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?
Respostas:
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;)
ps -caxm -orss= | awk '{ sum += $1 } END { print "Resident Set Size: " sum/1024 " MiB" }'
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 PhysMemAlé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'vm_stat.
topé significativamente mais lenta que a chamada, vm_statmas a topextração é muito menos detalhada e a unidade é megabyte e não páginas. Para ser ainda menos detalhada, as quebras de linha podem ser removidas e awksubstituídas grepresultando em top -l 1 | grep ^PhysMem.
pageunidades inúteis / requer algum tipo de pós-processamento hacky para tornar essas unidades interpretáveis.
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
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"
htop
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}'top -l1 | awk '/PhysMem/ {print $2}'on macos> = High Sierra
free="$(( $(vm_stat | awk '/free/ {gsub(/\./, "", $3); print $3}') * 4096 / 1048576)) MiB free"tcsh(meu padrão) ou sh. O comando é específico do shell?
bashe kshespecífico. Na tcshtentativa: set freeblocks=`vm_stat | grep free | awk '{ print $3 }' | sed 's/\.//'` ; set freeMB=`expr $freeblocks \* 4096 / 1048576`; set free=`echo $freeMB MiB free`. Você pode fazer isso echo $freepara imprimir a quantidade de memória livre. Você também pode criar um alias: alias free echo $freeMB 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:
system_profiler - Mostra todas as informações de perfil do sistema do Mac no shell 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.
allmemorypode ser inesperadamente longa - para mim hoje, mais de quatro minutos por execução, YMMV. Uma corrida de allmemoryfor sysdiagnosepode demorar consideravelmente mais.
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 memoryPorém, não sei se o hostinfo existe em qualquer sistema operacional anterior ...
hostinfomostra a memória usada ?
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%
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.
gawkque não faz parte de uma instalação padrão do OS X.
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: -tDevoluçõ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.63Se 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.95top ou htop também pode ajudar a resolver o problema.