Considérations de Performance de Haskell FFI / C?

J'utilise un mélange de threads C et Haskell pour l'une de mes applications et je n'ai pas remarqué que beaucoup de performances frappent la commutation entre les deux. J'ai donc créé une référence simple... ce qui est un peu plus rapide/moins cher que celui de Don. cela mesure 10 millions d'itérations sur un i7 2.66 GHz:

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

Compilé avec GHC 7.0.3 / x86_64 et gcc-4.2.1 sur 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)

Et une application OSX C++ pour le conduire, devrait être simple à ajuster à Windows ou 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 peut jeter un coup d'oeil dans ce blob 20k si vous passez le pointeur.

Avertissement: Je n'ai aucune expérience avec le FFI.

Mais il me semble que si vous voulez réutiliser les 20 Ko de données pour ne pas les transmettre à chaque fois, alors vous pourriez simplement avoir une méthode qui prend une liste de" personnalités", et renvoie une liste de"décisions".

Donc, si vous avez une fonction

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

Alors pourquoi ne pas créer une fonction d'aide

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

Et invoquer cela? En utilisant cette façon, si vous voulez paralléliser, vous devez le faire Haskell-side avec listes parallèles et carte parallèle.

Je m'en remets aux experts pour expliquer si/comment les tableaux C peuvent être marshalés dans des listes Haskell (ou une structure similaire) facilement.