Changes between Version 51 and Version 52 of DataParallel/BenchmarkStatus


Ignore:
Timestamp:
Dec 2, 2010 3:43:11 AM (5 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]]