Come forzare GHC alle chiamate FFI in linea?

Question

Ho realizzato un piccolo modulo C per migliorare le prestazioni, ma GHC non esegue funzioni estranee inline e il costo delle chiamate elimina l'accelerazione. Ad esempio, test.h:

int inc (int x); 

test.c:

#include "test.h" 
int inc(int x) {return x + 1;} 

Test.hc:

{-# LANGUAGE ForeignFunctionInterface #-} 
module Test (inc) where 
import Foreign 
import Foreign.C 
foreign import ccall unsafe "test.h inc" c_inc :: CInt -> CInt 
inc = fromIntegral . c_inc . fromIntegral 
{-# INLINE c_inC#-} 
{-# INLINE inC#-} 

Main.hs:

import System.Environment 
import Test 
main = do {args <- getArgs; putStrLn . show . inc . read . head $ args } 

Fare:

$ gcc -O2 -c test.c 
$ ghc -O3 test.o Test.hs 
$ ghc --make -O3 test.o Main 
$ objdump -d Main > Main.as 

Infine, nel Main.as ho callq <inc> istruzioni invece di desiderabili inc 's.

Answer 1

GHC non incorpora il codice C tramite il suo back-end asm o back-end LLVM. Solitamente, chiamerai in C solo per motivi di prestazioni se la cosa che stai chiamando costa davvero molto. Incrementare un int non è una cosa del genere, dato che abbiamo già dei prim per questo.

Ora, se si chiama via C si può ottenere GCC inline cose (controllare l'assembly generato).

Ora, però, ci sono alcune cose che puoi fare già per minimizzare il costo della chiamata:

foreign import ccall unsafe "test.h inc" c_inc :: CInt -> CInt 

inc = fromIntegral . c_inc . fromIntegral 

forniscono una firma tipo per inc. Stai pagando cicli preziosi convertendo in intero qui.

Segna la chiamata come "non sicuro", come si fa, in modo che il runtime non è segnalibri alle prima della chiamata.

Misurare l'overhead di chiamata FFI - dovrebbe essere nei nanosecondi. Tuttavia, se lo trovi ancora troppo costoso, è possibile write a new primop and jump to it directly. Ma è meglio avere i numeri criterion prima.