Limitare la memoria fisica per processo

Question

Sto scrivendo un algoritmo per eseguire alcuni calcoli di memoria esterna, vale a dire dove i dati di input non si adattano alla memoria principale e si deve considerare la complessità dell'I/O.

Poiché per i miei test non sempre voglio utilizzare gli ingressi reali Voglio limitare la quantità di memoria disponibile al mio processo. Quello che ho trovato è, che io possa impostare il parametro mem kernel per limitare la memoria fisica utilizzata di tutti i processi (è corretto?)

C'è un modo di fare lo stesso, ma con un per limite di processo . Ho visto ulimit, ma limita solo la memoria virtuale per processo. Qualche idea (forse posso anche programmarla dal mio codice C++)?

Answer 1

Puoi provare con "cgroups". Per usarli, digitare i seguenti comandi, come root.

# mkdir /dev/cgroups 
# mount -t cgroup -omemory memory /dev/cgroups 
# mkdir /dev/cgroups/test 
# echo 10000000 > /dev/cgroups/test/memory.limit_in_bytes 
# echo 12000000 > /dev/cgroups/test/memory.memsw.limit_in_bytes 
# echo <PID> > /dev/cgroups/test/tasks 

Dove si trova il PID del processo che si desidera aggiungere al cgroup. Si noti che il limite si applica alla somma di tutti i processi assegnati a questo cgroup.

Da questo momento in poi, i processi sono limitati a 10 MB di memoria fisica e 12 MB di pysical + swap.

Ci sono altri parametri sintonizzabili in quella directory, ma l'elenco esatto dipenderà dalla versione del kernel che si sta utilizzando.

È anche possibile creare gerarchie di limiti, creando semplicemente sottodirectory.

Il cgroup viene ereditato quando si esegue fork/exec, quindi se si aggiunge la shell da cui il programma viene avviato in un cgroup verrà assegnato automaticamente.

Nota che puoi montare i cgroup in qualunque directory tu voglia, non solo/dev/cgroups.

Answer 2

Non riesco a fornire una risposta diretta, ma riguardo a fare cose del genere, di solito scrivo il mio sistema di gestione della memoria in modo da poter avere il pieno controllo dell'area di memoria e di quanto alloco. Questo è solitamente appliacbile anche quando scrivi per microcontrollori. Spero che sia d'aiuto.

Answer 3

Vorrei utilizzare il setrlimti con il parametro RLIMIT_AS per impostare il limite della memoria virtuale (questo è ciò che ulimit fa) e quindi utilizzare il processo mlockall (MCL_CURRENT | MCL_FUTURE) per forzare il kernel a fare il fault e bloccarlo in fisico RAM tutte le pagine di processo, quindi la quantità virtuale == quantità di memoria fisica per questo processo

Answer 4

Il parametro di avvio del kernel mem= limita la quantità di memoria utilizzata dal sistema operativo.

Questo è quasi mai ciò che l'utente desidera.

Per la memoria fisica, c'è RSS rlimit aka RLIMIT_AS.

Answer 5

hai considerato di provare il tuo codice in una sorta di ambiente virtuale? Una macchina virtuale potrebbe essere troppo per le tue esigenze, ma qualcosa come User-Mode Linux potrebbe essere una buona misura. Questo esegue un kernel Linux come un singolo processo all'interno del tuo normale sistema operativo. Quindi è possibile fornire un'impostazione del kernel mem= separata, nonché uno spazio di swap separato per effettuare esperimenti controllati.

Answer 6

Come già indicato da altri poster, setrlimit è la soluzione più probabile, controlla i limiti di tutti gli aspetti configurabili di un ambiente di processo. Utilizzare questo comando per vedere queste singole impostazioni del processo shell:

ulimit -a 

Quelli più pertinenti per lo scenario in output risultante sono le seguenti:

data seg size   (kbytes, -d) unlimited 
max locked memory  (kbytes, -l) 64 
max memory size   (kbytes, -m) unlimited 
virtual memory   (kbytes, -v) unlimited 

Checkout la pagina di manuale per setrlimit (" man setrlimit "), può essere invocato in modo programmatico dal codice C/C++. L'ho usato con buoni risultati in passato per controllare i limiti della dimensione dello stack. (btw, non esiste una pagina man dedicata per ulimit, è in realtà un comando bash incorporato, quindi è nella pagina man bash.)