ANN: Paraffin 3.2

ANN: Paraffin 3.2

[Brad Moore]

I am pleased to announce the availability of Paraffin 3.2

I know it's only been a few days since the 3.1 release, but
I applied the same technique that improved iterative work stealing
to iterative work seeking, and found some somewhat improved
results, plus a bigger improvement in ease of use. More details
below.

Paraffin is a set of Ada 2005 generics that may be used to add
parallelism to iterative loops and recursive code.

Paraffin also includes a suit of useful parallel utilities that
utilize the Paraffin generics. These include generics for;
    1) generic to integrating a function in parallel
    2) generic to apply quicksort algorithm in parallel to an array
    3) generic to apply fast fourier transform to an array of data.
    4) generic Red-Black tree container that performs some operations
       in parallel.
    5) function to solve matrices using Gauss-Jordan Elimination

The latest stable release and older releases may be downloaded from;

  https://sourceforge.net/projects/paraffin/files/

For those who want the current development versions of the source they
can download using git (http://git-scm.com/) by issuing the following
commands;

  mkdir sandbox
  cd sandbox
  git clone git://paraffin.git.sourceforge.net/gitroot/paraffin/paraffin

The current development version typically will correspond to the latest
stable release, but may at times be unstable when new features are being
worked on.

Major Changes since the last announced release: (was version 3.1)

- The same technique that was applied to iterative work stealing that
   significanly improved performance, was also applied to the work
   seeking generics, which also resulted in some performance gains.
- Another benefit of this change is that the work seeking mechanisms
   are now more hidden inside the generic, and not exposed to client
   code.
   As a result, the modifications needed to parallelize a sequential
   loop is the same for work-sharing, work-seeking, and work-stealing.
   It mostly just involves wrapping the loop in a nested procedure,
   and then passing the start and finish indexes of the loop as
   parameters to the nested procedure.
- A Minimum_Seek parameter replaces the Other_Workers parameter. This
   parameter indicates the minimum number of iterations that can be
   "seeked" at one time by an idle worker. This parameter can be left
   unspecified, in which case, a reasonable default will automatically
   be assigned.
- As a result of these changes, the Work-seeking iterative tests
   generally seem to out perform work-stealing, although the differences
   are usually quite marginal. There are still tests where work-sharing
   can be best choice, and other tests where work-stealing can come out
   ahead.

  Sample test results for a Quadcore AMD processor running Ubuntu.

./test_paraffin 2_000_000_000 43

************* Parallel Framework Test *************
   Physical Processors= 4
   DEFAULT_WORKER_COUNT= 4
   USE_AFFINITY=FALSE
   WORK_BUDGET_FOR_EVEN_LOADS=-1
   WORK_BUDGET_FOR_UNEVEN_LOADS=-1
   ONLY_TEST_FIBONACCI=FALSE
   MAX_STACK_LIMIT= 2147483647
   MAX_STACK_DEPTH= 90
   WORKER_STORAGE_SIZE= 2097152
   PARALLEL_TREE_PARALLELISM_DEPTH= 20
   FIBONACCI_PARALLELISM_LIMIT= 22
   FIBONACCI_PARALLELISM_DEPTH_LIMIT= 10
   RUN_UNBALANCED_ITERATION=TRUE
   RUN_DOUBLE_FIBONACCI=FALSE
   MIN_STEAL= 0
   MIN_SEEK= 0
   PARALLEL_DEBUG_ENABLED=FALSE
***************************************************

****** I T E R A T O R   T E S T S ******

** Sequential Integer Sum =  2321730048, Elapsed = 00:00:06.29
** Manual Parallel Sum = 2321730048
** Work Sharing Parallel Integer Sum =  2321730048, Elapsed = 00:00:01.32
** Work Seeking Parallel Integer Sum =  2321730048, Elapsed = 00:00:01.37
** Work Stealing Parallel Integer Sum =  2321730048, Elapsed = 00:00:01.50
** Sequential Integer Composite Monoid Sum =  2321730048, Elapsed = 
00:00:11.21
** Work Sharing Integer Composite Monoid Sum =  2321730048, Elapsed = 
00:00:03.15
** Work Seeking Parallel Integer Composite Monoid Sum =  2321730048, 
Elapsed = 00:00:02.99
** Work Stealing Parallel Integer Composite Monoid Sum =  2321730048, 
Elapsed = 00:00:03.20
** Sequential Elementary Float Sum =  5.49756E+11, Elapsed = 00:00:09.64
** Work Sharing Elementary Float Sum =  1.23695E+12, Elapsed = 00:00:02.70
** Work Seeking Parallel Elementary Float Sum =  1.36602E+12, Elapsed = 
00:00:02.63
** Work Stealing Parallel Elementary Float Sum =  1.23695E+12, Elapsed = 
00:00:02.72
** Parallel Integer Work Sharing Iterate, Elapsed = 00:00:06.35
** Parallel Integer Work Seeking Iterate, Elapsed = 00:00:06.41
** Parallel Integer Work Stealing Iterate, Elapsed = 00:00:06.36
** Parallel Integer Work Sharing Find: Is Prime = FALSE, Factor =  8719, 
Elapsed = 00:00:00.00
** Parallel Integer Work Seeking Find: Is Prime = FALSE, Factor =  8719, 
Elapsed = 00:00:00.00
** Parallel Integer Work Stealing Find: Is Prime = FALSE, Factor = 
8719, Elapsed = 00:00:00.00

******* R E C U R S I O N   T E S T S *******


(- Functional Fibonacci Integer Reduction -)

** Sequential Iterative Fibonacci of 43 is 433494437, Elapsed = 00:00:00.00
** Sequential Recursive Fibonacci of 43 is 433494437, Elapsed = 00:00:05.37
** Recursive Elementary Work Sharing Fibonacci of 43 is 433494437, 
Elapsed = 00:00:02.67
** Recursive Elementary Work Seeking Fibonacci of 43 is 433494437, 
Elapsed = 00:00:01.79
** Recursive Elementary Work Seeking Depth Fibonacci of 43 is 433494437, 
Elapsed = 00:00:02.06
** Recursive Stack Safe Elementary Work Seeking Fibonacci of 43 is 
433494437, Stack Limit Reached 0 times , Elapsed = 00:00:02.47

(- Procedural Fibonacci Integer Reduction -)

** Sequential Composite Recursive Fibonacci of 43 is 433494437, Elapsed 
= 00:00:07.16
** Recursive Composite Work Sharing Fibonacci of 43 is 433494437, 
Elapsed = 00:00:02.94
** Recursive Composite Work Seeking Fibonacci of 43 is 433494437, 
Elapsed = 00:00:02.45
** Recursive Stack Safe Composite Work Seeking Fibonacci of 43 is 
433494437, Stack Limit Reached 0 times , Elapsed = 00:00:02.70


Brad Moore