Bonjour à tous,

J'ai une application (Mathematica) qui à une fâcheuse tendance, quand on se goure par exemple dans les indices d'un tableau, à écrire l'intégralité de la variable concernée sur la console. C'est débile, et ca fait planter toute la machine dés que la variable est un peu grosse. D'où ma question: comment puis-je limiter la quantité de mémoire utilisable par le programme de sorte que, lorsque cette limite est atteinte, le programme stoppe/plante au lieu d'aller swapper comme un malade et de freezer le PC? J'ai regardé un peu du côté de ulimit, mais ça n'a pas l'air applicable à un programme spécifique...

Merci d'avance!
Je ne connais pas ce programme, mais n'y-a-t-il pas dans sa configuration une option concernant la limitation de taille mémoire ?
De plus, en regardant le man bash : 
       ulimit [-SHacdfilmnpqstuvx [limite]]
              fournit, sur les systèmes qui le permettent, un  mécanisme  de
              contrôle  des ressources disponibles pour le shell et pour les
              processus qu'il lance. Les options H  et  S  précisent  si  la
              limite  doit  être  dure  (Hard), ou souple (Soft). Une limite
              dure ne peut pas être augmentée une fois qu'elle a  été  défi‐
              nie.  Une limite souple peut être augmentée jusqu'à la hauteur
              de la limite dure  correspondante.  Par  défaut,  les  limites
              fixées  sont  souples.  La  valeur  de  la limite peut être un
              nombre (utilisant les unités particulières de la  ressources),
              ou  l'une  des  valeurs spéciales hard, soft ou unlimited, qui
              signifient, respectivement, la limite dure courante, la limite
              douce  courante  et  pas de limite. Si la limite est omise, on
              affiche la valeur de la limite souple pour la ressource  indi‐
              quée,  sauf  si  l'option  H est fournie. Quand plusieurs res‐
              sources sont indiquées, leurs noms, et  leurs  unités  respec‐
              tives sont affichés avant les valeurs. Les options sont inter‐
              prétées ainsi :
              -a     affichage de toutes les limites actuelles
              -c     la taille maximale pour la création d'un fichier core
              -d     la taille maximale du segment de données d'un processus
              -e     la priorité d'ordonnancement maximum (« nice »)
              -f     la taille maximale d'un fichier écrit par le  shell  et
                     ses fils
              -i     le nombre maximal de signaux en attente
              -l     la taille maximale que l'on peut verrouiller en mémoire
              -m     la  taille maximale de la partie résidente d'un proces‐
                     sus
              -n     le nombre maximal de descripteurs de  fichiers  ouverts
                     (la plupart des systèmes ne permettent pas de modifica‐
                     tion)
              -p     La taille d'un tuyau (pipe)  en  blocs  de  512  octets
                     (parfois non modifiable)
              -q     le  nombre  maximal  d'octets dans les files de message
                     POSIX
              -r     la priorité d'ordonnancement temps réel maximum
              -s     la taille maximale de la pile
              -t     la durée maximale, en seconde, de temps CPU  accordé  à
                     un processus.
              -u     le  nombre  maximal de processus autorisés pour un seul
                     utilisateur
              -v     la quantité de mémoire  virtuelle  disponible  pour  le
                     shell
              -x     le nombre maximum de verrouillages fichiers

              Si une limite est fournie, la ressource correspondante recevra
              cette limite (l'option  -a  ne  permet  que  l'affichage).  Si
              aucune  option  n'est  indiquée, la ressource -f est prise par
              défaut. Les valeurs s'expriment en kilo-octets, sauf pour  -t,
              ou  elles  s'expriment en secondes, -p, qui utilise des unités
              de blocs de 512 octets, ainsi que -n  et  -u,  qui  n'ont  pas
              d'unités.  La  valeur  renvoyée est 0 sauf si une option ou un
              argument non valide sont fournis, ou si une erreur se  produit
              durant la modification de la limite.
Je me demande si tu ne pourrai pas lancer ton programme avec une commande du genre 
Mathematica ulimit -l "taille de la mémoire allouée"
chepioq wrote: Je me demande si tu ne pourrai pas lancer ton programme avec une commande du genre 
Mathematica ulimit -l "taille de la mémoire allouée"
peut être l'inverse car, je n'ai pas vérifié, mais dans ce sens, c'est comme si ulimit était une option de Mathematica (ce qui est peu probable.

Alors que 
ulimit -l "taille de la mémoire allouée" Mathematica
correspondrait plus à ulimit qui prends en paramètre à lancer Mathematica.

Je ne peux pas essayer.
Re...
Je viens de trouver ceci :
http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.cmds/doc/aixcmds5/ulimit.htm
Chez moi un ulimit -a me renvois : 
[dominique@localhost ~]$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 31476
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 1024
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited
[dominique@localhost ~]$
D'après ce que je lis, ce serai plutôt l'option -m
On aurai donc une commande de la forme 
ulimit -m "taille de la mémoire allouée" Mathematica
avec la taille de la mémoire allouée en kilobytes...
Le man de ulimit wrote:fournit, sur les systèmes qui le permettent, un mécanisme de contrôle des ressources disponibles pour le shell et pour les processus qu'il lance.
En gros ça veut dire qu'on exécute ulimit une fois, et la limite s'applique à toutes les applications lancées dans le même shell. Donc il faut lancer les commandes ulimit et Mathematica séparément.

EDIT: attention chepioq, le lien que tu as posté concerne le ulimit de ksh sur AIX, ce n'est pas forcément pertinent sur bash.
WilQu wrote:
Le man de ulimit wrote:fournit, sur les systèmes qui le permettent, un mécanisme de contrôle des ressources disponibles pour le shell et pour les processus qu'il lance.
En gros ça veut dire qu'on exécute ulimit une fois, et la limite s'applique à toutes les applications lancées dans le même shell. Donc il faut lancer les commandes ulimit et Mathematica séparément.
Je ne l'avais pas compris, mais c'est encore plus facile comme ça.

En gros il suffirait de faire un petit script du genre : 
#!/bin/bash
ulimit -m "taille de la mémoire allouée"
Mathematica
exit 0
puis le rendre exécutable, et le lancer à la place de Mathematica

Vous êtes d'accord ?
Je retirerais le exit 0 à la fin (c'est inutile et mieux vaut que le script quitte avec le même code d'erreur que Mathematica) mais sinon je pense que ça devrait marcher.
Sinon tu peux cloisonner ton programme avec cpusets. Mais +1 ulimit c'est plus simple !
J'ai testé ulimit pour voir. 
[dominique@localhost ~]$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 31476
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 1024
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited
Ensuite 
[dominique@localhost ~]$ ulimit -m 4000
[dominique@localhost ~]$ ulimit -m 4000
Vérification : 
[dominique@localhost ~]$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 31476
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) 4000
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 1024
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited
On voit bien que max memory size a été modifié : 
max memory size         (kbytes, -m) 4000
J'ai lancé une autre console pour voir, et effectivement dans cette deuxième console, max memory size est resté en unlimited 
max memory size         (kbytes, -m) unlimited
Il faudrait que Mammouth essaye avec son programme pour voir si cela le satisfait...
Attention parce que ulimit -m c'est la somme des mémoire allouée + mémoire virtuelle. J'ai eu récemment des problèmes à gérer les ulimit pour des programmes parce que simplement le programme s'allouait une grosse quantité de mémoire virtuelle peu importe la mémoire physique demandée. Le mieux c'est de faire un top et de lire la ligne VIRT pour connaître la taille.
chepioq wrote: En gros il suffirait de faire un petit script du genre : 
#!/bin/bash
ulimit -m "taille de la mémoire allouée"
Mathematica
exit 0
puis le rendre exécutable, et le lancer à la place de Mathematica

Vous êtes d'accord ?
ou alors, modier le lanceur de Mathematica par 
ulimit -m "taille de la mémoire allouée" && Mathematica
mais bon c'est de l'optimisation ça, ça ne change rien à l'idée :-P