Changes between Version 51 and Version 52 of DataParallel/BenchmarkStatus


Ignore:
Timestamp:
Dec 2, 2010 3:43:11 AM (3 years ago)
Author:
benl
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • DataParallel/BenchmarkStatus

    v51 v52  
    99The benchmarks are run each night by [http://darcs.haskell.org/packages/dph/dph-buildbot DPH BuildBot]. The results are posted to cvs-ghc and uploaded to [http://log.ouroborus.net/limitingfactor/dph/]. Check there for the latest numbers. 
    1010 
     11[[br]] 
     12= Summary = 
     13 * Evens gets slower as number of threads increases, probably because it's using a filtering operation. 
     14 * !QuickHull is 4x slower than the immutable Data.Vector version in absolute terms. This may be related to the problem with Evens. 
     15 * Vectorised sequential !QuickSort doesn't compile due to a blow-up in !SpecConstr. 
     16 * Vectorised NBody has a core-lint error due to a bug in the rule matcher. If you turn off -dcore-lint it segfaults when run. 
     17 
    1118!ToDo: Benchmarks are currently being run with -fasm, and not via the LLVM backend. This will affect comparisons with C, but not with Data.Vector as it uses the same backend. 
    1219 
    13 = Key = 
    14 <project>.<benchmark>.<version>.<parallelism>.<threads> 
     20[[br]] 
     21---- 
     22= Flat Parallelism = 
    1523 
    16 Project 
    17  * Either ''dph'' or ''repa''. Repa programs use the same parallel array library as DPH, but do not go through the vectorising transform. 
    18  
    19 Version 
    20  * ''vectorised'' means it's been through the DPH vectorising transform.  
    21  * ''vector'' is a hand written version using immutable Data.Vectors 
    22  * ''vector-mutable'' is a hand written version using mutable Data.Vectors. 
    23  * ''vector-immutable'' means the same as ''vector'' and is used when there is also an mutable version. 
    24  
    25 Parallelism  
    26  * Whether a benchmark is natively parallel or sequential.  
    27  * Parallel versions are also run single threaded (with -N1) and sequential versions are also run with (-N4) so we get the parallel GC. 
    28  * Parallel versions with -N1 will tend to be slower than natively sequential versions due to overheads for supporting parallelism. 
    29  
    30 Status 
    31  * '''BROKEN''': Benchmark doesn't compile, or crashes when run. 
    32  * '''SLOWDOWN''': Benchmark gets slower as number of threads increases.  
    33  * '''SLOWLORIS''': Benchmark scales as the number of threads increases, but the absolute performance is not acceptable compared with equivalent versions using immutable Data.Vectors. 
     24Todo: add Repa benchmarks. 
    3425 
    3526  
    3627[[br]] 
    37 = Statically Nested = 
     28= Statically Nested Parallelism = 
    3829Statically nested parallelism is where the parallelism has a fixed, finite depth. For example ``mapP f (filterP g xs)``. Statically nested programs are easier to vectorize than dynamically nested programs. At present, single threaded statically nested programs should run as fast as equivalent Data.Vector programs. Parallel versions should display a good speedup. 
    3930 
     
    8778 
    8879[[br]] 
    89 = Dynamically Nested = 
     80= Dynamically Nested Parallelism = 
    9081Dynamically nested programs have a recursive structure where each level of the recursion invokes more parallel computations. This is common for benchmarks that use divide-and-conquer style algorithms. 
    9182 
     
    116107 
    117108[[br]] 
    118 = Dynamically Nested with Algebraic Data Types = 
     109= Dynamically Nested Parallelism with Algebraic Data Types = 
    119110These programs also use user defined algebraic data types. Vectorization of these programs is still a work in progress. 
    120111 
    121112 [http://darcs.haskell.org/packages/dph/dph-examples/barnesHut/ BarnesHut]:: 
    122113  This benchmark implements the Barnes-Hut algorithm to solve the ''n''-body problem in two dimensions.  '''Currently won't compile with vectorisation due to excessive inlining of dictionaries.''' 
     114 
     115[[br]] 
     116---- 
     117---- 
     118= Key = 
     119<project>.<benchmark>.<version>.<parallelism>.<threads> 
     120 
     121Project 
     122 * Either ''dph'' or ''repa''. Repa programs use the same parallel array library as DPH, but do not go through the vectorising transform. 
     123 
     124Version 
     125 * ''vectorised'' means it's been through the DPH vectorising transform.  
     126 * ''vector'' is a hand written version using immutable Data.Vectors 
     127 * ''vector-mutable'' is a hand written version using mutable Data.Vectors. 
     128 * ''vector-immutable'' means the same as ''vector'' and is used when there is also an mutable version. 
     129 
     130Parallelism  
     131 * Whether a benchmark is natively parallel or sequential.  
     132 * Parallel versions are also run single threaded (with -N1) and sequential versions are also run with (-N4) so we get the parallel GC. 
     133 * Parallel versions with -N1 will tend to be slower than natively sequential versions due to overheads for supporting parallelism. 
     134 
     135Status 
     136 * '''BROKEN''': Benchmark doesn't compile, or crashes when run. 
     137 * '''SLOWDOWN''': Benchmark gets slower as number of threads increases.  
     138 * '''SLOWLORIS''': Benchmark scales as the number of threads increases, but the absolute performance is not acceptable compared with equivalent versions using immutable Data.Vectors. 
    123139 
    124140[[br]]