Comment remplir 90% de la memory libre?

Je veux faire des tests de faibles ressources et pour cela j'ai besoin d'avoir 90% de la memory libre pleine.

Comment puis-je le faire sur un système *nix ?

stress est un générateur de charge de travail qui simule le stress cpu / mem / io / hdd sur les systèmes POSIX. Cet appel devrait faire l'affaire sur Linux:

 stress --vm-bytes $(awk '/MemFree/{printf "%d\n", $2 * 0.9;}' < /proc/meminfo)k --vm-keep -m 1 

Adaptez l'appel /proc/meminfo avec free(1) / vm_stat(1) / etc. si vous en avez besoin portable.

Vous pouvez écrire un programme C sur malloc() la memory requirejse, puis utiliser mlock() pour éviter que la memory ne soit échangée.

Ensuite, laissez le programme attendre la saisie au keyboard et déverrouillez la memory, libérez la memory et quittez.

Je suggère d'exécuter une machine virtuelle avec une memory limitée et de tester le logiciel dans ce serait un test plus efficace que d'essayer de remplir la memory sur la machine hôte.

Cette méthode présente également l'avantage que si la situation de memory faible provoque des erreurs de MOO ailleurs et bloque l'set du operating system, vous ne suspendez que la machine virtuelle que vous testez dans votre machine sur laquelle d'autres process utiles peuvent s'exécuter.

De même, si vos tests ne sont pas intensifs pour les processeurs ou les E / S, vous pouvez exécuter simultanément des instances de tests sur une famille de machines virtuelles de tailles de memory réduites.

  1. exécuter linux;
  2. boot avec le paramètre de démarrage du kernel mem=nn[KMG]

(regardez dans Linux / Documentation / kernel-parameters.txt pour plus de détails).

A partir de ce commentaire HN: https://news.ycombinator.com/item?id=6695581

Il suffit de remplir / dev / shm via dd ou similaire.

 swapoff -a dd if=/dev/zero of=/dev/shm/fill bs=1k count=1024k 

Comment abount une solution python simple?

 #!/usr/bin/env python import sys import time if len(sys.argv) != 2: print "usage: fillmem <number-of-megabytes>" sys.exit() count = int(sys.argv[1]) megabyte = (0,) * (1024 * 1024 / 8) data = megabyte * count while True: time.sleep(1) 

Je garde une fonction pour faire quelque chose de similaire dans mes files de points. https://github.com/sagotsky/.dotfiles/blob/master/.functions#L248

 function malloc() { if [[ $# -eq 0 || $1 -eq '-h' || $1 -lt 0 ]] ; then echo -e "usage: malloc N\n\nAllocate N mb, wait, then release it." else N=$(free -m | grep Mem: | awk '{print int($2/10)}') if [[ $N -gt $1 ]] ;then N=$1 fi sh -c "MEMBLOB=\$(dd if=/dev/urandom bs=1MB count=$N) ; sleep 1" fi } 

Si vous avez des outils GNU de base ( sh , grep , yes et head ) vous pouvez faire ceci:

 yes | tr \\nx | head -c $BYTES | grep n # Protip: use `head -c $((1024*1024*2))` to calculate 2MB easily 

Cela fonctionne parce que grep charge toute la ligne de données dans la RAM (j'ai appris cela d'une manière plutôt regrettable en grepping une image de disque). La ligne, générée par yes , en rlocation des newlines, sera infiniment longue, mais limitée par la head à $BYTES bytes, grep charge donc $ BYTES en memory. Grep lui-même utilise comme 100-200KB pour moi, vous pourriez avoir besoin de soustraire cela pour un montant plus précis.

Si vous voulez également append une contrainte de time, cela peut être fait assez facilement dans bash (ne fonctionnera pas dans sh ):

 cat <(yes | tr \\nx | head -c $BYTES) <(sleep $NumberOfSeconds) | grep n 

La chose <(command) semble être peu connue mais elle est souvent extrêmement utile, plus d'informations ici: http://tldp.org/LDP/abs/html/process-sub.html

Ensuite, pour l'utilisation de cat : cat attendra que les inputs soient terminées jusqu'à la sortie, et en gardant un des tuyaux ouverts, il gardera grep vivant.

Si vous avez pv et que vous voulez augmenter lentement l'utilisation de RAM:

 yes | tr \\nx | head -c $BYTES | pv -L $BYTESPERSEC | grep n 

Par exemple:

 yes | tr \\nx | head -c $((1024*1024*1024)) | pv -L $((1024*1024)) | grep n 

Utilisera jusqu'à un gigaoctet à un taux de 1 Mo par seconde. En prime, pv vous montrera le taux d'utilisation actuel et l'utilisation totale jusqu'à présent. Bien sûr, cela peut également être fait avec les variantes précédentes:

 yes | tr \\nx | head -c $BYTES | pv | grep n 

Il suffit d'insert le | pv | | pv | partie vous montrera l'état actuel (débit et total, par défaut, je pense – sinon voir la page man (ual)).


Pourquoi une autre réponse? La réponse acceptée recommand d'installer un package (je parie qu'il y a une version pour chaque chipset sans avoir besoin d'un gestionnaire de packages); la réponse la mieux votée recommand de comstackr un programme C (je n'avais pas de compilateur ni de string d'outils installé pour comstackr pour votre plate-forme cible); la réponse à la deuxième réponse recommand d'exécuter l'application dans une machine virtuelle (ouais laissez-moi juste dd sdcard interne de ce téléphone sur usb ou quelque chose et créer une image de virtualbox); le troisième suggère de modifier quelque chose dans la séquence de démarrage qui ne remplit pas la RAM comme désiré; le quasortingème ne fonctionne que dans la mesure où le sharepoint assembly / dev / shm (1) existe et (2) est grand (remonter a besoin de la racine); le cinquième combine beaucoup de ce qui précède sans code d'échantillon; la sixième est une excellente réponse, mais je n'ai pas vu cette réponse avant de venir avec ma propre approche, alors j'ai pensé append la mienne, parce que c'est plus court de se souvenir ou de taper si vous ne voyez pas que la ligne memblob est en fait le cœur de la question; le septième ne répond toujours pas à la question (utilise ulimit pour limiter un process à la place); le huitième essaie de vous inciter à installer python; le neuvième pense que nous sums tous très peu créatifs et finalement le dixième a écrit son propre programme C ++ qui provoque le même problème que la réponse votée.

Que diriez-vous de ramfs s'il existe? Montez-le et copyz-le sur un file volumineux? S'il n'y a pas de /dev/shm et pas de ramfs – je suppose un petit programme C qui fait un gros malloc basé sur une valeur d'input? Pourrait devoir l'exécuter plusieurs fois à la fois sur un système 32 bits avec beaucoup de memory.

Si vous voulez tester un process particulier avec une memory limitée, il peut être préférable d'utiliser ulimit pour limiter la quantité de memory allouable.

Je pense que c'est un cas de poser la mauvaise question et la santé mentale étant noyée par les gens en compétition pour la réponse la plus créative. Si vous n'avez besoin que de simuler les conditions OOM, vous n'avez pas besoin de remplir la memory. Il suffit d'utiliser un allocateur personnalisé et de le faire échouer après un certain nombre d'allocations. Cette approche semble fonctionner assez bien pour SQLite .

J'ai écrit ce petit programme C ++ pour cela: https://github.com/rmetzger/dynamic-ballooner

L'avantage de cette implémentation est de vérifier périodiquement s'il faut libérer ou réatsortingbuer la memory.