machine qui a le plus de mémoire dispo - Page 1

Salut,
J'ai besoin de choisir le serveur Linux qui a le plus de mémoire disponible parmi deux.
J'utilise pour ça la commande vmstat -n 4 2 en utilisant la seconde ligne, colonne free.

Ça fonctionnait bien jusqu'à un upgrade d'un serveur, car maintenant celui qui ne fait rien semble être celui qui a le moins de mémoire disponible.
Du coup, j'ai tenté de voir ce que retournaient les commandes "free" et "cat /proc/meminfo", tout semble cohérent avec vmstat

Voici les deux screenshots. J'interprète peut-être mal, quelle est la machine la moins chargée selon vous ?
Merci d'avance

la 2eme. les buffers sont relachés quand une appli a besoin de place. ils servent à la mise en cache des I/O au lieu de tout écrire immédiatement sur le disque.

used inclut les buffers.

enfin, IIRC...

La deuxième est moins chargée ? Enfin c'est cohérent avec la réalité, mais peux-tu expliquer rapidement ce que tu regarderais pour définir la moins chargée à coup sûr ?
Comment tu pondèrerais la mémoire libre avec les buffers ? Ou alors regarder les buffers suffirait ?

(j'ai le cat de /proc/meminfo si ça intéresse)

bin si le kernel se vautre plus dans les buffers, c'est qu'il a rien de mieux à foutre

en tout cas j'avais vu ça avec l'outil mémoire de KDE. J'étais trouducuté de voir 100% de RAM utilisée sans qu'il utilise un seul octet de swap, et en fait quand tu réserves de la vraie mémoire, le total reste à 100% mais la quantité de buffers alloués diminue.

donc pour savoir ce qui est vraiment pris, tu soustrais les buffers à ce qui est "used" ^^

edit: la formule proposée me semble bien: MemTotal - (MemFree + Buffers + Cached) + SwapTotal - SwapFree

OK merci, je vais l'utiliser alors.
C'est 100% standard comme format de fichier ? Toujours les mêmes infos ? (bon en même temps, le programme ne tourne que sur des serveurs définis donc on s'en fout )

je veux pas trop me mouiller jusqu'à 100%, mais je crois que /proc/meminfo est assez classique, oui

99 me suffisent #trihuouitrihuouitrihuoui#
Merci

Tu peux faire "echo 3 > /proc/sys/vm/drop_caches" pour forcer le kernel à vider ses caches, et après ça ton "free" t'affiche la mémoire réellement disponible.

Ça ne risque pas d'avoir un impact sur les performances ?

(heu, à noter que la formule de ./6 est celle de la mémoire UTILISÉE, pas la mémoire libre (j'avais même pas vérifié ))

Pen^2 (./11) :
Ça ne risque pas d'avoir un impact sur les performances ?

Si, mais c'est juste pour vérifier que ton calcul à partir de /proc/meminfo ou autre est correct.

OK merci, je vérifierai !

Bonsoir Pen² et vous autres

Si tu as eu une pause pour les fêtes de fin d'année qui remet à plus tard la mise en pratique de ce qui a été écrit ci-dessus, voici une fonction toute faite :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


static const char MEMFREE[] = "MemFree:";
static const char BUFFERS[] = "Buffers:";
static const char CACHED[]  = "Cached:";
static const char SWAPFREE[]= "SwapFree:";


long long get_free_memory(void) {
    void      *eof;
    FILE      *meminfo;
    long long  result;
    char       line[256];
    char      *size;
    
    
    meminfo= fopen("/proc/meminfo", "r");
    if (meminfo == NULL)  return (-1);
    
    do  eof= fgets(line, 255, meminfo);  while (eof != NULL  &&  strncmp(line, MEMFREE, sizeof(MEMFREE)-1) != 0);
    if (eof == NULL)  {fclose(meminfo); return (-1);}
    size= &line[sizeof(MEMFREE)-1];
    while (*size != 0  &&  (*size < '0'  ||  *size > '9'))  size++;
    result= 1024*atol(size);
    
    do  eof= fgets(line, 255, meminfo);  while (eof != NULL  &&  strncmp(line, BUFFERS, sizeof(BUFFERS)-1) != 0);
    if (eof == NULL)  {fclose(meminfo); return (-1);}
    size= &line[sizeof(BUFFERS)-1];
    while (*size != 0  &&  (*size < '0'  ||  *size > '9'))  size++;
    result+= 0.98*1024*atol(size);
    
    do  eof= fgets(line, 255, meminfo);  while (eof != NULL  &&  strncmp(line, CACHED, sizeof(CACHED)-1) != 0);
    if (eof == NULL)  {fclose(meminfo); return (-1);}
    size= &line[sizeof(CACHED)-1];
    while (*size != 0  &&  (*size < '0'  ||  *size > '9'))  size++;
    result+= 0.98*1024*atol(size);
    
    do  eof= fgets(line, 255, meminfo);  while (eof != NULL  &&  strncmp(line, SWAPFREE, sizeof(SWAPFREE)-1) != 0);
    if (eof == NULL)  {fclose(meminfo); return (-1);}
    size= &line[sizeof(SWAPFREE)-1];
    while (*size != 0  &&  (*size < '0'  ||  *size > '9'))  size++;
    result+= 1024*atol(size);
    
    fclose(meminfo);
    
    return (result);
}

Toute reprise sauvage est possible. D'ailleurs il y a sans doute des améliorations à apporter :
- c'est un peu lent,
- si un caractère change dans les chaînes, ça se pète la gueule,
- l'unité des valeurs de /proc/meminfo est le ko et si ça change, pouf,
- par sécurité, je considère que les buffers ne sont pas entièrement vidables, qu'il doit leur rester arbitrairement 2% de leur taille.
Si quelqu'un a mieux et que c'est libre, je prends.

Salut Thibaut !
Merci beaucoup, je jetterai un œil demain. J'avais implémenté ça dans la foulée, j'ai pas eu de retour du client sur ce point pour l'instant vu qu'il partait en vacances. Dans tous les cas, je garde ça sous le coude
Merci !
(et bonne année )

Heu au fait, pour info j'ai codé ça avec quelques fscanf.
Faudra que je sécurise un peu tout ça pour la version définitive
(avec chaque entier défini comme un long long)

   FILE* fp= fopen("/proc/meminfo", "r") ;
   
   fscanf(fp, "MemTotal: %lld kB\n", &MemTotal) ;
   fscanf(fp, "MemFree: %lld kB\n", &MemFree) ;
   fscanf(fp, "Buffers: %lld kB\n", &Buffers) ;
   fscanf(fp, "Cached: %lld kB\n", &Cached) ;
   fscanf(fp, "SwapCached: %lld kB\n", &SwapCached) ;
   fscanf(fp, "Active: %lld kB\n", &Active) ;
   fscanf(fp, "Inactive: %lld kB\n", &Inactive) ;
   fscanf(fp, "HighTotal: %lld kB\n", &HighTotal) ;
   fscanf(fp, "HighFree: %lld kB\n", &HighFree) ;
   fscanf(fp, "LowTotal: %lld kB\n", &LowTotal) ;
   fscanf(fp, "LowFree: %lld kB\n", &LowFree) ;
   fscanf(fp, "SwapTotal: %lld kB\n", &SwapTotal) ;
   fscanf(fp, "SwapFree: %lld kB\n", &SwapFree) ;
   fscanf(fp, "Dirty: %lld kB\n", &Dirty) ;
   fscanf(fp, "Writeback: %lld kB\n", &Writeback) ;
   fscanf(fp, "AnonPages: %lld kB\n", &AnonPages) ;
   fscanf(fp, "Mapped: %lld kB\n", &Mapped) ;
   fscanf(fp, "Slab: %lld kB\n", &Slab) ;
   fscanf(fp, "PageTables: %lld kB\n", &PageTables) ;
   fscanf(fp, "NFS_Unstable: %lld kB\n", &NFS_Unstable) ;
   fscanf(fp, "Bounce: %lld kB\n", &Bounce) ;
   fscanf(fp, "CommitLimit: %lld kB\n", &CommitLimit) ;
   fscanf(fp, "Committed_AS: %lld kB\n", &Committed_AS) ;
   fscanf(fp, "VmallocTotal: %lld kB\n", &VmallocTotal) ;
   fscanf(fp, "VmallocUsed: %lld kB\n", &VmallocUsed) ;
   fscanf(fp, "VmallocChunk: %lld kB\n", &VmallocChunk) ;
   fscanf(fp, "HugePages_Total: %lld\n", &HugePages_Total) ;
   fscanf(fp, "HugePages_Free: %lld\n", &HugePages_Free) ;
   fscanf(fp, "HugePages_Rsvd: %lld\n", &HugePages_Rsvd) ;
   fscanf(fp, "Hugepagesize: %lld kB\n", &Hugepagesize) ;

   fclose(fp) ;

Thibaut (./15) :
- c'est un peu lent,

moué honnêtement, ça ne me semble pas super grave pour ce genre de fonction

- si un caractère change dans les chaînes, ça se pète la gueule,

oué, pareil pour tout le monde je pense.

- l'unité des valeurs de /proc/meminfo est le ko et si ça change, pouf,

- par sécurité, je considère que les buffers ne sont pas entièrement vidables, qu'il doit leur rester arbitrairement 2% de leur taille.

pkoi pas, mais perso j'ai juste besoin d'une estimation, pas du chiffre exact, donc je ne vais pas voir ce genre de détail

Passe une excellente année toi aussi
Je connais très mal scanf. Est-ce que ta méthode (tellement plus simple) fonctionne si l'ordre des champs change dans le fichier ?
Mais merci, tu m'inspires : je vais rajouter un rewind avant chaque paragraphe.

Pen^2 (./18) :
moué honnêtement, ça ne me semble pas super grave pour ce genre de fonction

Je pense que ça devient embêtant si on écrit son propre malloc dans le but de vérifier que la quantité demandée est disponible avant de faire appel au vrai malloc. L'utilisateur qui souhaite construire ses structures de données en allouant un par un chaque élément produira un programme très lent. C'est emmerdant qu'il n'existe pas une fonction rapide dans la bibliothèque standard pour vérifier la mémoire réellement disponible.

Merci

Thibaut (./19) :
Est-ce que ta méthode (tellement plus simple) fonctionne si l'ordre des champs change dans le fichier ?

Non, non
Si quelque chose change, tout explose
Sinon, c'est comme un fread pour l'avancement.

Thibaut (./19) :
C'est emmerdant qu'il n'existe pas une fonction rapide dans la bibliothèque standard pour vérifier la mémoire réellement disponible.

Oué, j'avoue. Je suppose que c'est trop lié au système.

Oula, c'est vraiment chiant et casse gueule tout ça :/

J'avoue. Je crois que je devrais coder des réveils sur mon temps libre !

Sérieusement, c'est du code de test pour l'instant pour voir si ça fonctionne. Et puis, de toute façon, on est prévenu en cas de changement d'environnement, donc ça reste acceptable.
Pour la vraie version je bouclerai sans doute pour trouver chaque ligne.

Pen^2 (./20) :

Thibaut (./19) :
Est-ce que ta méthode (tellement plus simple) fonctionne si l'ordre des champs change dans le fichier ?

Non, non
Si quelque chose change, tout explose
Sinon, c'est comme un fread pour l'avancement.

Note que tu peux facilement coder un petit framework si ça pète, du style:

void merIlEtFou(FILE *in, const char *fmt, ...) {
    va_list arg_ptr;
    va_start(arg_ptr, fmt);
    fseek(in, 0, SEEK_SET);
    while (!feof(f) && !vfscanf(in, fmt, arg_ptr));
    va_end(arg_ptr);
}

#define fscanf merIlEtFou

Mais ce serait encore mieux de le coder à partir d'expressions régulières en Perl par exemple (ou Python en ce qui me concerne).

Pen^2 (./22) :
J'avoue. Je crois que je devrais coder des réveils sur mon temps libre !

Ah ah

Thibaut (./19) :
C'est emmerdant qu'il n'existe pas une fonction rapide dans la bibliothèque standard pour vérifier la mémoire réellement disponible.

C'est surtout moins simple qu'il n'y paraît. Si le but est de vérifier combien il reste de place avant de faire une allocation mémoire, c'est foireux pour un tas de raisons :
- sur un système multitâche, la situation peut avoir changé entre l'appel de la fonction qui donne la taille mémoire restante et la fonction qui alloue de la mémoire
- pour satisfaire une allocation mémoire, le système peut libérer de la mémoire précédemment utilisée en swappant ou en virant des pages allouées à des caches
- la mémoire peut être fragmentée, ce qui fait qu'on ne peut pas forcément allouer autant que prévu (c'est pas trop un problème sur les machines qui gèrent la pagination, mais sur un système ancien ou peu puissant ça peut se produire)

Il y a le même genre de problèmes avec l'espace disque (par exemple, sur un système de fichiers compressé, l'espace disque restant est juste une estimation plus ou moins grossière).

Zerosquare (./25) :

Thibaut (./19) :
C'est emmerdant qu'il n'existe pas une fonction rapide dans la bibliothèque standard pour vérifier la mémoire réellement disponible.

C'est surtout moins simple qu'il n'y paraît. Si le but est de vérifier combien il reste de place avant de faire une allocation mémoire, c'est foireux pour un tas de raisons :
- sur un système multitâche, la situation peut avoir changé entre l'appel de la fonction qui donne la taille mémoire restante et la fonction qui alloue de la mémoire
- pour satisfaire une allocation mémoire, le système peut libérer de la mémoire précédemment utilisée en swappant ou en virant des pages allouées à des caches
- la mémoire peut être fragmentée, ce qui fait qu'on ne peut pas forcément allouer autant que prévu (c'est pas trop un problème sur les machines qui gèrent la pagination, mais sur un système ancien ou peu puissant ça peut se produire)

Il y a le même genre de problèmes avec l'espace disque (par exemple, sur un système de fichiers compressé, l'espace disque restant est juste une estimation plus ou moins grossière).

Enfin un OS "normal" propose quand meme ce genre de fonction, seul UNIX/LINUX n'a pas ça, et on doit bidouiller pour arriver a lire ce genre d'info, meme si c'est imprécis, ça peut servir de temps a autres pour faire du load balancing comme veux le faire pen²

Ah je dis pas le contraire, juste qu'il faut s'en méfier.

ou utiliser un mac.

BTW, http://msdn.microsoft.com/en-us/library/aa366589%28v=vs.85%29.aspx