OCAMLRUNPARAM non influenza le dimensioni dello stack

Question

Vorrei modificare le dimensioni dello stack per consentire a un progetto con molte funzioni non ricorsive di eseguire su dati più grandi. Per fare ciò, ho provato a impostare OCAMLRUNPARAM="l=xxx" per diversi valori di xxx (nell'intervallo da 0 a 10G), ma non ha avuto alcun effetto. Sta impostando OCAMLRUNPARAM anche l'approccio giusto?

Nel caso in cui sia rilevante: il progetto a cui sono interessato è costruito utilizzando OCamlMakefile, target native-code.

Ecco un esempio minimo in cui viene semplicemente creata una grande lista senza ricorsione della coda. Per verificare rapidamente se l'impostazione di OCAMLRUNPARAM ha un effetto, ho compilato il programma stacktest.ml:

let rec create l = 
    match l with 
| 0 -> [] 
| _ -> "00"::(create (l-1)) 

let l = create (int_of_string (Sys.argv.(1))) 
let _ = print_endline("List of size "^string_of_int (List.length l)^" created.") 

utilizzando il comando

ocamlbuild stacktest.native 

e scoperto circa in cui la lunghezza della lista un overflow dello stack si verifica da (più o meno) la ricerca binaria con il seguente script bash foo.sh:

#!/bin/bash 
export OCAMLRUNPARAM="l=$1" 
increment=1000000 
length=1 
while [[ $increment > 0 ]] ; do 
    while [[ $(./stacktest.native $length) ]]; do 
     length=$(($length+$increment)) 
    done 
    length=$(($length-$increment)) 
    increment=$(($increment/2)) 
    length=$(($length+$increment)) 
done 
length=$(($length-$increment)) 
echo "Largest list without overflow: $length" 
echo $OCAMLRUNPARAM 

I risultati variano tra i percorsi di questo script (e i risultati intermedi non sono nemmeno coerenti all'interno di una corsa, ma ignoriamo che per ora), ma sono simili, non importa se io chiamo

bash foo.sh 1 

o

bash foo.sh 1G 

vale a dire se la dimensione dello stack è impostato a 1 o 2^30 parole.

Answer 1

La modifica del limite di stack tramite OCAMLRUNPARAM funziona solo per gli eseguibili bytecode, eseguiti dall'interprete OCaml. Un programma nativo è gestito da un sistema operativo ed eseguito direttamente sulla CPU. Pertanto, al fine di modificare il limite di stack, è necessario utilizzare le funzionalità fornite dal proprio sistema operativo.

Ad esempio, su Linux è disponibile il comando ulimit che gestisce molti parametri di processo, incluso il limite di stack. Aggiungi il seguente al tuo script

ulimit -s $1 

E vedrai che il risultato sta cambiando.