Allowed inlining for traverseWithIndex (#623)
authorDonnacha Oisín Kidney <oisdk@users.noreply.github.com>
Fri, 12 Apr 2019 00:54:22 +0000 (01:54 +0100)
committerGitHub <noreply@github.com>
Fri, 12 Apr 2019 00:54:22 +0000 (01:54 +0100)
commit18639286b2030189b246d5f914765584b2113cc9
treeac2dc496035ebec9d995393fa0fba78e0bd62008
parent121df4af49ba48c79a19e3b3d60c1e4d705d05af
Allowed inlining for traverseWithIndex (#623)

* Allowed inlining for traverseWithIndex

Switched NOINLINE to INLINE:
- Ideally this would be INLINABLE, but that can't have phase controls
- This is the next best, which gets the proper performance benefits and also the phase controles so the rewrite rules still fire properly

Because this was prompted by sequenceA.mapWithIndex being faster, a benchamrk of that operation has been added to compare.

* INLINABLE can have phase controls

As it turns out, INLINABLE *can* have phase controls.

Benchmarks so no real change:

benchmarking traverseWithIndex/State/10
time                 368.6 ns   (364.2 ns .. 372.2 ns)
                     0.999 R²   (0.999 R² .. 1.000 R²)
mean                 366.6 ns   (363.2 ns .. 370.0 ns)
std dev              11.56 ns   (9.593 ns .. 14.54 ns)
variance introduced by outliers: 46% (moderately inflated)

benchmarking traverseWithIndex/State/100
time                 4.730 μs   (4.663 μs .. 4.796 μs)
                     0.999 R²   (0.998 R² .. 0.999 R²)
mean                 4.702 μs   (4.660 μs .. 4.752 μs)
std dev              149.9 ns   (123.3 ns .. 192.9 ns)
variance introduced by outliers: 40% (moderately inflated)

benchmarking traverseWithIndex/State/1000
time                 65.15 μs   (64.31 μs .. 66.13 μs)
                     0.999 R²   (0.998 R² .. 0.999 R²)
mean                 66.58 μs   (65.80 μs .. 67.65 μs)
std dev              3.082 μs   (2.343 μs .. 4.561 μs)
variance introduced by outliers: 50% (moderately inflated)

benchmarking sequenceA.mapWithIndex/State/10
time                 597.8 ns   (589.4 ns .. 606.8 ns)
                     0.998 R²   (0.997 R² .. 0.999 R²)
mean                 602.1 ns   (595.9 ns .. 610.4 ns)
std dev              23.84 ns   (17.59 ns .. 38.02 ns)
variance introduced by outliers: 56% (severely inflated)

benchmarking sequenceA.mapWithIndex/State/100
time                 5.915 μs   (5.854 μs .. 6.023 μs)
                     0.998 R²   (0.997 R² .. 0.999 R²)
mean                 6.006 μs   (5.939 μs .. 6.078 μs)
std dev              235.9 ns   (199.3 ns .. 285.5 ns)
variance introduced by outliers: 50% (moderately inflated)

benchmarking sequenceA.mapWithIndex/State/1000
time                 83.08 μs   (81.80 μs .. 84.81 μs)
                     0.998 R²   (0.998 R² .. 0.999 R²)
mean                 83.78 μs   (83.04 μs .. 84.50 μs)
std dev              2.604 μs   (2.277 μs .. 3.018 μs)
variance introduced by outliers: 30% (moderately inflated)

* put INLINABLE behind a macro
Data/Sequence/Internal.hs
benchmarks/Sequence.hs