This allows different implementations of Haskell code to be compared to each other.
Each table compares different implementations of the same functionality on different inputs (for all the tests so far the input is the size of data to use).
Each column compares 2 implementations. The number in each cell is how many times longer the second took than the first. For example, suppose that with input 100 A takes 10s and B takes 12s. Then the table would look like:
| A -> B | |
|---|---|
| 100 | 1.20 |
Failures, defined as being 1.1 times slower, are shown like this.
If the second implementation is 1.1 times faster then it is shown like this.
Find the first space (character with value 32) in a chunk of memory
| Base -> BarelyHaskell | BarelyHaskell -> Haskell | |
|---|---|---|
| 0 | 0.98 | 1.00 |
| 1 | 0.99 | 1.00 |
| 10 | 0.99 | 1.00 |
| 100 | 1.00 | 1.01 |
| 1000 | 1.16 | 0.96 |
| 10000 | 1.83 | 0.88 |
| 100000 | 2.85 | 0.83 |
| 1000000 | 2.28 | 0.84 |
| 10485760 | 2.21 | 0.88 |
Find the first white space character (character with value 32, 9, 13 or 10) in a chunk of memory
| Base -> BarelyHaskell | BarelyHaskell -> Haskell | Haskell -> NicerHaskell | |
|---|---|---|---|
| 0 | 0.97 | 1.00 | 1.03 |
| 1 | 0.98 | 0.99 | 1.04 |
| 10 | 0.99 | 1.00 | 1.12 |
| 100 | 1.01 | 0.99 | 1.89 |
| 1000 | 1.15 | 0.98 | 7.67 |
| 10000 | 1.62 | 0.95 | 19.02 |
| 100000 | 2.01 | 0.93 | 22.46 |
| 1000000 | 2.01 | 0.93 | 22.33 |
| 10485760 | 2.02 | 0.93 | 22.42 |
Make a reversed copy of a chunk of memory
| Base -> BarelyHaskell | BarelyHaskell -> Haskell | BarelyHaskell -> Haskell2 | |
|---|---|---|---|
| 0 | 1.00 | 1.35 | 1.31 |
| 1 | 1.01 | 1.34 | 1.29 |
| 10 | 1.01 | 1.40 | 1.34 |
| 100 | 1.03 | 1.68 | 1.61 |
| 1000 | 1.21 | 3.27 | 3.11 |
| 10000 | 1.55 | 5.73 | 5.40 |
| 100000 | 1.67 | 4.09 | 3.73 |
| 1000000 | 1.82 | 4.24 | 3.87 |
| 10485760 | 2.02 | 4.34 | 4.08 |