Existe-t-il une version Mac OS X Terminal de la commande «free» sur les systèmes Linux?

Sous Linux, j'utilise souvent la commande free pour voir la quantité actuelle de mémoire libre et utilisée dans le système. Par exemple:

$ free
             total       used       free     shared    buffers     cached
Mem:       7264256    1010952    6253304          0     371892     189088
-/+ buffers/cache:     449972    6814284
Swap:      8126456         28    8126428

Il ne semble pas exister lorsque j'entre freedans le terminal de Mac OS X. Y a-t-il une alternative?

Comme @khedron le dit , vous pouvez voir cette information dans Activity Monitor.

Si vous le souhaitez sur la ligne de commande, voici un script Python que j'ai écrit (ou peut-être modifié de quelqu'un d'autre, je ne me souviens plus, il est assez ancien maintenant) pour vous montrer les quantités de mémoire câblée, active, inactive et libre:

#!/usr/bin/python

import subprocess
import re

# Get process info
ps = subprocess.Popen(['ps', '-caxm', '-orss,comm'], stdout=subprocess.PIPE).communicate()[0].decode()
vm = subprocess.Popen(['vm_stat'], stdout=subprocess.PIPE).communicate()[0].decode()

# Iterate processes
processLines = ps.split('\n')
sep = re.compile('[\s]+')
rssTotal = 0 # kB
for row in range(1,len(processLines)):
    rowText = processLines[row].strip()
    rowElements = sep.split(rowText)
    try:
        rss = float(rowElements[0]) * 1024
    except:
        rss = 0 # ignore...
    rssTotal += rss

# Process vm_stat
vmLines = vm.split('\n')
sep = re.compile(':[\s]+')
vmStats = {}
for row in range(1,len(vmLines)-2):
    rowText = vmLines[row].strip()
    rowElements = sep.split(rowText)
    vmStats[(rowElements[0])] = int(rowElements[1].strip('\.')) * 4096

print 'Wired Memory:\t\t%d MB' % ( vmStats["Pages wired down"]/1024/1024 )
print('Active Memory:\t\t%d MB' % ( vmStats["Pages active"]/1024/1024 ))
print('Inactive Memory:\t%d MB' % ( vmStats["Pages inactive"]/1024/1024 ))
print('Free Memory:\t\t%d MB' % ( vmStats["Pages free"]/1024/1024 ))
print('Real Mem Total (ps):\t%.3f MB' % ( rssTotal/1024/1024 ))

Comme vous pouvez le constater, vous pouvez simplement appeler à vm_statpartir de la ligne de commande, même si cela compte en pages de 4 Ko, d'où le script pour convertir en Mo.

Le script compte également l'utilisation "réelle de la mémoire" de tous les processus en cours à des fins de comparaison (elle ne correspond à aucune valeur spécifique des statistiques de la mémoire globale, car la mémoire est une bête complexe).

Voici un exemple de la sortie du script sur mon système:

[user@host:~] % memReport.py
Wired Memory:           1381 MB
Active Memory:          3053 MB
Inactive Memory:        727 MB
Free Memory:            1619 MB
Real Mem Total (ps):    3402.828 MB

(très légèrement ajusté pour correspondre à la taille de l'onglet sur StackExchange;)

La commande dont vous avez besoin est vm_stat- similaire à l'outil Unix traditionnel, vmstatmais avec quelques différences spécifiques à MACH. La page de manuel est bien écrite.

Il semble que la raison pour laquelle c'est lent est parce que top -l 1le délai standard entre les rafraîchissements est toujours retardé d'une seconde après la fin. L'ajout de -s 0 à la commande la complète instantanément:

top -l 1 -s 0 | grep PhysMem

De plus, pour plus de clarté, j'aime afficher chaque composant mem sur sa ligne. J'ai donc ajouté 9 espaces pour l'alignement sur 'PhysMem:' dans la chaîne de remplacement sed:

top -l 1 -s 0 | grep PhysMem | sed 's/, /\n         /g'

Voici un simple support pour rendre la vm_statsortie plus conviviale:

$ vm_stat | perl -ne '/page size of (\d+)/ and $size=$1; /Pages\s+([^:]+)[^\d]+(\d+)/ and printf("%-16s % 16.2f Mi\n", "$1:", $2 * $size / 1048576);'
free:                     2330.23 Mi
active:                   2948.07 Mi
inactive:                 1462.97 Mi
speculative:               599.45 Mi
wired down:                840.46 Mi
copy-on-write:           43684.84 Mi
zero filled:            385865.48 Mi
reactivated:               608.14 Mi

Si vous êtes uniquement intéressé par l'utilisation de swap (quelle serait la dernière ligne de sortie free):

$ sysctl vm.swapusage
vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)

Il existe une commande de terminal similaire à celle de freeMac OS X ... elle s’appelletop

Pour plus d'informations, vous pouvez consulter ce document d'assistance Apple.

Mac OS X: Comment afficher l'utilisation de la mémoire avec l'utilitaire "top"

En prenant simplement la solution de @zack et en ajoutant des blocs inactifs et spéculatifs.

#!/bin/bash

FREE_BLOCKS=$(vm_stat | grep free | awk '{ print $3 }' | sed 's/\.//')
INACTIVE_BLOCKS=$(vm_stat | grep inactive | awk '{ print $3 }' | sed 's/\.//')
SPECULATIVE_BLOCKS=$(vm_stat | grep speculative | awk '{ print $3 }' | sed 's/\.//')

FREE=$((($FREE_BLOCKS+SPECULATIVE_BLOCKS)*4096/1048576))
INACTIVE=$(($INACTIVE_BLOCKS*4096/1048576))
TOTAL=$((($FREE+$INACTIVE)))
echo Free:       $FREE MB
echo Inactive:   $INACTIVE MB
echo Total free: $TOTAL MB

#!/bin/bash
top -l 1 | grep PhysMem: | awk '{print $10}'

Pour les experts Unix uniquement:

top -l 1 | awk '/PhysMem:/ {print $10}'

free="$(( $(vm_stat | awk '/free/ {gsub(/\./, "", $3); print $3}') * 4096 / 1048576)) MiB free"

D'après votre autre question , je pense que vous avez trouvé l'utilisation de l'utilitaire Activity Monitor pour examiner l'état de votre mémoire, n'est-ce pas? Pour mémoire, il se trouve dans / Applications / Utilitaires / Activity Monitor.app.

Il n’existe pas d’équivalent exact distribué avec Mac OS X, mais il existe deux autres moyens d’obtenir ces informations:

1. system_profiler - Affiche toutes les informations du profil système du Mac dans le shell
2. sysctl -a | grep memou sysctl hw.memsize(total mem)

Vous pouvez essayer la commande allmemorysi vous voulez un outil de ligne de commande qui rapporte une utilisation extrêmement détaillée de la mémoire.

Ce qui précède représente beaucoup trop d’efforts à mon goût, et suppose que vous avez également une installation à part entière ... Si vous avez démarré à partir d’un disque de démarrage Mac OS X, toutes les solutions ci-dessus ne fonctionneront évidemment pas. .. Utilisez simplement la commande "hostinfo", voici le résultat de mon MBAir mi-2012 exécutant Mavericks (10.9.1):

 Mach kernel version:
 Darwin Kernel Version 13.0.0: Thu Sep 19 22:22:27 PDT 2013; root:xnu-2422.1.72~6/RELEASE_X86_64
Kernel configured for up to 4 processors.
2 processors are physically available.
4 processors are logically available.
Processor type: i486 (Intel 80486)
Processors active: 0 1 2 3
Primary memory available: 8.00 gigabytes
Default processor set: 195 tasks, 961 threads, 4 processors
Load average: 1.61, Mach factor: 2.38

L’avantage de cette commande, c’est qu’il est livré avec le programme d’installation 10.9 également /usr/bin, il est donc très pratique,

idéalement, si vous voulez juste de la RAM, alors tapez:

$ hostinfo | grep memory

Je ne sais pas si hostinfo existe sur les précédents systèmes d'exploitation ...

top -l 1 -s 0 | awk ' /Processes/ || /PhysMem/ || /Load Avg/{print}'

Cela devrait bien faire :)

Vous pouvez essayer la memory_pressurecommande. Voir la sortie de mon système (i5, 4 Go de RAM)

The system has 2147483648 (524288 pages with a page size of 4096).

Stats: 
Pages free: 90009 
Pages purgeable: 139593 
Pages purged: 7496548 

Swap I/O:
Swapins: 470466 
Swapouts: 530913 

Page Q counts:
Pages active: 407739 
Pages inactive: 148277 
Pages speculative: 16200 
Pages throttled: 0 
Pages wired down: 263064 

Compressor Stats:
Pages used by compressor: 122815 
Pages decompressed: 7327420 
Pages compressed: 17625795 

File I/O:
Pageins: 1538997 
Pageouts: 86692 

System-wide memory free percentage: 63%

Commandes Bash "free like" pour Mac OSX.

Ceci est la deuxième réédition de ce post. Au début, j'en ai deux -1. Un parce que je ne décrivais pas en anglais, c'est corrigé. L'autre parce que j'ai utilisé gawk(qui ne fait pas partie d'une installation standard d'OS X), il est également corrigé, je l'utilise maintenant awk. Le -2sont toujours là ;-). Le mieux est peut-être maintenant de tester et d’évaluer les commandes elles-mêmes?

J'ai passé en revue ma première idée de créer une seule commande orientée utilisateur avec un affichage convivial et hautement configurable.

• free-like.sh un script toujours orienté "utilisateur final", avec plus de précision, un affichage "convivial" et configurable, mais avec plus de calculs et de consommation de ressources,

• free-like-raw.sh, commande maintenant orientée développeur, sysadmin, etc., avec moins de calcul et moins de consommation de ressources, mais aussi avec moins de précision, un affichage moins "convivial".

Les données de la mémoire physique sont extraites des résultats de la commande vm_stat(qui renvoie les résultats en tailles de bloc). L'imprécision résultant de la transformation en octets (number_of_blocks * block_size, la valeur par défaut des calculs) sera comprise entre 0 <la taille du bloc. Les données pour la mémoire virtuelle sont extraites de la topcommande. L'imprécision est ici liée à l'unité de référence de la topcommande: kilo, méga, giga.

Les calculs sont effectués en utilisant awkce respect arrondi (par opposition à bc). awkest aussi plus rapide que bc. Vous pouvez voir le script de test ici: http://myblog.robert.sebille.name/article29.html#awk-bc

Vous pouvez afficher les résultats des commandes en octets (par défaut), en kilo, méga ou giga, avec x décimales dans le cas de free-like.sh et si vous demandez l’affichage en méga ou giga.

Les scripts sont trop longs pour un article, mais vous pouvez les trouver sur cet article de mon blog: http://myblog.robert.sebille.name/article29.html

L'article est en français, mais il affiche un exemple d'affichage pour chaque commande et leur aide intégrée ( ./free-like.sh -het ./free-like-raw.sh -h), en anglais. Ces aides décrivent complètement les commandes. L'article affiche également les codes.

L'anglais n'est pas ma langue maternelle. Si quelqu'un veut corriger des erreurs dans l'aide intégrée, il est le bienvenu;).

le tiens.

Cela fonctionne à mon $ PS1:

https://github.com/vigo/dotfiles-universal/blob/master/prompts/free_memory

(Version Ruby: https://github.com/vigo/dotfiles-universal/blob/master/prompts%2Ffree_memory.rb )

Je pense que ces jours-ci psutilet son meminfo.pyscript fournissent les détails les plus utiles sur l'utilisation de la mémoire. Pour l'essayer:

pip install psutil
curl -O https://raw.githubusercontent.com/giampaolo/psutil/master/scripts/meminfo.py
python ./meminfo.py

La sortie qu'il produit ressemble à ceci:

MEMORY
------
Total      :   16.0G
Available  :    5.5G
Percent    :    65.8
Used       :   13.5G
Free       :    1.5G
Active     :    7.4G
Inactive   :    4.0G
Wired      :    2.1G

SWAP
----
Total      :    1.0G
Used       :   33.5M
Free       :  990.5M
Percent    :     3.3
Sin        :   15.9G
Sout       :   71.6M

Remarquez la Availableligne, qui indique une estimation de la quantité de mémoire réellement disponible pour démarrer de nouvelles applications , sans permutation.

Je ne connais aucun autre utilitaire MacOS fournissant cette estimation de la mémoire disponible.

À des fins de comparaison: sur un système Linux, le même type d’informations est fourni dans la availablecolonne de sortie des versions actuelles de free:

              total        used        free      shared  buff/cache   available
Mem:           7.8G        552M        182M        156M        7.1G        6.9G
Swap:            0B          0B          0B
Total:         7.8G        552M        182M

Cette availablecolonne en freesortie vient juste de MemAvailabledans /proc/meminfo. Et sur les systèmes qui en ont /proc/meminfo, psutil l’utilise également pour estimer la mémoire disponible.

Mais MacOS n'a pas /proc/meminfo, pour ainsi estimer la mémoire disponible dans ce cas, psutil utilise le même algorithme utilisé sur Linux pour calculer MemAvailablepour/proc/meminfo .

vm_stat vous montre en kilo-octets.

L'oneliner ci-dessous indique en mégaoctets:

paste <(vm_stat | awk 'NR>1' | grep -o ".*:") <(for i in $(vm_stat | awk 'NR>1' | tr -d '.' | awk '{print $NF}'); do perl -e "print $i/1024" | awk '{printf "%0.2f", $0}'; echo; done) | column -s: -t

Résultats:

Pages free                      11.06
Pages active                    798.25
Pages inactive                  776.03
Pages speculative               9.15
Pages throttled                 0.00
Pages wired down                303.27
Pages purgeable                 0.95
"Translation faults"            82172.66
Pages copy-on-write             11629.60
Pages zero filled               27685.41
Pages reactivated               1450.70
Pages purged                    91.66
File-backed pages               430.20
Anonymous pages                 1153.24
Pages stored in compressor      481.75
Pages occupied by compressor    149.91
Decompressions                  1277.92
Compressions                    1622.33
Pageins                         13198.02
Pageouts                        66.61
Swapins                         54.34
Swapouts                        90.63

Si vous utilisez fishshell sur osx, avec son gestionnaire de packages.

J'ai écrit l'extension suivante: https://github.com/fisherman/free

C'est une refonte complète de la commande free pour osx. Voyez vous-même

> free
                 total     used     free   appmem    wired   compressed
Mem:            8.00Gb   6.65Gb   1.95Gb   2.87Gb   2.09Gb   1.86Gb
+/- Cache:               1.24Gb   1.87Gb
Swap(43%):      2048Mb    877Mb   1171Mb
Load Avg:        1.63 1.95 1.95

top ou htop peuvent également aider à résoudre le problème.