Comment puis-je obtenir la quantité de mémoire disponible de manière portable dans les distributions?

Les fichiers / outils standard qui signalent la mémoire semblent avoir différents formats sur différentes distributions Linux. Par exemple, sur Arch et Ubuntu.

• Cambre

  $ free
                total        used        free      shared  buff/cache   available
  Mem:        8169312     3870392     2648348       97884     1650572     4110336
  Swap:      16777212      389588    16387624
  
  
  $ head /proc/meminfo 
  MemTotal:        8169312 kB
  MemFree:         2625668 kB
  MemAvailable:    4088520 kB
  Buffers:          239688 kB
  Cached:          1224520 kB
  SwapCached:        17452 kB
  Active:          4074548 kB
  Inactive:        1035716 kB
  Active(anon):    3247948 kB
  Inactive(anon):   497684 kB
  

• Ubuntu

  $ free
               total       used       free     shared    buffers     cached
  Mem:      80642828   69076080   11566748    3063796     150688   58358264
  -/+ buffers/cache:   10567128   70075700
  Swap:     20971516    5828472   15143044
  
  
  $ head /proc/meminfo 
  MemTotal:       80642828 kB
  MemFree:        11565936 kB
  Buffers:          150688 kB
  Cached:         58358264 kB
  SwapCached:      2173912 kB
  Active:         27305364 kB
  Inactive:       40004480 kB
  Active(anon):    7584320 kB
  Inactive(anon):  4280400 kB
  Active(file):   19721044 kB
  

Alors, comment puis-je porter de manière portable (sur des distributions Linux uniquement) et obtenir de manière fiable la quantité de mémoire (hors swap) disponible pour mon logiciel à un moment donné? Vraisemblablement, c'est ce qui est indiqué comme «disponible» et «MemAvailable» dans la sortie de freeet cat /proc/meminfodans Arch, mais comment puis-je obtenir les mêmes dans Ubuntu ou une autre distribution?

MemAvailableest inclus /proc/meminfodepuis la version 3.14 du noyau; il a été ajouté par commit 34e431b0a . C'est le facteur déterminant dans les variations de sortie que vous montrez. Le message de validation indique comment estimer la mémoire disponible sans MemAvailable:

À l' heure actuelle, la quantité de mémoire disponible pour une nouvelle charge de travail, sans pousser le système de swap, peut être estimée à partir MemFree, Active(file), Inactive(file), et SReclaimable, ainsi que les « filigranes de bas » de /proc/zoneinfo.

Les filigranes bas sont le niveau en dessous duquel le système va permuter. Donc , en l'absence de MemAvailablevous pouvez au moins additionner les valeurs données pour MemFree, Active(file), Inactive(file)et SReclaimable(selon sont présents dans /proc/meminfo) et soustraire les bas de filigranes /proc/zoneinfo. Ce dernier répertorie également le nombre de pages libres par zone, ce qui pourrait être utile à titre de comparaison ...

L'algorithme complet est donné dans le patch meminfo.cet semble assez facile à adapter:

• additionner les filigranes bas dans toutes les zones;
• prenez la mémoire libre identifiée ( MemFree);
• soustraire le filigrane bas (nous devons éviter de le toucher pour éviter de permuter);
• ajouter la quantité de mémoire que nous pouvons utiliser à partir du cache de pages (somme de Active(file)et Inactive(file)): c'est la quantité de mémoire utilisée par le cache de pages, moins la moitié du cache de pages, ou le filigrane bas, le plus petit des deux;
• ajoutez la quantité de mémoire que nous pouvons récupérer ( SReclaimable), en suivant le même algorithme.

Donc, en rassemblant tout cela, vous pouvez obtenir la mémoire disponible pour un nouveau processus avec:

awk -v low=$(grep low /proc/zoneinfo | awk '{k+=$2}END{print k}') \
 '{a[$1]=$2}
  END{ 
   print a["MemFree:"]+a["Active(file):"]+a["Inactive(file):"]+a["SReclaimable:"]-(12*low); 
  }' /proc/meminfo 

Alors que la réponse de Stephen est parfaitement suffisante et fait preuve de prudence, j'ai décidé de rédiger la logique complète, y compris les comparaisons minimales. Les informations sont d'abord lues dans / proc / meminfo et stockées dans une variable afin que les détails de la mémoire soient cohérents.

LOW_WATERMARK=$(awk '$1 == "low" {LOW_WATERMARK += $2} END {print LOW_WATERMARK * 4096}' /proc/zoneinfo)

MEMINFO=$(</proc/meminfo)

MEMINFO_MEMFREE=$(echo "${MEMINFO}" | awk '$1 == "MemFree:" {print $2 * 1024}')
MEMINFO_FILE=$(echo "${MEMINFO}" | awk '{MEMINFO[$1]=$2} END {print (MEMINFO["Active(file):"] + MEMINFO["Inactive(file):"]) * 1024}')
MEMINFO_SRECLAIMABLE=$(echo "${MEMINFO}" | awk '$1 == "SReclaimable:" {print $2 * 1024}')

MEMINFO_MEMAVAILABLE=$((
  MEMINFO_MEMFREE - LOW_WATERMARK
  + MEMINFO_FILE - ((MEMINFO_FILE/2) < LOW_WATERMARK ? (MEMINFO_FILE/2) : LOW_WATERMARK)
  + MEMINFO_SRECLAIMABLE - ((MEMINFO_SRECLAIMABLE/2) < LOW_WATERMARK ? (MEMINFO_SRECLAIMABLE/2) : LOW_WATERMARK)
))

if [[ "${MEMINFO_MEMAVAILABLE}" -le 0 ]]
then
  MEMINFO_MEMAVAILABLE=0
fi

Le résultat stocké dans la variable est en octets.