Jak uzyskać przenośną ilość dostępnej pamięci między dystrybucjami?

Standardowe pliki / narzędzia zgłaszające pamięć wydają się mieć różne formaty w różnych dystrybucjach systemu Linux. Na przykład w Arch i Ubuntu.

• Łuk

  $ 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
  

Jak mogę przenośnie (tylko w różnych dystrybucjach Linuksa) i niezawodnie uzyskać ilość pamięci - z wyjątkiem wymiany - dostępnej dla mojego oprogramowania w określonym czasie? Prawdopodobnie to jest pokazywane jako „dostępne” i „MemAvailable” na wyjściu freeiw cat /proc/meminfoArch, ale jak mogę uzyskać to samo w Ubuntu lub innej dystrybucji?

MemAvailablejest zawarty w /proc/meminfowersji 3.14 jądra; został dodany przez commit 34e431b0a . To czynnik decydujący o wyświetlanych wariantach wyjściowych. Komunikat zatwierdzenia wskazuje, jak oszacować dostępną pamięć bez MemAvailable:

Obecnie ilość pamięci, która jest dostępna dla nowego nakładu pracy, bez pchania system do wymiany, można oszacować MemFree, Active(file), Inactive(file), i SReclaimable, a także znaki wodne „Low” z /proc/zoneinfo.

Niskie znaki wodne to poziom, poniżej którego system będzie zamieniał. Tak więc w przypadku braku MemAvailablemożna przynajmniej sumować wartości podane dla MemFree, Active(file), Inactive(file)oraz SReclaimable(w zależności od tego są obecne w /proc/meminfo) i odjąć od niskich znaków wodnych /proc/zoneinfo. Ta ostatnia zawiera również liczbę bezpłatnych stron na strefę, które mogą być przydatne jako porównanie ...

Kompletny algorytm jest podany w łatce meminfo.ci wydaje się dość łatwy do dostosowania:

• zsumuj niskie znaki wodne we wszystkich strefach;
• weź zidentyfikowaną wolną pamięć ( MemFree);
• odejmij niski znak wodny (musimy unikać jego dotykania, aby uniknąć zamiany);
• dodaj ilość pamięci, którą możemy użyć z pamięci podręcznej strony (suma Active(file)i Inactive(file)): jest to ilość pamięci używanej przez pamięć podręczną strony, pomniejszona o połowę pamięci podręcznej strony lub niski znak wodny, w zależności od tego, która wartość jest mniejsza;
• dodaj ilość pamięci, którą możemy odzyskać ( SReclaimable), postępując zgodnie z tym samym algorytmem.

Podsumowując, możesz uzyskać dostępną pamięć dla nowego procesu dzięki:

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 

Chociaż odpowiedź Stephena jest całkowicie wystarczająca i popełniła błąd po stronie ostrożności, postanowiłem napisać pełną logikę, w tym minimalne porównania. Informacje są najpierw odczytywane z / proc / meminfo i przechowywane w zmiennej, dzięki czemu szczegóły pamięci są spójne.

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

Wynik przechowywany w zmiennej jest w bajtach.