Changes between Version 52 and Version 53 of DataParallel/BenchmarkStatus


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

--

Legend:

Unmodified
Added
Removed
Modified
  • DataParallel/BenchmarkStatus

    v52 v53  
    3939  || dph.sumsq.vectorised.par.N4 || 111ms || 3.63 || || 
    4040 
    41   '''Summary''': fine[[br]] 
     41  '''Status''': fine[[br]] 
    4242  '''Todo''': Add a sequential C version. 
    4343 
     
    5555  A: The sequential vectorised version is faster than with Data.Vector. Why was this? 
    5656 
    57   '''Summary''': fine.[[br]] 
     57  '''Status''': fine[[br]] 
    5858  '''Todo''': Add a sequential C version. 
    5959 
     
    6868  || dph.evens.vectorised.par.N4 || 859ms ||  1.25 || || 
    6969 
    70   '''Summary''': Benchmark runs slower when number of threads increases. This benchmark invokes {{{packByTag}}} due to the filtering operation. This is probably affecting Quickhull as it also uses filtering. [[br]]  
     70  '''Status''': Benchmark runs slower when number of threads increases. This benchmark invokes {{{packByTag}}} due to the filtering operation. This is probably affecting Quickhull as it also uses filtering. [[br]]  
    7171  '''Todo''': Fix slowdown. Add a sequential C version.  
    7272 
     
    8787 
    8888[[br]] 
     89 [http://darcs.haskell.org/libraries/dph/dph-examples/spectral/QuickSort/ QuickSort] '''(BROKEN)''':: 
     90  Sort a vector of doubles by recursively splitting the vector and sorting the two halves. This is a "fake" benchmark because we divide right down to two-point vectors and construct the result using copying append. A production algorithm would switch to an in-place sort once the size of the vector reaches a few thousand elements. 
     91 
     92  || '''name''' || '''runtime''' || '''speedup''' || '''notes''' || 
     93  || dph.quicksort.vectorised.par.N1 || 428ms ||  1 || || 
     94  || dph.quicksort.vectorised.par.N2 || 400ms ||  1.07 || || 
     95  || dph.quicksort.vectorised.par.N4 || 392ms ||  1.09 || || 
     96 
     97  '''Status''': Sequential vectorised version does not compile due to a blowup in !SpecConstr. 
     98 
     99[[br]] 
    89100 [http://darcs.haskell.org/libraries/dph/dph-examples/spectral/QuickHull/ Quickhull] '''(SLOWLORIS)''':: 
    90   Given a set of points (in a plane), compute the sequence of points that encloses all points in the set. This benchmark is interesting as it is the simplest code that exploits the ability to implement divide-and-conquer algorithms with nested data parallelism. 
     101  Given a set of points in the plane, compute the sequence of points that encloses all points in the set. This benchmark is interesting as it is the simplest code that exploits the ability to implement divide-and-conquer algorithms with nested data parallelism. 
    91102 
    92103 
     
    101112  || dph.quickhull.c.seq || 0.044s || 3.77 || || 
    102113 
    103   '''Status''': Benchmark scales but is 4x slower than version using immutable Data.Vectors. This benchmark is based around filtering operations, so the fact that Evens is also slow is probably related. 
     114  '''Status''': Benchmark scales but is 4x slower than version using immutable Data.Vectors. !QuickHull is based around filtering operations, so the fact that Evens is also slow is probably related. 
    104115 
    105  [http://darcs.haskell.org/packages/dph/examples/qsort/ Quicksort]:: 
    106   FIXME 
    107116 
    108117[[br]]