Drew Freer, Beayna Grigorian, Collin Lambert, Alfonso Roman, Brian Soumakian

Introduction Motivation Massive integers computations are useful for science and research Difficult to achieve efficiently with standard computing resources E.g. GNU Multiple Precision Arithmetic Library Problem Big Integer Arithmetic Current limitations based on computer architecture

Introduction Goal Allow for arithmetic on operands of unlimited size Perform operations efficiently (parallelize!) Solution Utilize existing parallel programming frameworks Implement new integer representation: BigInt Support common operations: Addition, Subtraction, Multiplication, Division Bitwise AND, Bitwise OR, Bitwise XOR, Bitwise NOT Left-Shift, Right-Shift, Equality-Test

Design Overview Sign-and-Magnitude representation Array of integers w/ MSB used as carry bit (overflow) Multiplication: Shift-and-Add Division: Shift-and-Subtract Key Insight: Delayed Carry-Ripple! I.E. Exploit arithmetic on un-normalized values Mostly beneficial for addition and multiplication Only normalize when absolutely necessary (e.g. comparisons, print value, etc.)

Design Overview: BigInt Repr.

Parallel Programming OpenMP Need to compute massive amounts of data  Ideal problem for data decomposition OpenMP simplifies data decomposition Loop iterations easily divided amongst threads (#pragma omp parallel for) Static, dynamic, and guided Automated reductions Easy to compare sequential vs. parallel execution

Division of Tasks Development BigInt Structure: Brian & Drew Addition & Subtraction: Drew Multiplication & Division: Collin & Beayna Bitwise Ops & Equality-Test: Alfonso Left-Shift & Right-Shift: Brian Testing & Code Review Everyone!

Progress Basic Functionality Parse & Print Values: Complete. Bitwise Ops & Equality: Complete. Addition & Multiplication: Complete. Left-Shift & Right-Shift: Complete. Subtraction & Division: Started… Optimizations Drafted Ready for implementation

Challenges & Bugs Design Challenges Minimize memory usage (avoid unnecessary allocations) Aliasing issues (e.g. a+b = a) Minimize sequential tasks (i.e. normalization) Expose algorithmic shortcuts (e.g. a+0=a) Appropriate handling of boundary cases Interesting Bugs Unintentional deallocation of result pointers Memory swapping Masking and shifting

Results * 5000 Chunks = ± 2 31*625 * 1,000,000 Chunks = ± 2 31*1250