Calling fsincos instruction in LLVM slower than calling Libc sin/cos functions

assembly - Calling fsincos instruction in LLVM slower than calling libc sin/cos functions? - Stack Overflow

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Learn more about Collectives

Stack Internal

Knowledge at work

Bring the best of human thought and AI automation together at your work.

Explore Stack Internal

Calling fsincos instruction in LLVM slower than calling libc sin/cos functions?

Ask Question

Asked 13 years, 8 months ago

Modified 2 years, 10 months ago

Viewed 7k times

I am working on a language that is compiled with LLVM. Just for fun, I wanted to do some microbenchmarks. In one, I run some million sin / cos computations in a loop. In pseudocode, it looks like this:

var x: Double = 0.0 for (i

If I'm computing sin/cos using LLVM IR inline assembly in the form:

%sc = call { double, double } asm "fsincos", "={st(1)},={st},1,~{dirflag},~{fpsr},~{flags}" (double %"res") nounwind

this is faster than using fsin and fcos separately instead of fsincos. However, it is slower than if I calling the llvm.sin.f64 and llvm.cos.f64 intrinsics separately, which compile to calls to the C math lib functions, at least with the target settings I'm using (x86_64 with SSE enabled).

It seems LLVM inserts some conversions between single/double precision FP -- that might be the culprit. Why is that? Sorry, I'm a relative newbie at assembly:

.globl main .align 16, 0x90 .type main,@function main: # @main .cfi_startproc # BB#0: # %loopEntry1 xorps %xmm0, %xmm0 movl $-1, %eax jmp .LBB44_1 .align 16, 0x90 .LBB44_2: # %then4 # in Loop: Header=BB44_1 Depth=1 movss %xmm0, -4(%rsp) flds -4(%rsp) #APP fsincos #NO_APP fstpl -16(%rsp) fstpl -24(%rsp) movsd -16(%rsp), %xmm0 mulsd %xmm0, %xmm0 cvtsd2ss %xmm0, %xmm1 movsd -24(%rsp), %xmm0 mulsd %xmm0, %xmm0 cvtsd2ss %xmm0, %xmm0 addss %xmm1, %xmm0 .LBB44_1: # %loop2 # =>This Inner Loop Header: Depth=1 incl %eax cmpl $99999999, %eax # imm = 0x5F5E0FF jle .LBB44_2 # BB#3: # %break3 cvttss2si %xmm0, %eax ret .Ltmp160: .size main, .Ltmp160-main .cfi_endproc

Same test with calls to llvm sin/cos intrinsics:

.globl main .align 16, 0x90 .type main,@function main: # @main .cfi_startproc # BB#0: # %loopEntry1 pushq %rbx .Ltmp162: .cfi_def_cfa_offset 16 subq $16, %rsp .Ltmp163: .cfi_def_cfa_offset 32 .Ltmp164: .cfi_offset %rbx, -16 xorps %xmm0, %xmm0 movl $-1, %ebx jmp .LBB44_1 .align 16, 0x90 .LBB44_2: # %then4 # in Loop: Header=BB44_1 Depth=1 movsd %xmm0, (%rsp) # 8-byte Spill callq cos mulsd %xmm0, %xmm0 movsd %xmm0, 8(%rsp) # 8-byte Spill movsd (%rsp), %xmm0 # 8-byte Reload callq sin mulsd %xmm0, %xmm0 addsd 8(%rsp), %xmm0 # 8-byte Folded Reload .LBB44_1: # %loop2 # =>This Inner Loop Header: Depth=1 incl %ebx cmpl $99999999, %ebx # imm = 0x5F5E0FF jle .LBB44_2 # BB#3: # %break3 cvttsd2si %xmm0, %eax addq $16, %rsp popq %rbx ret .Ltmp165: .size main, .Ltmp165-main .cfi_endproc

Can you suggest how the ideal assembly would look like with fsincos? PS. Adding -enable-unsafe-fp-math to llc makes the conversions disappear and switches to doubles (fldl etc.), but the speed remains the same.

.globl main .align 16, 0x90 .type main,@function main: # @main .cfi_startproc # BB#0: # %loopEntry1 xorps %xmm0, %xmm0 movl $-1, %eax jmp .LBB44_1 .align 16, 0x90 .LBB44_2: # %then4 # in Loop: Header=BB44_1 Depth=1 movsd %xmm0, -8(%rsp) fldl -8(%rsp) #APP fsincos #NO_APP fstpl -24(%rsp) fstpl -16(%rsp) movsd -24(%rsp), %xmm1 mulsd %xmm1, %xmm1 movsd -16(%rsp), %xmm0 mulsd %xmm0, %xmm0 addsd %xmm1, %xmm0 .LBB44_1: # %loop2 # =>This Inner Loop Header: Depth=1 incl %eax cmpl $99999999, %eax # imm = 0x5F5E0FF jle .LBB44_2 # BB#3: # %break3 cvttsd2si %xmm0, %eax ret .Ltmp160: .size main, .Ltmp160-main .cfi_endproc

assembly llvm inline-assembly x87

Improve this question

edited Sep 18, 2012 at 21:31

asked Sep 18, 2012 at 21:18

Erkki Lindpere

61766 silver badges1111 bronze badges

Hmm.. I think I'm starting to get it. fsin/fcos/fsincos use x87 registers and mulsd addsd use MMX / SSE. So the overhead is from moving the data between them probably?

Erkki Lindpere

2012-09-18 21:38:01 +00:00

Commented Sep 18, 2012 at 21:38

No, cvtsd2ss is a conversion from double to float. But stay away from legacy coprocessor instructions, they are slower and more imprecise than library routines nowadays. See for instance gcc.gnu.org/ml/gcc/2012-02/msg00188.html

Gunther Piez

2012-09-18 22:00:06 +00:00

Commented Sep 18, 2012 at 22:00

And yes, there is additional overhead from moving, but it doesn't amount to much compared to the 200-300 cycles fsincos uses.

Gunther Piez

2012-09-18 22:01:07 +00:00

Commented Sep 18, 2012 at 22:01

Thanks, I guess I'll stick with the llvm sin/cos intrinsics then.

Erkki Lindpere

2012-09-18 22:10:34 +00:00

Commented Sep 18, 2012 at 22:10

Add a comment

2 Answers 2

Sorted by:

Reset to default

Highest score...

Calling fsincos instruction in LLVM slower than calling Libc sin/cos functions

Related Articles

The Newest Instagram "Exploit" Is the Goofiest I've Seen

Apple WWDC 2026 Livestream

Claude Fable 5

It's Not Just X. It's Y

Show HN: GoPeek – open links in live mini browser windows without new tabs