POLY : A new polynomial data structure for Maple 17 that improves parallel speedup.

Transcription

1 : A new polynomial data structure for Maple 7 that improves parallel speedup. Department of Mathematics, Simon Fraser University British Columbia, CANADA Parallel Computer Algebra Applications ACA 22, Sofia, Bulgaria June 25-28, 22 This is joint work with Roman Pearce.

2 Talk Outline Polynomial data structures in Maple and Singular are slow. Our data structure.

3 Talk Outline Polynomial data structures in Maple and Singular are slow. Our data structure. Johnson s polynomial multiplication using a heap from 973. Our parallelization of it. A multiplication and factorization benchmark in Maple 6.

4 Talk Outline Polynomial data structures in Maple and Singular are slow. Our data structure. Johnson s polynomial multiplication using a heap from 973. Our parallelization of it. A multiplication and factorization benchmark in Maple 6. Why is parallel speedup poor? Solution and new timings.

5 Talk Outline Polynomial data structures in Maple and Singular are slow. Our data structure. Johnson s polynomial multiplication using a heap from 973. Our parallelization of it. A multiplication and factorization benchmark in Maple 6. Why is parallel speedup poor? Solution and new timings. Notes on integration into Maple kernel for Maple 7. Conclusion

6 Representations for 9 xy 3 z 4 y 3 z 2 6 xy 2 z 8 x 3 5. PROD 7 x y 3 z Maple 6 PROD 5 y 3 z PROD 7 x 2 y 2 z PROD 3 x 3 SUM

7 Representations for 9 xy 3 z 4 y 3 z 2 6 xy 2 z 8 x 3 5. PROD 7 x y 3 z Maple 6 PROD 5 y 3 z PROD 7 x 2 y 2 z PROD 3 x 3 SUM Singular 3. x y z Memory access is not sequential. Monomial multiplication costs O() cycles.

8 Our representation 9 xy 3 z 4 y 3 z 2 6 xy 2 z 8 x 3 5. SEQ 4 x y z Monomial encoding for graded lex order with x>y >z Encodes x i y j z k in a single word d i j k where d = i+j+k. Advantages

9 Our representation 9 xy 3 z 4 y 3 z 2 6 xy 2 z 8 x 3 5. SEQ 4 x y z Monomial encoding for graded lex order with x>y >z Encodes x i y j z k in a single word d i j k where d = i+j+k. Advantages It s more compact. Memory access is sequential. Fewer objects to clutter tables. Monomial > and cost one instruction.

10 Multiplication using a binary heap. Let f = f + f f n and g = g + g g m. Compute f g = f g + f 2 g + + f n g. Johnson, 974, does a simultaneous n-ary merge using a heap.

11 Multiplication using a binary heap. Let f = f + f f n and g = g + g g m. Compute f g = f g + f 2 g + + f n g. Johnson, 974, does a simultaneous n-ary merge using a heap. add f 2 g f g +... f g2 Heap f x f 2 x f 3 x fn x ( g + g 2 + g g m) ( g + g 2 + g g m) ( g + g 2 + g g m). ( g + g 2 + g g m ) Heap n = O(nm log n) comparisons. Can pick n m. Algorithm outputs f g in descending order.

12 Target Parallel Architecture Intel Core i7, quad core, shared memory.

13 Parallel Multiplication Algorithm Global Heap Local Heaps 2 3 f g One heap per core. Add (merge) results in global heap. 4

14 Parallel Multiplication Algorithm Global Heap Local Heaps 2 3 f g One heap per core. Add (merge) results in global heap. 4 Threads write to a finite circular buffer. N r w r mod N w mod N Threads try to acquire global heap as buffer fills up to balance load.

15 Old multiplication and factorization benchmark. Intel Core i GHz (4 cores) Times in seconds Maple Maple 6 Magma Singular Mathem multiply 3 core 4 cores atica 7 p := f (f + ) p 3 := f 3(f 3 + ) p 4 := f 4(f 4 + ) factor Hensel lifting is mostly polynomial multiplication!! p 234 terms p terms p terms f = ( + x + y + z) 2 + f 3 = ( + x + y + z) 3 + f 4 = ( + x + y + z + t) terms 5456 terms 626 terms The Maple timings are for expand(f*(f+)) and factor(p).

16 Maple Integration To expand sums f g Maple calls expand/bigprod(f,g) if #f > 2 and #g > 2 and #f #g > 5. expand/bigprod := proc(a,b) # multiply two large sums if type(a,polynom(integer)) and type(b,polynom(integer)) then x := indets(a) union indets(b); k := nops(x); A := sdmp:-import(a, plex(op(x)), pack=k); B := sdmp:-import(b, plex(op(x)), pack=k); C := sdmp:-multiply(a,b); return sdmp:-export(c); else... expand/bigdiv := proc(a,b,q) # divide two large sums... x := indets(a) union indets(b); k := nops(x)+; A := sdmp:-import(a, grlex(op(x)), pack=k); B := sdmp:-import(b, grlex(op(x)), pack=k);...

17 Almost everything is slow. PROD 7 x y 3 z PROD 5 y 3 z 2 PROD 7 x y 2 z PROD 3 x 3 SUM Many operations cost O(nt). [ n = #variables, t = #terms ] E.g. indets(f); degree(f,x); coeff(f,x,i); Some operations add sorting cost of O(t.25 ). E.g. diff(f,x); expand(x*f); taylor(f,x,d);

18 Make the default representation in Maple. If we can pack all monomials into one word use SEQ 4 x y z O() O(n) O(n + t) degree(f); lcoeff(f); indets(f); has(f,z); type(f,polynom(integer)); degree(f,x); expand(x*t); diff(f,x); For f with t terms in n variables.

19 Almost everything is fast. command Maple 6 Maple 7 speedup notes coeff(f, x, 2) 2.4 s.5 s 42x terms easy to locate coeffs(f, x).979 s.9 s 8x reorder exponents and radix frontend(g, [f ]) 3.73 s. s O(n) looks at variables only degree(f, x).73 s.3 s 24x stop early using monomial de diff(f, x).956 s.3 s 3x terms remain sorted eval(f, x = 6) 3.76 s.75 s 2x use Horner form recursively expand(2 x f ).9 s.66 s 8x terms remain sorted indets(f ).6 s. s O() first word in dag subs(x = y, f ).6 s.76 s 5x combine exponents, sort, me taylor(f, x, 5).668 s.55 s 2x get coefficients in one pass type(f, polynom).29 s. s O(n) type check variables only For f with n = 3 variables and t = 6 terms created by f := expand(mul(randpoly(v,degree=,dense),v=[x,y,z])):

20 New multiplication and factorization benchmark. Intel Core i GHz (4 cores) Times in seconds Maple 6 Maple 7 Magma Singular multiply core 4 cores core 4 cores p := f (f + ) p 3 := f 3(f 3 + ) p 4 := f 4(f 4 + ) factor Hensel lifting is mostly polynomial multiplication. p 234 terms p terms p terms f = ( + x + y + z) 2 + f 3 = ( + x + y + z) 3 + f 4 = ( + x + y + z + t) terms 5456 terms 626 terms More benchmarks and details available in preprint.

21 Profile for factor(p); Profile for factor(p); Real time from 2.63s to.s real. Maple 6 New Maple function #calls time time% time time% coeftayl s s expand s s 3.9 factor/diophant s s 3.76 divide s s 4.56 factor.26s s.4 factor/hensel.4s s 6.22 factor/unifactor 2.55s s 3.57 total: s.%.26s.% The coeftayl(f,x=a,k); command is defined by coeff(taylor(f,x=a,k+),x,k); and is computed via eval(diff(f,x$k),x=a) / k! which is 4x faster.

22 Notes on the new integration for Maple 7. Let f R[x, x 2,..., x n ] with deg xi f >. We store f using if (i) f has integer coefficients (ii) d > and t > where d = deg f and t = #terms. (iii) we can pack all monomials of f into one 64 bit word, i.e. if d < 2 b where b = 64 n+ Otherwise we use the old sum-of-products representation.

23 Notes on the new integration for Maple 7. Let f R[x, x 2,..., x n ] with deg xi f >. We store f using if (i) f has integer coefficients (ii) d > and t > where d = deg f and t = #terms. (iii) we can pack all monomials of f into one 64 bit word, i.e. if d < 2 b where b = 64 n+ Otherwise we use the old sum-of-products representation. Packing is fixed by n = #variables. If n = 8, (iii) = we use b = 64/9 = 7 bits per exponent field hence restricts d < 28. The representation is invisible to the Maple user. Conversions are automatic. polynomials will be displayed in sorted order.

24 Conclusion We will not get good parallel speedup using these PROD 7 x y 3 z PROD 5 y 3 z 2 PROD 7 x y 2 z PROD 3 x 3 SUM x y z Thank you for attending my talk.