#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime | Unknown/Multiple performance bug | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Changes (by bgamari): * differential: Phab:D3265 => Phab:D3508 -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:1 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime | Unknown/Multiple performance bug | Test Case: Blocked By: | Blocking: Related Tickets: #13570 | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj):

The NCG currently implements the square root MachOp with an out-of-line call

Where is this choice made? E.g. I think the `sin` `MachOp` really generates a `sin` instruction. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | numeric/num009 Blocked By: | Blocking: Related Tickets: #13570 | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Ben Gamari ): In [changeset:"9ac22183e405773ea7147728e593edd78f30a025/ghc" 9ac22183/ghc]: {{{ #!CommitTicketReference repository="ghc" revision="9ac22183e405773ea7147728e593edd78f30a025" nativeGen: Use SSE2 SQRT instruction Reviewers: austin, dfeuer Subscribers: dfeuer, rwbarton, thomie GHC Trac Issues: #13629 Differential Revision: https://phabricator.haskell.org/D3508 }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:7 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: closed Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | numeric/num009 Blocked By: | Blocking: Related Tickets: #13570 | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Comment (by kavon): Replying to [comment:4 bgamari]:

It's made in the native code generator, `genCCall` in `compiler/nativeGen/X86/CodeGen.hs`. While we use the `fsin` instruction on i386, we don't on x86_64 (and i386 with `-msse2`).

If there is already x87 FPU instruction support in the NCG for x86-32, it might be profitable to reuse that support for x86-64 to speed up trig functions, etc. The simplest way I see it is to expand the foreign call into an instruction sequence that moves the float from XMM registers to the x87 stack, computes the value, and moves it back to XMM registers. This way we no longer have a C call in a potentially bad place. It's worth comparing x87 on modern processors against the assembly routine backing the C function first. It seems platforms like Skylake the x87 `fsin` takes 50-120 cycles [1], but I'm not sure about the library versions. If they're roughly equivalent, there's likely a benefit to eliding the C call. [1] http://www.agner.org/optimize/instruction_tables.pdf (Page 223 for Skylake x87) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:9 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: closed Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | numeric/num009 Blocked By: | Blocking: Related Tickets: #13570 | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Comment (by bgamari): For the record, I did a quick, rather unscientific, comparison of SSE2 and x87, {{{#!c++ #include #include #include #include <functional> const int N = 1e8; template void time_it(const char *name, std::function f, Args... args) { struct timespec start, end; clock_gettime(CLOCK_MONOTONIC, &start); f(args...); clock_gettime(CLOCK_MONOTONIC, &end); double t = (end.tv_nsec - start.tv_nsec) * 1e-9 + (end.tv_sec - start.tv_sec); printf("%s: %f seconds / %d = %f ns per iter\n", name, t, N, t / N / 1e-9); } static double test(double x) { double y = 0; for (int i=0; i(test), 0.0); return 0; } }}} For x87 I compiled this with, {{{ $ g++ -lm hi.cpp -O2 -std=c++11 -march=core2 -ffast-math -mfpmath=387 }}} Which produced (ignoring the epilogue responsible for preparing the return value) {{{#!objdump 0000000000000b00 <_ZL4libmd>: b00: f2 0f 11 44 24 f8 movsd %xmm0,-0x8(%rsp) b06: dd 44 24 f8 fldl -0x8(%rsp) b0a: b8 00 e1 f5 05 mov $0x5f5e100,%eax b0f: dd 05 53 01 00 00 fldl 0x153(%rip) # c68 <_ZTSPFddE+0xb> b15: d9 ee fldz b17: dd 05 53 01 00 00 fldl 0x153(%rip) # c70 <_ZTSPFddE+0x13> b1d: dd 05 55 01 00 00 fldl 0x155(%rip) # c78 <_ZTSPFddE+0x1b> b23: eb 0f jmp b34 <_ZL4libmd+0x34> b25: 0f 1f 00 nopl (%rax) b28: dc c2 fadd %st,%st(2) b2a: d9 ca fxch %st(2) b2c: d9 fe fsin b2e: d9 cb fxch %st(3) b30: d9 cc fxch %st(4) b32: d9 ca fxch %st(2) b34: d9 c2 fld %st(2) b36: 83 e8 01 sub $0x1,%eax b39: d8 c2 fadd %st(2),%st b3b: d9 cd fxch %st(5) b3d: de c4 faddp %st,%st(4) b3f: 75 e7 jne b28 <_ZL4libmd+0x28> ... }}} For SSE I compiled with, {{{ $ g++ -lm hi.cpp -O2 -std=c++11 -march=core2 -ffast-math }}} Which produced, {{{#!objdump 0000000000000b60 <_ZL4libmd>: b60: 53 push %rbx b61: 66 0f ef c9 pxor %xmm1,%xmm1 b65: bb 00 e1 f5 05 mov $0x5f5e100,%ebx b6a: 48 83 ec 10 sub $0x10,%rsp b6e: f2 0f 11 04 24 movsd %xmm0,(%rsp) b73: f2 0f 10 05 5d 01 00 movsd 0x15d(%rip),%xmm0 # cd8 <_ZTSPFddE+0xb> b7a: 00 b7b: eb 1e jmp b9b <_ZL4libmd+0x3b> b7d: 0f 1f 00 nopl (%rax) b80: f2 0f 10 05 60 01 00 movsd 0x160(%rip),%xmm0 # ce8 <_ZTSPFddE+0x1b> b87: 00 b88: f2 0f 58 c1 addsd %xmm1,%xmm0 b8c: e8 4f fd ff ff callq 8e0 b91: f2 0f 10 54 24 08 movsd 0x8(%rsp),%xmm2 b97: 66 0f 28 ca movapd %xmm2,%xmm1 b9b: f2 0f 10 15 3d 01 00 movsd 0x13d(%rip),%xmm2 # ce0 <_ZTSPFddE+0x13> ba2: 00 ba3: 83 eb 01 sub $0x1,%ebx ba6: f2 0f 58 04 24 addsd (%rsp),%xmm0 bab: f2 0f 58 d1 addsd %xmm1,%xmm2 baf: f2 0f 11 04 24 movsd %xmm0,(%rsp) bb4: f2 0f 11 54 24 08 movsd %xmm2,0x8(%rsp) bba: 75 c4 jne b80 <_ZL4libmd+0x20> }}} Note the call to `sin` which is sent through the PLT. Yuck. This gave the following results on my i7-6600U (Skylake @ 2.6GHz) (looking at a variety of iteration counts to ensure that the timing isn't dominated by setup time, as well as a few measurements at each count to get a sense for variance) , ||= Method =||= iterations =||= Time per iteration (ns) =|| || SSE || 1e8 || 33.91 || || SSE || 1e8 || 34.08 || || SSE || 1e8 || 33.08 || || SSE || 5e7 || 34.47 || || SSE || 5e7 || 34.76 || || SSE || 5e7 || 36.36 || || SSE || 1e7 || 39.69 || || SSE || 1e7 || 36.45 || || SSE || 1e7 || 39.40 || || X87 || 1e8 || 37.95 || || X87 || 1e8 || 39.74 || || X87 || 1e8 || 40.94 || || X87 || 5e7 || 37.29 || || X87 || 5e7 || 36.35 || || X87 || 5e7 || 36.60 || || X87 || 1e7 || 37.75 || || X87 || 1e7 || 37.34 || || X87 || 1e7 || 38.30 || It seems to me like (in the case of this particularly terrible benchmark) the two implementations are relatively similar, with SSE perhaps having a slight edge. Intriguingly, replacing `sin` in the example with `sqrt` changes the outcome dramatically: both timings decrease markedly (as one might expect; `sin` isn't an easy thing to compute), but X87 is twice as fast as SSE (2.2 ns/iteration vs. 5.5 ns/iteration). -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:11 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | numeric/num009 Blocked By: | Blocking: Related Tickets: #13570 | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Changes (by dfeuer): * status: closed => new * resolution: fixed => Comment: This made `n-body` ''slower'' and did not appreciably affect other benchmarks. It would be really good to figure out what's going on here. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:13 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | numeric/num009 Blocked By: | Blocking: Related Tickets: #13570 | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Comment (by nomeata): If you have reasons to doubt the results, better try to reproduce them on your machine. I see performance cliffs of that size on perf.h.o that are sometimes triggered by very insignificant changes to the runtime system, for example. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:15 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | numeric/num009 Blocked By: | Blocking: Related Tickets: #13570 | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Comment (by bgamari): So `perf stat` reveals a rather interesting picture. With the patch we retire few instructions (9,146,722,334 vs. 12,346,134,565), perform far fewer branches (908,661,442 compared to 1,308,583,802 without, the predictor missing around 0.01% in both cases), yet see a significantly higher runtime. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:17 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | numeric/num009 Blocked By: | Blocking: Related Tickets: #13570 | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Comment (by bgamari): For the record, `sqrtf` is the following on my machine, {{{#!asm 0x00007ffff78892c0 <+0>: pxor %xmm1,%xmm1 0x00007ffff78892c4 <+4>: ucomiss %xmm0,%xmm1 0x00007ffff78892c7 <+7>: ja 0x7ffff78892d0 <__sqrtf+16> 0x00007ffff78892c9 <+9>: sqrtss %xmm0,%xmm0 0x00007ffff78892cd <+13>: retq 0x00007ffff78892ce <+14>: xchg %ax,%ax 0x00007ffff78892d0 <+16>: mov 0x2cccf9(%rip),%rax # 0x7ffff7b55fd0 0x00007ffff78892d7 <+23>: cmpl $0xffffffff,(%rax) 0x00007ffff78892da <+26>: je 0x7ffff78892c9 <__sqrtf+9> 0x00007ffff78892dc <+28>: movaps %xmm0,%xmm1 0x00007ffff78892df <+31>: mov $0x7e,%edi 0x00007ffff78892e4 <+36>: jmpq 0x7ffff788ed50 <__kernel_standard_f> }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:19 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#13629: sqrt should use machine instruction on x86_64 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.4.1 Component: Compiler (NCG) | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | numeric/num009 Blocked By: | Blocking: Related Tickets: #13570 | Differential Rev(s): Phab:D3508 Wiki Page: | -------------------------------------+------------------------------------- Changes (by michalt): * cc: michalt (added) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13629#comment:21 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler