UFPR Licenciatura em Computação

Atividades Práticas - Memória

Exemplos práticos com Linux, Shell Script e Python sobre memória em Sistemas Operacionais.

📌 Introdução

Este material aborda comandos e scripts que permitem visualizar, monitorar e gerenciar o uso de memória em sistemas operacionais Linux. Serão apresentados comandos básicos, scripts automatizados e explicações detalhadas para entendimento completo dos conceitos envolvidos.

A memória é um componente fundamental nos sistemas operacionais modernos. Sua gestão adequada afeta diretamente o desempenho das aplicações. Neste material, você aprenderá a monitorar e otimizar o uso de memória em sistemas Linux.

🐧 Comandos Linux (Memória)

Comandos essenciais para visualizar, monitorar e analisar o uso de memória em sistemas Linux.

free -h

Exibe uma visão geral do uso de memória (RAM e swap) em formato legível por humanos.

free -h

ps aux --sort=-%mem

Lista os processos ordenados pelo consumo de memória, do maior para o menor.

ps aux --sort=-%mem | head -n 6

cat /proc/meminfo

Fornece informações detalhadas sobre a memória, incluindo cache, buffers e swap.

cat /proc/meminfo

top -o %MEM

Exibe processos em tempo real, ordenados pelo uso de memória.

top -o %MEM

vmstat -s

Mostra estatísticas resumidas sobre memória, incluindo uso de swap e cache.

vmstat -s
Dica

O comando free -h é ideal para uma visão rápida da memória. Para identificar processos que consomem muita memória, use ps aux --sort=-%mem | head -n 6, que limita a saída aos 5 processos mais intensivos, facilitando a análise.

🐧 Comandos Extras Linux (Memória)

Comandos avançados para monitoramento e análise detalhada da memória em sistemas Linux.

top -o %MEM

Exibe processos em tempo real, ordenados pelo uso de memória, permitindo monitoramento dinâmico.

top -o %MEM

vmstat -s | grep -E "memory|swap"

Mostra estatísticas resumidas de memória e swap, filtrando apenas informações relevantes.

vmstat -s | grep -E "memory|swap"

sudo dmidecode -t memory

Exibe detalhes físicos da memória RAM instalada, como tamanho, tipo e velocidade (requer privilégios de root).

sudo dmidecode -t memory

lscpu

Mostra informações sobre o processador, incluindo tamanhos de cache L1, L2 e L3.

lscpu

smem

Exibe o consumo de memória por processo, incluindo memória proporcional e total (requer instalação).

sudo apt install smem
smem -t

sar -r 1 3

Monitora o uso de memória a cada segundo, repetindo três vezes (parte do pacote sysstat).

sar -r 1 3

numastat

Mostra estatísticas de alocação de memória em sistemas NUMA, útil para servidores multi-nó (*Máquinas NUMA).

numastat

pmap -x <PID>

Exibe um mapa detalhado da memória usada por um processo específico, incluindo RSS e dirty pages.

pmap -x 1234

dmesg | grep -i memory

Filtra mensagens do kernel relacionadas à memória, útil para diagnosticar problemas.

dmesg | grep -i memory

perf stat -a -- sleep 5

Coleta estatísticas de desempenho do sistema, incluindo eventos de memória, por 5 segundos.

perf stat -a -- sleep 5

sudo ps_mem

Exibe o consumo de memória por processo, com resumo detalhado (requer instalação).

sudo apt install ps_mem
sudo ps_mem

watch -n 2 free -h

Monitora o uso de memória em tempo real, atualizando a cada 2 segundos.

watch -n 2 free -h
Dica

O comando sudo dmidecode -t memory é excelente para verificar especificações de hardware, mas requer privilégios de root. Para monitoramento contínuo, use watch -n 2 free -h para acompanhar o uso de memória em tempo real.

🐚 Scripts Shell - Monitoramento de Memória

Scripts Bash para monitoramento contínuo e geração de relatórios sobre o uso de memória no Linux.

Script 1: Monitoramento Contínuo de Memória

Monitora a memória RAM e swap em tempo real, exibindo os processos que mais consomem memória.

#!/bin/bash
# Verifica se o comando free está disponível
if ! command -v free &> /dev/null; then
  echo "Erro: Comando 'free' não encontrado. Instale o pacote procps."
  exit 1
fi

while true; do
  clear
  echo "$(date '+%Y-%m-%d %H:%M:%S') - Monitoramento de Memória"
  echo "------------------------------------"
  # Memória RAM
  free -h | grep Mem | awk '{printf "RAM: %s usada / %s total (%.1f%%)\n", $3, $2, $3/$2*100}'
  # Memória Swap
  free -h | grep Swap | awk '{printf "Swap: %s usada / %s total (%.1f%%)\n", $3, $2, $3/$2*100}'
  echo "------------------------------------"
  echo "Top 5 processos por uso de memória:"
  ps aux --sort=-%mem | head -n 6 | awk '{printf "%-8s %-20s %6.2f%%\n", $2, $11, $4}'
  sleep 3
done

Script 2: Relatório de Memória em Arquivo

Gera um relatório detalhado do uso de memória e processos em um arquivo de log.

#!/bin/bash
LOGFILE="memory_report_$(date '+%Y%m%d_%H%M%S').log"

# Verifica se o comando free está disponível
if ! command -v free &> /dev/null; then
  echo "Erro: Comando 'free' não encontrado. Instale o pacote procps."
  exit 1
fi

echo "Relatório de Memória - $(date '+%Y-%m-%d %H:%M:%S')" >> "$LOGFILE"
echo "=====================================" >> "$LOGFILE"
free -h >> "$LOGFILE"
echo "" >> "$LOGFILE"
echo "Top 5 processos por uso de memória:" >> "$LOGFILE"
ps aux --sort=-%mem | head -n 6 | awk '{printf "%-8s %-20s %6.2f%%\n", $2, $11, $4}' >> "$LOGFILE"
echo "=====================================" >> "$LOGFILE"
echo "Relatório salvo em: $LOGFILE"
Avançado

Para executar o script de monitoramento contínuo, salve-o como monitor_mem.sh, dê permissão com chmod +x monitor_mem.sh, e execute com ./monitor_mem.sh. Para rodar em background, use nohup ./monitor_mem.sh > log.txt &. Para parar, encontre o PID com ps aux | grep monitor_mem e finalize com kill . O script de relatório gera logs para análise posterior.

🐍 Scripts Python - Monitoramento de Memória

Scripts Python para monitoramento em tempo real e geração de relatórios detalhados sobre o uso de memória no Linux.

Script 1: Monitoramento Contínuo de Memória

Exibe o uso de RAM, swap e os 5 processos mais consumidores de memória, com barras de progresso no terminal.

import psutil
import time
import os
import sys
from datetime import datetime

def progress_bar(percent, width=50):
    filled = int(width * percent / 100)
    bar = '█' * filled + '░' * (width - filled)
    return f"[{bar}] {percent:.1f}%"

def clear_screen():
    os.system('cls' if os.name == 'nt' else 'clear')

def main(interval=5):
    if not hasattr(psutil, 'virtual_memory'):
        print("Erro: Biblioteca psutil não está instalada. Instale com 'pip install psutil'.")
        sys.exit(1)
    
    try:
        while True:
            clear_screen()
            mem = psutil.virtual_memory()
            swap = psutil.swap_memory()
            now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            
            print(f"\033[1;36m=== Sistema de Monitoramento de Memória ===\033[0m")
            print(f"\033[1;33mHorário: {now}\033[0m")
            print("\n\033[1;32m=== Memória RAM ===\033[0m")
            print(f"Total: {mem.total / (1024**3):.2f} GB")
            print(f"Em uso: {mem.used / (1024**3):.2f} GB")
            print(f"Disponível: {mem.available / (1024**3):.2f} GB")
            print(f"Percentual: {progress_bar(mem.percent)}")
            
            print("\n\033[1;32m=== Memória SWAP ===\033[0m")
            print(f"Total: {swap.total / (1024**3):.2f} GB")
            print(f"Em uso: {swap.used / (1024**3):.2f} GB")
            print(f"Livre: {swap.free / (1024**3):.2f} GB")
            print(f"Percentual: {progress_bar(swap.percent)}")
            
            print("\n\033[1;32m=== Top 5 Processos (Uso de Memória) ===\033[0m")
            processes = []
            try:
                for proc in psutil.process_iter(['pid', 'name', 'memory_percent']):
                    try:
                        processes.append(proc.info)
                    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                        pass
                processes = sorted(processes, key=lambda x: x['memory_percent'], reverse=True)[:5]
                
                print(f"{'PID':<8} {'Nome':<25} {'Memória %':<10}")
                print("-" * 45)
                for proc in processes:
                    print(f"{proc['pid']:<8} {proc['name'][:25]:<25} {proc['memory_percent']:.2f}%")
            except Exception as e:
                print(f"Erro ao listar processos: {e}")
            
            time.sleep(interval)
    except KeyboardInterrupt:
        print("\n\033[1;31mMonitoramento finalizado pelo usuário.\033[0m")
    except Exception as e:
        print(f"\n\033[1;31mErro inesperado: {e}\033[0m")

if __name__ == "__main__":
    main(interval=5)

Script 2: Relatório de Memória em CSV

Gera um relatório em formato CSV com o uso de memória e processos, ideal para análise posterior.

import psutil
import csv
import sys
from datetime import datetime

def generate_memory_report():
    if not hasattr(psutil, 'virtual_memory'):
        print("Erro: Biblioteca psutil não está instalada. Instale com 'pip install psutil'.")
        sys.exit(1)
    
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"memory_report_{timestamp}.csv"
    
    try:
        mem = psutil.virtual_memory()
        swap = psutil.swap_memory()
        processes = []
        for proc in psutil.process_iter(['pid', 'name', 'memory_percent']):
            try:
                processes.append(proc.info)
            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                pass
        processes = sorted(processes, key=lambda x: x['memory_percent'], reverse=True)[:5]
        
        with open(filename, 'w', newline='') as csvfile:
            writer = csv.writer(csvfile)
            writer.writerow(["Relatório de Memória", datetime.now().strftime("%Y-%m-%d %H:%M:%S")])
            writer.writerow([])
            writer.writerow(["Memória RAM"])
            writer.writerow(["Total (GB)", "Em uso (GB)", "Disponível (GB)", "Percentual (%)"])
            writer.writerow([
                f"{mem.total / (1024**3):.2f}",
                f"{mem.used / (1024**3):.2f}",
                f"{mem.available / (1024**3):.2f}",
                f"{mem.percent:.1f}"
            ])
            writer.writerow([])
            writer.writerow(["Memória SWAP"])
            writer.writerow(["Total (GB)", "Em uso (GB)", "Livre (GB)", "Percentual (%)"])
            writer.writerow([
                f"{swap.total / (1024**3):.2f}",
                f"{swap.used / (1024**3):.2f}",
                f"{swap.free / (1024**3):.2f}",
                f"{swap.percent:.1f}"
            ])
            writer.writerow([])
            writer.writerow(["Top 5 Processos"])
            writer.writerow(["PID", "Nome", "Memória (%)"])
            for proc in processes:
                writer.writerow([proc['pid'], proc['name'], f"{proc['memory_percent']:.2f}"])
        
        print(f"Relatório salvo em: {filename}")
    except Exception as e:
        print(f"Erro ao gerar relatório: {e}")

if __name__ == "__main__":
    generate_memory_report()
Requisito

Para executar esses scripts, instale a biblioteca pip install psutil. Salve o script de monitoramento como monitor_mem.py e execute com python3 monitor_mem.py. O script de relatório gera um arquivo CSV (memory_report_*.csv) para análise em ferramentas como Excel. Compatível com Linux, Windows e macOS.

📂 Atividades sobre Cache

Comandos e scripts para entender, monitorar e gerenciar o cache de memória no Linux.

Comando: Sincronizar e Limpar Cache

Sincroniza dados pendentes e limpa cache, dentries e inodes (requer privilégios de root). Use com cautela.

sudo sync; echo 3 > /proc/sys/vm/drop_caches

Comando: Verificar Uso de Cache

Exibe a quantidade de memória usada como cache no momento.

free -h | grep "Mem:" | awk '{print "Cache: " $6}'

Comando: Analisar Cache do Kernel

Mostra detalhes sobre o uso de slab cache (memória do kernel), ordenado por tamanho.

slabtop -s c

Script: Monitoramento Contínuo de Cache

Monitora cache e buffers em tempo real, atualizando a cada 5 segundos.

#!/bin/bash
# Verifica dependência do comando free
if ! command -v free &> /dev/null; then
  echo "Erro: Comando 'free' não encontrado. Instale o pacote procps."
  exit 1
fi

while true; do
  cache=$(free -h | grep "Mem:" | awk '{print $6}')
  buffers=$(free -h | grep "Mem:" | awk '{print $5}')
  echo "$(date '+%Y-%m-%d %H:%M:%S') - Cache: $cache | Buffers: $buffers"
  sleep 5
done
Informação

O cache de memória melhora o desempenho ao armazenar dados frequentemente acessados. Limpar o cache com sudo sync; echo 3 > /proc/sys/vm/drop_caches é útil para diagnósticos, mas pode reduzir temporariamente a eficiência. Use slabtop -s c para análises detalhadas.

🛠️ Programas Linux para Memória

Ferramentas gráficas e de terminal para monitoramento detalhado e interativo do uso de memória no Linux.

htop

Monitor interativo de processos com interface colorida e suporte a ordenação por memória.

sudo apt install htop
htop

top

Ferramenta nativa para monitoramento em tempo real, com opção de ordenar por uso de memória.

top -o %MEM

vmstat

Exibe estatísticas em tempo real de memória, CPU e I/O, atualizando a cada segundo.

vmstat 1 5

glances

Monitor avançado com interface rica, exibindo memória, CPU, disco e rede em tempo real.

sudo apt install glances
glances

nmon

Ferramenta interativa para monitoramento detalhado, com telas específicas para memória.

sudo apt install nmon
nmon

gnome-system-monitor

Interface gráfica para monitoramento de recursos, ideal para usuários de ambientes GNOME.

gnome-system-monitor
Recomendação

O htop é ideal para monitoramento interativo, permitindo ordenar processos por memória (tecla F6 > %MEM). Para uma visão mais completa, experimente glances, que exibe memória, CPU, disco e rede em uma única interface.

❓ Quiz - Memória

📚 Referências Úteis

Links úteis para aprofundamento no assunto: