UFPR Setor Palotina
Curso de Licenciatura em Computação

1. Comando free

1. Execute o comando free -h. O que cada coluna da saída representa?

2. Compare os valores de "used" e "available". Por que eles diferem?

2. Comando top

1. Execute top e observe a seção de memória. Qual é o processo que mais consome memória?

2. Pressione f, selecione "VIRT" e ordene por essa coluna. O que "VIRT" significa?

3. Comando vmstat

1. Execute vmstat 1 5. O que as colunas "si" e "so" indicam?

2. O que significa se "si" e "so" têm valores altos?

4. Alocação de Memória em C

1. Escreva um programa em C que aloque 100 MB de memória usando malloc e inicialize com zeros.

2. Compile e execute o programa enquanto observa o uso de memória com top. O que você observa?

#include 
#include 
#include 

int main() {
    size_t size = 100 * 1024 * 1024; // 100 MB
    char *mem = (char *)malloc(size);
    if (mem == NULL) {
        printf("Erro ao alocar memória!\n");
        return 1;
    }
    memset(mem, 0, size);
    printf("Memória alocada. Pressione Enter para liberar.\n");
    getchar();
    free(mem);
    return 0;
}
            

5. Comando swapon e swapoff

1. Execute swapon --show. Qual é o tamanho da área de swap no seu sistema?

2. Crie um arquivo de swap de 512 MB com dd if=/dev/zero of=/swapfile bs=1M count=512, configure-o com mkswap /swapfile e ative-o com swapon /swapfile. Verifique o resultado.

6. Verificação de Limites de Memória

1. Execute ulimit -v. O que esse comando retorna?

2. Reduza o limite para 100 MB com ulimit -v 102400 e tente executar o programa da Atividade 4. O que acontece?

7. Paginação em C

1. Escreva um programa em C que acesse um array grande (ex.: 256 MB) de forma sequencial e meça o tempo de execução.

2. Compile e execute com time ./programa. Por que o tempo pode variar?

#include 
#include 
#include 

int main() {
    size_t size = 256 * 1024 * 1024; // 256 MB
    char *array = (char *)malloc(size);
    if (array == NULL) {
        printf("Erro ao alocar memória!\n");
        return 1;
    }
    clock_t start = clock();
    for (size_t i = 0; i < size; i += 4096) { // Acesso por página
        array[i] = 1;
    }
    clock_t end = clock();
    printf("Tempo: %.3f segundos\n", (double)(end - start) / CLOCKS_PER_SEC);
    free(array);
    return 0;
}
            

8. Simulação de Fragmentação

1. Escreva um programa em C que aloque vários blocos de tamanhos diferentes e libere alguns, simulando fragmentação.

2. Execute e observe o uso de memória com free -h antes e depois.

#include 
#include 

int main() {
    char *blk1 = malloc(10 * 1024 * 1024); // 10 MB
    char *blk2 = malloc(20 * 1024 * 1024); // 20 MB
    char *blk3 = malloc(15 * 1024 * 1024); // 15 MB
    printf("Blocos alocados. Pressione Enter para liberar blk2.\n");
    getchar();
    free(blk2);
    printf("Blk2 liberado. Pressione Enter para encerrar.\n");
    getchar();
    free(blk1);
    free(blk3);
    return 0;
}
            

9. Cálculo Manual de Paginação

1. Considere um sistema com páginas de 4 KB (4096 bytes). Um processo tem um endereço lógico de 15000 (decimal). Calcule manualmente o número da página e o deslocamento (offset).

2. Se o tamanho do espaço de endereço lógico é 64 KB, quantas páginas o processo pode ter?

10. Cálculo Manual de Segmentação

1. Um sistema usa segmentação com a tabela de segmentos: Segmento 0 (base: 1000, limite: 4000), Segmento 1 (base: 6000, limite: 2000). Para um endereço lógico , calcule o endereço físico.

2. O que acontece se o deslocamento for 2500 no Segmento 1?

11. Swap e Page Faults

1. Execute cat /proc/vmstat | grep pgfault. O que esse valor representa?

2. Modifique o programa da Atividade 7 para acessar o array de forma aleatória (use rand()) e compare o número de page faults antes e depois com /proc/vmstat.

#include 
#include 
#include 

int main() {
    size_t size = 256 * 1024 * 1024; // 256 MB
    char *array = (char *)malloc(size);
    if (array == NULL) {
        printf("Erro ao alocar memória!\n");
        return 1;
    }
    srand(time(NULL));
    clock_t start = clock();
    for (size_t i = 0; i < size / 4096; i++) {
        size_t idx = rand() % size;
        array[idx] = 1;
    }
    clock_t end = clock();
    printf("Tempo: %.3f segundos\n", (double)(end - start) / CLOCKS_PER_SEC);
    free(array);
    return 0;
}