Se você realmente tem RAM suficiente disponível novamente, você pode usar esta sequência (como root):
$ swapoff -a
$ swapon -a
(para forçar a troca explícita de todos os seus aplicativos)
(assumindo que você esteja usando o linux)
Se a minha área de trabalho ficar sem memória e trocar muito, então eu libero ou mato o aplicativo perdendo minha memória RAM. Mas, depois disso, todas as minhas áreas de trabalho / aplicativos foram trocadas e são terrivelmente lentas, você sabe uma maneira de "unswap" (recarregar do espaço de swap na RAM) meu desktop / aplicativos?
O seguinte script python rápido e sujo despeja a memória de um processo para stdout. Isso tem o efeito colateral de carregar qualquer página trocada ou arquivo mapeado. Chame-o como cat_proc_mem 123 456 789 , em que os argumentos são IDs de processo.
Este script é completamente específico para o Linux. Pode ser adaptável a outros sistemas com uma estrutura /proc similar (Solaris?), Mas esqueça de executá-lo, por ex. * BSD Mesmo no Linux, talvez seja necessário alterar a definição de c_pid_t e os valores de PTRACE_ATTACH e PTRACE_DETACH . Este é um script de prova de princípio, não concebido como um exemplo de boas práticas de programação. Use a seu próprio risco.
O Linux disponibiliza a memória de um processo como /proc/$pid/mem . Apenas determinados intervalos de endereços são legíveis. Esses intervalos podem ser encontrados lendo as informações de mapeamento de memória do arquivo de texto /proc/$pid/maps . O pseudo arquivo /proc/$pid/mem não pode ser lido por todos os processos que têm permissão para lê-lo: o processo do leitor deve ter chamado ptrace(PTRACE_ATTACH, $pid) .
#!/usr/bin/env python
import ctypes, re, sys
## Partial interface to ptrace(2), only for PTRACE_ATTACH and PTRACE_DETACH.
c_ptrace = ctypes.CDLL("libc.so.6").ptrace
c_pid_t = ctypes.c_int32 # This assumes pid_t is int32_t
c_ptrace.argtypes = [ctypes.c_int, c_pid_t, ctypes.c_void_p, ctypes.c_void_p]
def ptrace(attach, pid):
op = ctypes.c_int(16 if attach else 17) #PTRACE_ATTACH or PTRACE_DETACH
c_pid = c_pid_t(pid)
null = ctypes.c_void_p()
err = c_ptrace(op, c_pid, null, null)
if err != 0: raise SysError, 'ptrace', err
## Parse a line in /proc/$pid/maps. Return the boundaries of the chunk
## the read permission character.
def maps_line_range(line):
m = re.match(r'([0-9A-Fa-f]+)-([0-9A-Fa-f]+) ([-r])', line)
return [int(m.group(1), 16), int(m.group(2), 16), m.group(3)]
## Dump the readable chunks of memory mapped by a process
def cat_proc_mem(pid):
## Apparently we need to ptrace(PTRACE_ATTACH, $pid) to read /proc/$pid/mem
ptrace(True, int(pid))
## Read the memory maps to see what address ranges are readable
maps_file = open("/proc/" + pid + "/maps", 'r')
ranges = map(maps_line_range, maps_file.readlines())
maps_file.close()
## Read the readable mapped ranges
mem_file = open("/proc/" + pid + "/mem", 'r', 0)
for r in ranges:
if r[2] == 'r':
mem_file.seek(r[0])
chunk = mem_file.read(r[1] - r[0])
print chunk,
mem_file.close()
## Cleanup
ptrace(False, int(pid))
if __name__ == "__main__":
for pid in sys.argv[1:]:
cat_proc_mem(pid)
Veja também mais informações sobre /proc/$pid/mem .
unswap () {
cat_proc_mem "$@" >/dev/null
}
Apenas para completar, o GDB pode despejar a imagem do processo. Eu não verifiquei se ele desativa, mas tem que --- não há outra maneira de ler toda a memória do processo:
gdb -p $mypid
seguido por
(gdb) gcore /tmp/myprocess-core
Saved corefile /tmp/myprocess-core
O swapon / swapoff irá limpar completamente o seu espaço de troca, mas você também pode liberá-lo através do sistema de arquivos / proc. Você quer o primeiro:
# To free pagecache
echo 1 > /proc/sys/vm/drop_caches
# To free dentries and inodes
echo 2 > /proc/sys/vm/drop_caches
# To free pagecache, dentries and inodes
echo 3 > /proc/sys/vm/drop_caches
via link