Existe uma versão do Mac OS X Terminal do comando "free" nos sistemas Linux?

No Linux, costumo usar o comando free para ver a quantidade atual de memória livre e usada no sistema. Por exemplo:

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

Parece não existir quando entro freeno terminal do Mac OS X. Existe uma alternativa?

Como @khedron diz , você pode ver essas informações no Activity Monitor.

Se você quiser na linha de comando, aqui está um script Python que eu escrevi (ou talvez modificado a partir de outra pessoa, não me lembro, é muito antigo agora) para mostrar as quantidades de memória com fio, ativa, inativa e livre:

#!/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 você pode ver, você pode simplesmente chamar a vm_statpartir da linha de comando, apesar de contar em páginas de 4kB, daí o script para converter em MB.

O script também conta o uso de "memória real" de todos os processos em execução para comparação (isso não corresponde a nenhum valor específico das estatísticas gerais de memória, porque a memória é uma besta complexa).

Aqui está um exemplo da saída do script no meu 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

(ligeiramente ajustado para corresponder ao tamanho da guia no StackExchange;)

O comando que você precisa é vm_statsemelhante à ferramenta tradicional do Unix, vmstatmas com algumas diferenças específicas ao MACH. A página do manual está bem escrita.

Parece que o motivo é lento porque top -l 1sempre atrasa um segundo após a conclusão, o atraso padrão entre as atualizações. Adicionar -s 0 ao comando faz com que seja concluído instantaneamente:

top -l 1 -s 0 | grep PhysMem

Além disso, para maior clareza, gosto de mostrar cada componente mem em sua linha, então adicionei 9 espaços para alinhamento com 'PhysMem:' na sequência de substituição sed:

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

Aqui está uma linha simples para tornar toda a vm_statprodução mais amigável ao ser humano:

$ 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

Caso você esteja realmente interessado apenas no uso de swap (qual seria a última linha de saída free):

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

Há um terminal de comando semelhante ao freedo Mac OS X ... É chamadotop

Para obter mais informações, consulte este documento de suporte da Apple.

Mac OS X: Como exibir o uso de memória com o utilitário "top"

Basta pegar a solução do @zack e adicionar blocos inativos e 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}'

Somente para especialistas em Unix:

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

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

A julgar pela sua outra pergunta , acho que você encontrou o uso do utilitário Activity Monitor para verificar seu status de memória, certo? Apenas para o registro, está em / Aplicativos / Utilitários / Activity Monitor.app.

Não existe um equivalente exato distribuído no Mac OS X, mas existem outras maneiras de obter as informações:

1. system_profiler - Mostra todas as informações de perfil do sistema do Mac no shell
2. sysctl -a | grep memou sysctl hw.memsize(mem total)

Você pode tentar o comando allmemoryse desejar uma ferramenta de linha de comando que relate o uso extremamente detalhado da memória.

O exposto acima é um esforço demais para o meu gosto, e pressupõe que você também tenha uma instalação completa ... Se você inicializou a partir de um disco de inicialização do Mac OS X, todas as soluções acima obviamente não funcionarão. .. Basta usar o comando "hostinfo", aqui está a saída do meu MBAir de meados de 2012 executando o 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

O bom deste comando é que ele vem pré-instalado com o instalador 10.9 também /usr/bin, portanto é muito útil,

idealmente, se você quer apenas RAM, emita:

$ hostinfo | grep memory

Porém, não sei se o hostinfo existe em qualquer sistema operacional anterior ...

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

Isso deve fazer muito bem :)

Penso que atualmente, psutile seu meminfo.pyscript fornece os detalhes mais úteis sobre o uso da memória. Experimentá-lo:

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

A saída que ele produz se parece com isso:

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 a Availablelinha, que mostra uma estimativa da quantidade de memória realmente disponível para iniciar novos aplicativos , sem trocar.

Não conheço nenhum outro utilitário MacOS que ofereça essa estimativa de memória disponível.

Para fins de comparação: Em um sistema Linux, o mesmo tipo de informação é fornecido na availablecoluna na saída das versões atuais 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

Essa availablecoluna na freesaída apenas vem MemAvailableem /proc/meminfo. E em sistemas que possuem /proc/meminfo, o psutil também usa isso para estimar a memória disponível.

Mas MacOS não tem /proc/meminfo, por isso, para estimar a memória disponível, nesse caso, psutil emprega o mesmo algoritmo usado no Linux para calcular MemAvailablepara/proc/meminfo .

Você pode tentar o memory_pressurecomando Veja a saída do meu 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 "free like" para Mac OSX.

Esta é a segunda reedição deste post. No começo, eu tenho dois -1. Um porque eu não estava descrevendo em inglês, está corrigido. O outro, porque eu usei gawk(que não faz parte de uma instalação padrão do OS X), também é corrigido, agora uso awk. O -2ainda estão lá ;-). Talvez o melhor agora seja testar e avaliar os comandos por si próprios?

Revisei minha primeira ideia para criar apenas um comando orientado ao usuário final com uma exibição amigável e altamente configurável; fiz duas:

• free-like.sh um script sempre orientado para "usuário final", com mais precisão, uma exibição "amigável" e configurável, mas com mais cálculos e consumo de recursos,

• free-like-raw.sh, um desenvolvedor agora orientado a comando, sysadmin, etc., com menos computação e consumo de recursos, mas também com menos precisão, exibição menos "amigável".

Os dados para a memória física são extraídos dos resultados do comando vm_stat(que retorna os resultados em tamanho de bloco). A imprecisão resultante da transformação em bytes (number_of_blocks * block_size, o valor padrão dos cálculos) estará entre 0 <o tamanho do bloco. Os dados da memória virtual são obtidos do topcomando A imprecisão aqui está ligada à unidade de referência do topcomando: kilo, mega, giga.

Os cálculos são feitos com awkrespeito aos aspectos arredondados (em oposição a bc). awktambém é mais rápido que bc. Você pode ver o script de teste aqui: http://myblog.robert.sebille.name/article29.html#awk-bc

Você pode visualizar os resultados dos comandos em bytes (padrão), em quilo, mega ou giga, com x casas decimais no caso de free-like.sh e se você solicitar a exibição em mega ou giga.

Os scripts são muito longos para uma postagem, mas você pode encontrá-los neste artigo do meu blog: http://myblog.robert.sebille.name/article29.html

O artigo está em francês, mas exibe um exemplo de exibição para cada comando e sua ajuda integrada ( ./free-like.sh -he ./free-like-raw.sh -h), em inglês. Esses auxílios descrevem completamente os comandos. O artigo também exibe os códigos.

Inglês não é minha língua materna. Se alguém quiser corrigir erros na ajuda integrada, será bem-vindo;).

Sua.

Isso funciona no meu $ PS1:

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

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

vm_stat mostra em kilobytes.

O oneliner abaixo mostra em 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

Devoluções:

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

Se você usar o fishshell no osx, junto com o fisher, seu gerenciador de pacotes.

Eu escrevi a seguinte extensão: https://github.com/fisherman/free

É uma refazer completa do comando free para osx. Veja você mesmo

> 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 também pode ajudar a resolver o problema.