[GHC] #14980: Runtime performance regression with binary operations on vectors

[GHC]

#14980: Runtime performance regression with binary operations on vectors
-------------------------------------+-------------------------------------
        Reporter:  ttylec            |                Owner:  bgamari
            Type:  bug               |               Status:  new
        Priority:  high              |            Milestone:  8.8.1
       Component:  Compiler          |              Version:  8.2.2
      Resolution:                    |             Keywords:  vector
                                     |  bitwise operations
Operating System:  Unknown/Multiple  |         Architecture:
 Type of failure:  Runtime           |  Unknown/Multiple
  performance bug                    |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by tdammers):

 OK, some more experimenting.

 Changed the .cabal file to force `vector` to `0.12.0.1` (the latest
 version on hackage); no difference, results are still more or less the
 same on both compilers.

 Also managed to get things built with stack; the 8.2 results are also very
 similar:

 {{{
 "Generated"
 benchmarking 64 columns/raw unbox vectors
 time                 443.6 μs   (443.2 μs .. 443.9 μs)
                      1.000 R²   (1.000 R² .. 1.000 R²)
 mean                 441.6 μs   (441.2 μs .. 442.0 μs)
 std dev              1.364 μs   (1.092 μs .. 1.738 μs)

 benchmarking 64 columns/binary packed
 time                 51.35 μs   (51.29 μs .. 51.44 μs)
                      1.000 R²   (1.000 R² .. 1.000 R²)
 mean                 51.07 μs   (51.00 μs .. 51.18 μs)
 std dev              265.9 ns   (176.1 ns .. 453.5 ns)

 benchmarking 256 columns/raw unbox vectors
 time                 446.1 μs   (445.5 μs .. 447.2 μs)
                      1.000 R²   (1.000 R² .. 1.000 R²)
 mean                 443.9 μs   (443.4 μs .. 444.6 μs)
 std dev              1.883 μs   (1.337 μs .. 3.374 μs)

 benchmarking 256 columns/binary packed
 time                 291.2 μs   (286.2 μs .. 296.9 μs)
                      0.998 R²   (0.998 R² .. 0.999 R²)
 mean                 298.3 μs   (294.2 μs .. 301.2 μs)
 std dev              7.891 μs   (5.688 μs .. 10.20 μs)
 variance introduced by outliers: 15% (moderately inflated)
 }}}

 Stack-installed, with 8.0.2:

 {{{
 "Generated"
 benchmarking 64 columns/raw unbox vectors
 time                 412.3 μs   (411.7 μs .. 413.1 μs)
                      1.000 R²   (1.000 R² .. 1.000 R²)
 mean                 412.4 μs   (412.0 μs .. 413.1 μs)
 std dev              1.643 μs   (1.124 μs .. 2.815 μs)

 benchmarking 64 columns/binary packed
 time                 21.89 μs   (21.87 μs .. 21.90 μs)
                      1.000 R²   (1.000 R² .. 1.000 R²)
 mean                 21.90 μs   (21.89 μs .. 21.91 μs)
 std dev              38.13 ns   (26.94 ns .. 54.15 ns)

 benchmarking 256 columns/raw unbox vectors
 time                 417.6 μs   (416.0 μs .. 419.5 μs)
                      1.000 R²   (1.000 R² .. 1.000 R²)
 mean                 417.2 μs   (416.5 μs .. 419.1 μs)
 std dev              3.403 μs   (935.8 ns .. 6.896 μs)

 benchmarking 256 columns/binary packed
 time                 29.56 μs   (29.51 μs .. 29.63 μs)
                      1.000 R²   (1.000 R² .. 1.000 R²)
 mean                 29.52 μs   (29.51 μs .. 29.56 μs)
 std dev              71.00 ns   (36.37 ns .. 131.9 ns)
 }}}

 So apparently compiling with 8.0.2 through cabal gives different results
 than compiling though stack. Strange.

-- 
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14980#comment:9>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler