В OCaml, насколько велика цена абстракции (т.е. полиморфные функции)

Я все еще на начальной стадии изучения OCaml, и мне любопытно узнать, каков наилучший способ извлечь максимальную производительность из общего кода в OCaml.

В качестве небольшого эксперимента я написал две полиморфные функции: одну в C ++ и другую в OCaml, которая находит самый большой элемент в данном массиве.

Я заметил, что в то время как в C ++ вы не платите штраф за подобную абстракцию, штраф в OCaml — это колоссальное падение производительности на один градус. Кроме того, решение C ++, которое я быстро придумал, является более общим, чем решение OCaml, но я виню в этом, в первую очередь, мою неопытность по отношению к языку.

Мой вопрос заключается в следующем: как писать и использовать полиморфные функции в OCaml, не платя при этом огромных потерь производительности, которые я только что наблюдал?

Еще одна вещь, которую я заметил для этой конкретной проблемы, заключается в том, что мое функциональное решение в OCaml было медленнее, чем императивное, тогда как «функциональное» решение в C ++ не подвергалось никаким штрафам по сравнению с аналоговым императивным подходом.

C ++ код был скомпилирован с g++ -std="c++0x" -O3 -o max_cpp max.cpp, используя gcc-4.6.3
и код OCaml с: ocamlopt -o max_ml max.ml используя ocamlopt версии 3.12.1.
Оба сгенерированных исполняемых файла были 32-битными и работали на Ubuntu x64 11.04

Я отправляю код обеих программ.

Код C ++ (конечно, не совсем безопасный;))

#include <iostream>
#include <vector>
#include <numeric>
template <typename T> T max (T a, T b) {
return (a>b)? a : b;
}

template <typename I> typename I::value_type find_max (I begin, I end) {
auto max = *begin;
for (begin++;begin!=end;begin++)
if (*begin > max) max = *begin;
return max;
}

template <typename I> typename I::value_type find_max1(I begin, I end) {
return std::accumulate(begin, end, *begin, max< typename I::value_type> );
}

int main(int argc, char ** argv) {
const size_t nElem = atoi(argv[1]);
const size_t nIter = atoi(argv[2]);
std::vector<int> intA(nElem);
std::vector<double> dubA(nElem);
for (int i=0;i<nIter;i++) {
auto res1 = find_max(intA.begin(), intA.end());
auto res2 = find_max(dubA.begin(), dubA.end());
std::cout << "Max int: " << res1 << " " << "Max dub: " << res2 << std::endl;
}
}

Код OCaml

let max a b = if a > b then a else b

(* functional version *)
let find_max vector =
Array.fold_right max vector vector.(0)

(* imperative version *)
let find_max1 vector =
let length = Array.length vector in
let max = ref (vector.(0)) in
for i=1 to length-1 do
if vector.(i) > !max then max := vector.(i)
done; max

let nElems = int_of_string Sys.argv.(1)

let nIter  = int_of_string Sys.argv.(2)

let _ = let intA = Array.make nElems 0 in
let dubA = Array.make nElems 0.0 in
for i=1 to nIter do
let res1 = find_max intA in
let res2 = find_max dubA in
print_int !res1;
print_newline ();
print_float !res2;
done

Однако, если я «перегружу» функцию для распознавания целых чисел и чисел с плавающей запятой, то производительность программы даже превосходит производительность моего кода C ++ на 50%! Интересно, почему, хотя.

let find_max_int (vector : int array) =
let length = Array.length vector in
let max = ref (vector.(0)) in
for i=1 to length-1 do
if vector.(i) > !max then max := vector.(i)
done; max

let find_max_float (vector : float array) =
let length = Array.length vector in
let max = ref (vector.(0)) in
for i=1 to length-1 do
if vector.(i) > !max then max := vector.(i)
done; max

Время было выполнено довольно грубо с:
time ./max_cpp 1000000 100 а также time ./max_ml 1000000 100