concurrency-benchmarks alternatives and similar packages
Based on the "Benchmark" category.
Alternatively, view concurrency-benchmarks alternatives based on common mentions on social networks and blogs.
Benchmarks to compare Haskell streaming library performance
Do you think we are missing an alternative of concurrency-benchmarks or a related project?
Benchmarks to compare the concurrency overhead of
concurrent streamly streams and the
async package. If you are familiar
async, see this quick
equivalent features of streamly. For more detailed introduction to streamly see
How to run
run.sh script to run the benchmarks and create the charts. You can
cabal new-bench or
stack bench to run the benchmarks. To generate
charts, run the benchmarks with
--csv-raw=results.csv option and then run
makecharts results.csv. Charts are generated in the
IMPORTANT NOTE: THE
maxrss FIGURES REPORTED BY GAUGE WILL NOT BE CORRECT
UNLESS YOU RUN ONE BENCHMARK AT A TIME. This is because
maxrss is tracked per
A total of 10,000 tasks are run for each concurrency mechanism being compared. Two independent experiments are performed:
- In the first experiment, each task is just a noop i.e. it takes almost 0 time to execute.
- In the second experiment, each task introduces a 5 second delay
The first case shows streamly's smart scheduling to automatically run the tasks in less number of threads than the actual number of tasks. When the tasks do not block and have a very low latency, streamly may run multiple tasks per thread. Therefore streamly is much faster on this benchmark.
In the second case a 5 second delay is introduced to make sure that streamly
uses one thread per task which is similar to what
async does and therefore a
fair comparison. For the
mapConcurrently is used which can
be compared with streamly's
ahead style stream.
For streamly this is the code that is benchmarked, by default streamly has a
limit on the buffer size and the number of threads, we set those limits to
which means there is no limit:
let work = (\i -> threadDelay 5000000 >> return i) in runStream $ aheadly $ maxBuffer (-1) $ maxThreads (-1) $ S.fromFoldableM $ map work [1..10000]
async this is the code that is benchmarked:
let work = (\i -> threadDelay 5000000 >> return i) mapConcurrently work [1..10000]
These charts compare
async-2.2.1 on a MacBook Pro with a 2.2 GHz Intel Core i7 processor.
-threaded -with-rtsopts "-N" GHC options were used to enable
the use of multiple processor cores in parallel.
For streamly, results for both
ahead style streams are shown.
Zero delay case
Peak Memory Consumed
5 second delay case
Peak Memory Consumed
Note, this time shows the overhead only and not the full time taken by the
benchmark. For example the actual time taken by the
async benchmark is
5.135 seconds, but since 5 second in this is the delay introduced by each
parallel task, we compute the overhead of concurrency by deducting the 5
seconds from the actual time taken, so the overhead is
135 ms in case of
Feedback is welcome. Please raise an issue, send a PR or send an email to the author.