@everywhere function minimum_maximum_serial(a,s,e) if s==e [a[s], a[s]] else mid = ifloor((s+e)/2) X = minimum_maximum_serial(a,s,mid) Y = minimum_maximum_serial(a,mid+1,e) [min(X[1],Y[1]), max(X[2],Y[2])] end end @everywhere function minimum_maximum_parallel(a,s,e) if (e-s)<=10000000 minimum_maximum_serial(a,s,e) else mid = ifloor((s+e)/2) R = @spawn minimum_maximum_parallel(a,s,mid) Y = minimum_maximum_parallel(a,mid+1,e) X = fetch(R) [min(X[1],Y[1]), max(X[2],Y[2])] end end a=rand(20000000); @time minimum_maximum_serial(a,1,20000000) @time minimum_maximum_parallel(a,1,20000000) ## As you can see the function minimum_maximum_parallel ## seems twice faster than the function minimum_maximum_serial ## Meanwhile the function maximum_parallel seems clearly ## slower than maximum_serial. In addition maximum_serial ## is about 10 times faster than minimum_maximum_parallel ## In fact the main issue with minimum_maximum_serial ## and minimum_maximum_paralle is that they create a ## lot of intermediate arrays (all with two elements) ## while maximum_serial and maximum_parallel do not ## allocate intermediate memrory chunks. ## Thus intermediate array allocation can slow down ## computations terribly. ## Also, as we have said in class, this problem is ## essentially memory-bound and thus not so well-suited ## for multi-core arhcitectures