import build.__simple_cpp_python as wow

import getopt

import math

import operator

import time

import sys

import matplotlib.pyplot as plt

from pathos import multiprocessing

from functools import reduce

from collections import defaultdict

from pandas import DataFrame

def python_inner_loop(M):

# computes pi/8 as a series

return reduce(operator.add, [1 / ((4*k + 1) * (4*k + 3)) for k in range(M)], 0)

def python_outer_loop(xf, N, M):

# computes the series of cos(n * theta) + sin(n * theta)

pool = multiprocessing.Pool()

v = pool.map(lambda n: math.cos((n+1) * xf(M)) + math.sin((n+1) * xf(M)), [n for n in range(N)])

return reduce(operator.add, v, 0)

def full_python(N, M):

return python_outer_loop(python_inner_loop, N, M)

def mixed_op(pool, lr, n, M):

lr[n] = pool.apply_async(lambda : python_inner_loop(M))

def mixed_get(lr, n):

return lr[n].get()

if __name__ == "__main__":

try:

options, remainder = getopt.getopt(sys.argv[1:],

"x:n:",

["xarg=", "narg="])

except getopt.GetoptError as err:

# print help information and exit:

print(err) # will print something like "option -a not recognized"

usage()

sys.exit(2)

N = 1000

for opt, arg in options:

if opt in ('-n', '--narg'):

n = int(arg)

start = time.time()

r = full_python(N, 10*N)

end = time.time()

print('full python result: ' + str(r) + ' in ' + str(end-start) + ' seconds')

start = time.time()

r = wow.full_cpp(N, 10*N)

end = time.time()

print('full c++ result: ' + str(r) + ' in ' + str(end-start) + ' seconds')

start = time.time()

r = wow.cpp_outer_loop_gil(lambda M: python_inner_loop(M), N, 10*N)

end = time.time()

print('mixed result (GIL): ' + str(r) + ' in ' + str(end-start) + ' seconds')

start = time.time()

pool = multiprocessing.Pool()

lr = [None]*N

r = wow.cpp_outer_loop_process(lambda n, M : mixed_op(pool, lr, n, M), lambda n : mixed_get(lr, n), N, 10*N)

pool.close()

end = time.time()

print('mixed result (process): ' + str(r) + ' in ' + str(end-start) + ' seconds')

x = math.pi / 8

r = 0.5 * ((1.0 / math.tan(x / 2)) - 1 + (math.sin(x * (N + 0.5)) - math.cos(x * (N + 0.5))) / math.sin(x / 2))

print('exact result: ' + str(r))

# Statistical analysis

print('Statistic analysis...')

N = 1000

d = defaultdict(list)

index = [100, 1000, 10000, 100000, 1000000]

for M in index:

print("N={0}, M={1}".format(N, M))

start = time.time()

full_python(N, M)

end = time.time()

ref = end - start

d['full_python'].append(1.0)

print(' full python:', str(end-start))

start = time.time()

wow.cpp_outer_loop_gil(lambda m: python_inner_loop(m), N, M)

end = time.time()

d['mixed_gil'].append(ref / (end - start))

print(' mixed gil:', str(end-start))

start = time.time()

pool = multiprocessing.Pool()

lr = [None]*N

wow.cpp_outer_loop_process(lambda n, m : mixed_op(pool, lr, n, m), lambda n : mixed_get(lr, n), N, M)

pool.close()

end = time.time()

d['mixed_process'].append(ref / (end - start))

print(' mixed process:', str(end-start))

start = time.time()

wow.full_cpp(N, M)

end = time.time()

d['full_cpp'].append(ref / (end - start))

print(' full cpp:', str(end-start))

df = DataFrame(data=d, index=index)

df.plot.bar(rot=0, logy=True)

plt.xlabel('M')

plt.ylabel('(log) speedup compared to full python')

plt.axhline(y=1, linewidth=3, color='gray', linestyle='dashed')

plt.savefig('comparison_M.png', transparent=True)

plt.show()

M = 10000

d = defaultdict(list)

index = [10, 100, 1000, 10000, 100000]

for N in index:

print("N={0}, M={1}".format(N, M))

start = time.time()

full_python(N, M)

end = time.time()

ref = end - start

d['full_python'].append(1.0)

print(' full python:', str(end-start))

start = time.time()

wow.cpp_outer_loop_gil(lambda m: python_inner_loop(m), N, M)

end = time.time()

d['mixed_gil'].append(ref / (end - start))

print(' mixed gil:', str(end-start))

start = time.time()

pool = multiprocessing.Pool()

lr = [None]*N

wow.cpp_outer_loop_process(lambda n, m : mixed_op(pool, lr, n, m), lambda n : mixed_get(lr, n), N, M)

pool.close()

end = time.time()

d['mixed_process'].append(ref / (end - start))

print(' mixed process:', str(end-start))

start = time.time()

wow.full_cpp(N, M)

end = time.time()

d['full_cpp'].append(ref / (end - start))

print(' full cpp:', str(end-start))

df = DataFrame(data=d, index=index)

df.plot.bar(rot=0, logy=True)

plt.xlabel('N')

plt.ylabel('(log) speedup compared to full python')

plt.axhline(y=1, linewidth=3, color='gray', linestyle='dashed')

plt.savefig('comparison_N.png', transparent=True)

plt.show()