Consideraciones de rendimiento de Haskell FFI / C?

Utilizo una mezcla de hilos de C y Haskell para una de mis aplicaciones y no he notado que gran parte de un éxito de rendimiento de conmutación entre los dos. Así que diseñé un punto de referencia simple... que es un poco más rápido/más barato que Don. Esto está midiendo 10 millones de iteraciones en un 2.66 GHz i7:

$ ./foo
IO  : 2381952795 nanoseconds total, 238.195279 nanoseconds per, 160000000 value
Pure: 2188546976 nanoseconds total, 218.854698 nanoseconds per, 160000000 value

Compilado con GHC 7.0.3 / x86_64 y gcc-4.2.1 en OSX 10.6

ghc -no-hs-main -lstdc++ -O2 -optc-O2 -o foo ForeignExportCost.hs Driver.cpp

Haskell:

{-# LANGUAGE ForeignFunctionInterface #-}

module ForeignExportCost where

import Foreign.C.Types

foreign export ccall simpleFunction :: CInt -> CInt
simpleFunction i = i * i

foreign export ccall simpleFunctionIO :: CInt -> IO CInt
simpleFunctionIO i = return (i * i)

Y una aplicación de OSX C++ para manejarlo, debe ser fácil de ajustar a Windows o Linux:

#include <stdio.h>
#include <mach/mach_time.h>
#include <mach/kern_return.h>
#include <HsFFI.h>
#include "ForeignExportCost_stub.h"

static const int s_loop = 10000000;

int main(int argc, char** argv) {
    hs_init(&argc, &argv);

    struct mach_timebase_info timebase_info = { };
    kern_return_t err;
    err = mach_timebase_info(&timebase_info);
    if (err != KERN_SUCCESS) {
        fprintf(stderr, "error: %x\n", err);
        return err;
    }

    // timing a function in IO
    uint64_t start = mach_absolute_time();
    HsInt32 val = 0;
    for (int i = 0; i < s_loop; ++i) {
        val += simpleFunctionIO(4);
    }

    // in nanoseconds per http://developer.apple.com/library/mac/#qa/qa1398/_index.html
    uint64_t duration = (mach_absolute_time() - start) * timebase_info.numer / timebase_info.denom;
    double duration_per = static_cast<double>(duration) / s_loop;
    printf("IO  : %lld nanoseconds total, %f nanoseconds per, %d value\n", duration, duration_per, val);

    // run the loop again with a pure function
    start = mach_absolute_time();
    val = 0;
    for (int i = 0; i < s_loop; ++i) {
        val += simpleFunction(4);
    }

    duration = (mach_absolute_time() - start) * timebase_info.numer / timebase_info.denom;
    duration_per = static_cast<double>(duration) / s_loop;
    printf("Pure: %lld nanoseconds total, %f nanoseconds per, %d value\n", duration, duration_per, val);

    hs_exit();
}

Haskell puede echar un vistazo a ese blob de 20k si pasas el puntero.

Descargo de responsabilidad: No tengo experiencia con la FFI.

Pero me parece que si quieres reutilizar los 20 Kb de datos para no pasarlos cada vez, entonces podrías simplemente tener un método que toma una lista de "personalidades" y devuelve una lista de "decisiones".

Así que si tienes una función

f :: LotsaData -> Personality -> Decision
f data p = ...

Entonces, ¿por qué no hacer una función auxiliar

helper :: LotsaData -> [Personality] -> [Decision]
helper data ps = map (f data) ps

E invocar eso? Usando esta manera, sin embargo, si desea paralelizar, tendría que hacerlo Haskell-side con listas paralelas y mapa paralelo.

Defiendo a los expertos para explicar si/cómo los arrays C pueden ser organizados en listas de Haskell (o estructura similar) fácilmente.