¿Existe una versión para Mac OS X Terminal del comando "gratis" en sistemas Linux?

En Linux, a menudo uso el comando free para ver la cantidad actual de memoria libre y usada en el sistema. Por ejemplo:

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

Parece que no existe cuando entro freeen la Terminal de Mac OS X. ¿Hay una alternativa?

Como dice @khedron , puede ver esta información en el Monitor de actividad.

Si lo desea en la línea de comandos, aquí hay un script de Python que escribí (o quizás modificado de otra persona, no puedo recordar, es bastante antiguo ahora) para mostrarle las cantidades de memoria cableada, activa, inactiva y 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 ))

Como puede ver, puede llamar vm_statdesde la línea de comandos, aunque cuenta en páginas de 4kB, de ahí el script para convertir a MB.

El script también cuenta el uso de "memoria real" de todos los procesos en ejecución para la comparación (esto no coincidirá con ningún valor específico de las estadísticas generales de la memoria, porque la memoria es una bestia compleja).

Aquí hay un ejemplo de la salida del script en mi sistema:

[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

(muy ligeramente ajustado para que coincida con el tamaño de la pestaña en StackExchange;)

El comando que necesita es vm_stat: similar a la herramienta tradicional de Unix vmstatpero con algunas diferencias específicas de MACH. La página del manual está bien escrita.

Parece que la razón por la que es lenta es porque top -l 1siempre se demora un segundo después de completar, el retraso estándar entre actualizaciones. Agregar -s 0 al comando lo completa al instante:

top -l 1 -s 0 | grep PhysMem

Además, para mayor claridad, me gusta mostrar cada componente mem en su línea, por lo que agregué 9 espacios para la alineación con 'PhysMem:' en la cadena de reemplazo de sed:

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

Aquí hay una línea simple para hacer que toda la vm_statsalida sea más amigable para los humanos:

$ 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

En caso de que solo esté realmente interesado en el uso de intercambio (cuál sería la última línea de salida free):

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

Hay un comando de terminal similar a freeMac OS X ... se llamatop

Para obtener más información, puede consultar este documento de soporte de Apple.

Mac OS X: Cómo ver el uso de la memoria con la utilidad "superior"

Simplemente tomando la solución de @zack y agregando bloques inactivos y especulativos.

#!/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}'

Solo para expertos de Unix:

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

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

A juzgar por su otra pregunta , creo que ha encontrado el uso de la utilidad Monitor de actividad para ver el estado de su memoria, ¿verdad? Solo para el registro, está en / Aplicaciones / Utilidades / Activity Monitor.app.

No hay un equivalente exacto que se distribuya con Mac OS X, pero hay otras dos formas de obtener la información:

1. system_profiler - Muestra toda la información del perfil del sistema de Mac en el shell
2. sysctl -a | grep memo sysctl hw.memsize(total mem)

Puede probar el comando allmemorysi desea una herramienta de línea de comando que informe sobre el uso de memoria extremadamente detallado.

Lo anterior es demasiado esfuerzo para mi gusto, y supone que usted también tiene una instalación completa ... Si ha arrancado desde un disco de inicio de Mac OS X, entonces todas las soluciones anteriores obviamente no funcionarán. .. Solo use el comando "hostinfo", aquí está el resultado de mi MBAir de mediados de 2012 ejecutando 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

Lo bueno de este comando es que viene preinstalado con el instalador 10.9 también debajo /usr/bin, por lo que es muy útil,

idealmente, si solo quieres RAM, entonces emite:

$ hostinfo | grep memory

Sin embargo, no sé si hostinfo existe en cualquier sistema operativo anterior ...

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

Esto debería hacerlo bien :)

Creo que en estos días, psutily su meminfo.pyscript proporciona los detalles más útiles sobre el uso de la memoria. Intentarlo:

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

La salida que produce se ve así:

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

Observe la Availablefila, que muestra una estimación de cuánta memoria está realmente disponible para iniciar nuevas aplicaciones , sin intercambiar.

No conozco ninguna otra utilidad MacOS que proporcione esa estimación de memoria disponible.

En aras de la comparación: en un sistema Linux, se proporciona el mismo tipo de información en la availablecolumna en la salida de las versiones actuales 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

Esa availablecolumna en la freesalida solo viene de MemAvailableadentro /proc/meminfo. Y en los sistemas que tienen /proc/meminfo, psutil también solo lo usa para estimar la memoria disponible.

Pero MacOS no tiene /proc/meminfo, por lo que para estimar la memoria disponible en ese caso, psutil emplea el mismo algoritmo utilizado en Linux para el cálculo MemAvailablede/proc/meminfo .

Puedes probar el memory_pressurecomando. Ver la salida de mi sistema (i5, 4 GB 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%

Comandos Bash "gratis como" para Mac OSX.

Esta es la segunda reedición de esta publicación. Al principio, tengo dos -1. Uno porque no estaba describiendo en inglés, está corregido. El otro porque lo usé gawk(que no es parte de una instalación estándar de OS X), también está corregido, ahora lo uso awk. El -2todavía están allí ;-). ¿Quizás lo mejor es probar y evaluar los comandos por sí mismos?

Revisé mi primera idea para construir solo un comando orientado al usuario final con una pantalla amigable y altamente configurable, hice dos:

• free-like.sh un script siempre orientado al "usuario final", con más precisión, una pantalla "amigable" y configurable, pero con más cálculos y consumo de recursos,

• free-like-raw.sh, un comando ahora orientado a desarrolladores, administradores de sistemas, etc., con menos cómputo y consumo de recursos, pero también con menos precisión, pantalla menos "amigable".

Los datos para la memoria física se extraen de los resultados del comando vm_stat(que devuelve los resultados en tamaño de bloque). La imprecisión resultante de la transformación en bytes (número_de_bloques * tamaño_bloque, el valor predeterminado de los cálculos) estará entre 0 <el tamaño del bloque. Los datos para la memoria virtual se toman del topcomando. La imprecisión aquí está vinculada a la unidad de referencia del topcomando: kilo, mega, giga.

Los cálculos se realizan utilizando los awkaspectos redondeados (en lugar de bc). awkTambién es más rápido que bc. Puede ver el script de prueba aquí: http://myblog.robert.sebille.name/article29.html#awk-bc

Puede ver los resultados de los comandos en bytes (predeterminado), en kilo, mega o giga, con x decimales en el caso de free-like.sh y si pregunta la pantalla en mega ou giga.

Los scripts son demasiado largos para una publicación, pero puede encontrarlos en este artículo de mi blog: http://myblog.robert.sebille.name/article29.html

El artículo está en francés, pero muestra un ejemplo de visualización para cada comando y su ayuda integrada ( ./free-like.sh -hy ./free-like-raw.sh -h), en inglés. Estas ayudas describen completamente los comandos. El artículo muestra también los códigos.

El inglés no es mi lengua materna. Si alguien quiere corregir errores en la ayuda integrada, es bienvenido;).

tuya.

Esto se ejecuta en mi $ PS1:

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

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

vm_stat te muestra en kilobytes.

La línea de abajo se muestra en megabytes:

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

Devoluciones:

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 es el caso, utiliza fishshell en osx, junto con fisher, su administrador de paquetes.

Escribí la siguiente extensión: https://github.com/fisherman/free

Es un rehacer completo del comando gratuito para osx. Ver por ti mismo

> 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 o htop también puede ayudar a resolver el problema.