♡ Memoria Virtual

O QUE É UMA MEMORIA VIRTUAL Memória virtual é uma técnica do sistema operacional que usa parte do armazenamento (HD/SSD) como se fosse memória RAM extra. Ela permite rodar programas maiores do que a RAM disponível, movendo dados menos usados para o disco. É mais lenta que a RAM, mas impede que o computador trave quando a memória acaba.

Simulação de uma memoria virtual

CODIGO EM C++

Um pequeno cache que armazena traduções recentes de Página → Frame, acelerando o acesso.

#include <iostream>
#include <iomanip> //para a formatação
#include <sstream> //sTRINGS fORMADAS
#include <string> //para strings
#include <vector> //vetores dinamicos
#include <ctime> //teMemoriaPrincipalos como time NULL
#include <algorithm>
#include <cstdlib>
#include <set> // Para garantir unicidade dos frames, é uma coleção de estruturas de dados que armazena
// elementos distintos e ordenados. Ela é útil para operações que exigem busca rápida, inserção e remoção de elementos únicos, 
//com coMemoriaPrincipallexidade de teMemoriaPrincipalo de O(log n)

using namespace std;

#define TamanhoCache 32
#define TamanhoTLB 8
#define TamanhoVirtua 32
#define TamanhoPrincipal 256
#define TamanhoSegundaria 4096
//Molde para ocupar varios dados de forma aonde so ela consegue acessar praga
class GerenciadorMemoria {
private:
    string MemoriaSegundaria[TamanhoSegundaria - TamanhoPrincipal - TamanhoCache];
    string MemoriaPrincipal[TamanhoPrincipal - TamanhoCache];
    string Cache[TamanhoCache];
    string Virtual[TamanhoVirtua];
    string TLB[TamanhoTLB];
    vector<int> tabelaPaginas; // Mapeia página virtual para frame físico
    vector<bool> framesLivres; // Rastreia frames livres (28 frames)
    struct Segmento {
        int base;
        int tamanho;
    };
    Segmento tabelaSegmentos[4];
    bool modoPaginacao; // true para paginação, false para segmentação

public: //para qualquer parte do codigo
    GerenciadorMemoria() { // n tem tipo de retorno e chama quando cria o obj
        inicializarMemorias(); //ele automaticamente executa
        inicializarTabelaPaginas(); //para por pagina e frames
        inicializarTabelaSegmentos(); 
        modoPaginacao = true; // Padrão: paginação caso queira mudar 
    }
 //apenas para inicializar memorias
    void inicializarMemorias() {
        // Inicializa Cache para carregar valores unicos pra testar acesso
        for (int i = 0; i < TamanhoCache; i++) {
            stringstream ss; //buffer para strings formadas
            ss << setw(3) << setfill('0') << uppercase << hex << i; //transforma i em hexadecimal
            Cache[i] = "0cx" + ss.str(); //prefixo para indicar que esta na cache
        }
        // Inicializa MemoriaPrincipal , começa com tamanho da cache pq a principal vem logo depois da cache
        for (int i = TamanhoCache; i < TamanhoPrincipal; i++) { //i sendo endereço real e termina no da principal
            stringstream ss; // formata o texxto
            ss << setw(3) << setfill('0') << uppercase << hex << i;
            MemoriaPrincipal[i - TamanhoCache] = "0px" + ss.str(); //padrao para a principal
        }
        // Inicializa MemoriaSegundaria
        for (int i = TamanhoPrincipal; i < TamanhoSegundaria; i++) { //começa na principal e vai ate o tam da segunaria
            stringstream ss; // formata texto de novo transformando numeros em strings
            ss << setw(3) << setfill('0') << uppercase << hex << i;
            MemoriaSegundaria[i - TamanhoPrincipal] = "0sx" + ss.str();
        }
        // Inicializa MV com valores aleatórios
        srand(time(NULL)); //gera numeros aleatorios  usando o horario atual como semente para sempre serem aleatorios
        for (int i = 0; i < TamanhoVirtua; i++) {
            stringstream ss;
            ss << setw(3) << setfill('0') << uppercase << hex << rand() % TamanhoSegundaria; //n aleatoorio entre 0 e segundaria
            Virtual[i] = "0vx" + ss.str(); //uppercase foi para trnasformar as letras em maiusculas
        }
        // Inicializa TLB vazia
        fill_n(TLB, TamanhoTLB, ""); //usa fill n para preencher o array com um valor cada posição começa vazia
    }

void inicializarTabelaPaginas() {
        tabelaPaginas.resize(4, -1); // 4 páginas tam 4 e ainda n mapeada
        framesLivres.resize(28, true); // 28 frames (MemoriaPrincipal: 224 endereços / 8 = 28 frames)
        // Mapeia todas as páginas a frames aleatórios únicos para evitar -1 e sequencialidade
        set<int> framesUsados; //verifica se um valor ja foi utilizados p garatir que n repita frame
        for (int p = 0; p < 4; p++) { // mapeia em 4 paginas
            int frame;
            do {
                frame = rand() % 28; // Escolhe frame aleatório entre 0-27
            } while (framesUsados.count(frame)); // Garante unicidade
            framesUsados.insert(frame); // sorteado vira o ocupado
            tabelaPaginas[p] = frame; // p 0 e frame 15 ex
            framesLivres[frame] = false; // Marca frame como ocupado
        }
        // Frames restantes ficam livres para page faults futuros
    }

void inicializarTabelaSegmentos() {
        tabelaSegmentos[0] = {0, 8};   // Segmento 0: base 0, tamanho 8
        tabelaSegmentos[1] = {8, 8};   // Segmento 1: base 8, tamanho 8
        tabelaSegmentos[2] = {16, 8};  // Segmento 2: base 16, tamanho 8
        tabelaSegmentos[3] = {24, 8};  // Segmento 3: base 24, tamanho 8
    }

void visualizarMemoriaFisica() { //tudo que existe na memoria fisica
        cout << "!!! MEMORIA FISICA !!!" << endl;
        cout << "Cache (0-31):" << endl; // mostra a cache de 32 tipo 0cx000
        for (int i = 0; i < TamanhoCache; i++) { 
            cout << i << ": " << Cache[i] << endl;
        }
        cout << "Memoria Principal (32-255):" << endl;
        for (int i = 0; i < TamanhoPrincipal - TamanhoCache; i++) {
            cout << (i + TamanhoCache) << ": " << MemoriaPrincipal[i] << endl;
        }
        cout << "Memoria Secundaria (256-4095) - Mostrando primeiros 100 para brevidade:" << endl;
        for (int i = 0; i < 100; i++) {
            cout << (i + TamanhoPrincipal) << ": " << MemoriaSegundaria[i] << endl;
        }
    }

void visualizarTamanhoVirtua() {
        cout << "=== MEMORIA VIRTUAL ===" << endl;
        for (int pagina = 0; pagina < 4; pagina++) {
            cout << "<< PAGINA " << (pagina + 1) << " >>" << endl;
            for (int offset = 0; offset < 8; offset++) {
                int indice = pagina * 8 + offset;
                cout << offset << ": " << Virtual[indice] << endl;
            }
            cout << endl;
        }
    }

void demonstrarPaginas() {
        cout << "!! DEMONSTRACAO DE PAGINACAO !!" << endl;
        cout << "Memoria Virtual dividida em 4 paginas de 8 enderecos cada." << endl;
        cout << "Tabela de Paginas (Pagina Virtual -> Frame Fisico):" << endl;
        for (int p = 0; p < 4; p++) {
            cout << "Pagina " << p << " -> Frame " << tabelaPaginas[p] << endl;
        }
        cout << "ExeMemoriaPrincipallo: Endereco Virtual 0x010 (Pagina 1, Offset 0) -> ";
        if (tabelaPaginas[1] != -1) { //frame em pag xe for menos 1 n esta carregaada
            int fisico = tabelaPaginas[1] * 8 + 0;
            cout << "Endereco Fisico 0x" << hex << fisico << endl;
        } else {
            cout << "Nao mapeado (page fault)." << endl;
        }
    }

void demonstrarSegmentos() {
        cout << "=== DEMONSTRACAO DE SEGMENTACAO ===" << endl;
        cout << "Memoria Virtual dividida em 4 segmentos." << endl;
        cout << "Tabela de Segmentos:" << endl;
        for (int s = 0; s < 4; s++) {
            cout << "Segmento " << s << ": Base " << tabelaSegmentos[s].base << ", Tamanho " << tabelaSegmentos[s].tamanho << endl;
        }
        cout << "ExeMemoriaPrincipallo: Endereco Virtual 0x010 (Segmento 1, Offset 0) -> ";
        int segmento = 1, offset = 0;
        if (offset < tabelaSegmentos[segmento].tamanho) {
            int fisico = tabelaSegmentos[segmento].base + offset;
            cout << "Endereco Fisico 0x" << hex << fisico << endl;
        } else {
            cout << "Erro: Offset fora do segmento." << endl;
        }
    }

string traduzirEndereco(int enderecoVirtual) {
        string resultado = "";
        if (modoPaginacao) {
            // Modo Paginação: Página + Offset
            int pagina = enderecoVirtual / 8;
            int offset = enderecoVirtual % 8;
            if (pagina >= 0 && pagina < 4) {
                // Verificar TLB
                for (int i = 0; i < TamanhoTLB; i++) {
                    if (TLB[i] == "P" + to_string(pagina)) {
                        int frame = tabelaPaginas[pagina];
                        int fisico = frame * 8 + offset;
                        resultado = "TLB Hit: Pagina " + to_string(pagina) + " -> Frame " + to_string(frame) + " -> Fisico 0x" + to_string(fisico);
                        return resultado;
                    }
                }
                // Não em TLB, buscar em tabela
                if (tabelaPaginas[pagina] != -1) {
                    int frame = tabelaPaginas[pagina];
                    int fisico = frame * 8 + offset;
                    // Adicionar à TLB
                    int indiceTLB = rand() % TamanhoTLB;
                    TLB[indiceTLB] = "P" + to_string(pagina);
                    resultado = "Traduzido: Pagina " + to_string(pagina) + " -> Frame " + to_string(frame) + " -> Fisico 0x" + to_string(fisico);
                } else {
                    // Page Fault: Tentar carregar página
                    int frameLivre = -1;
                    for (int f = 0; f < 28; f++) {
                        if (framesLivres[f]) {
                            frameLivre = f;
                            break;
                        }
                    }
                    if (frameLivre != -1) {
                        // Simular carregamento da MemoriaSegundaria para MemoriaPrincipal
                        tabelaPaginas[pagina] = frameLivre;
                        framesLivres[frameLivre] = false;
                        int fisico = frameLivre * 8 + offset;
                        // Adicionar à TLB
                        int indiceTLB = rand() % TamanhoTLB;
                        TLB[indiceTLB] = "P" + to_string(pagina);
                        resultado = "Page Fault Tratado: Pagina " + to_string(pagina) + " carregada para Frame " + to_string(frameLivre) + " -> Fisico 0x" + to_string(fisico);
                    } else {
                        resultado = "Page Fault: Pagina " + to_string(pagina) + " nao mapeada e sem frames livres.";
                    }
                }
            } else {
                resultado = "Erro: Pagina invalida.";
            }
        } else {
            // Modo Segmentação: Segmento + Offset
            int segmento = enderecoVirtual / 8;
            int offset = enderecoVirtual % 8;
            if (segmento >= 0 && segmento < 4 && offset < tabelaSegmentos[segmento].tamanho) {
                int fisico = tabelaSegmentos[segmento].base + offset;
                resultado = "Traduzido: Segmento " + to_string(segmento) + " -> Fisico 0x" + to_string(fisico);
            } else {
                resultado = "Erro: Segmento ou offset invalido.";
            }
        }
        return resultado;
    }

void verificarEndereco() { // verificacao de endereco na fivirtua
        int endereco;
        cout << "Digite o endereco virtual (0-31): ";
        cin >> endereco;
        if (endereco >= 0 && endereco < TamanhoVirtua) {
            cout << traduzirEndereco(endereco) << endl;
        } else {
            cout << "Endereco invalido." << endl;
        }
    }

void alterarModo() {
        cout << "Modo atual: " << (modoPaginacao ? "Paginacao" : "Segmentacao") << endl;
        cout << "Alterar para " << (modoPaginacao ? "Segmentacao" : "Paginacao") << "? (S/N): ";
        char resp;
        cin >> resp;
        if (resp == 'S' || resp == 's') {
            modoPaginacao = !modoPaginacao;
            cout << "Modo alterado." << endl;
        }
    }

void executar() {
        int opcao;
        do {
            cout << "\n=== MENU PRINCIPAL ===" << endl;
            cout << "Modo atual: " << (modoPaginacao ? "Paginacao" : "Segmentacao") << endl;
            cout << "1 - Visualizar Memoria Fisica" << endl;
            cout << "2 - Visualizar Memoria Virtual" << endl;
            cout << "3 - Demonstrar Paginas (Paginacao)" << endl;
            cout << "4 - Demonstrar Segmentos (Segmentacao)" << endl;
            cout << "5 - Traduzir Endereco Virtual" << endl;
            cout << "6 - Alterar Modo (Paginacao/Segmentacao)" << endl;
            cout << "0 - Sair" << endl;
            cout << "Escolha: ";
            cin >> opcao;

switch (opcao) {
                case 1: visualizarMemoriaFisica(); break;
                case 2: visualizarTamanhoVirtua(); break;
                case 3: demonstrarPaginas(); break;
                case 4: demonstrarSegmentos(); break;
                case 5: verificarEndereco(); break;
                case 6: alterarModo(); break;
                case 0: cout << "Saindo..." << endl; break;
                default: cout << "Opcao invalida." << endl;
            }
        } while (opcao != 0);
    }
};

int main() {
    GerenciadorMemoria gm;
    gm.executar();
    return 0;
}

}

♡ DESCRIÇÃO // Instruções

1. Existem dois modos a se selecionar sendo Paginação e Segmentação
2. Paginação : O programa Pega a página virtual Descobre qual frame ela está usando Faz a conta frame * 8 + offset Se tabelaPaginas[p] == -1, ocorre page fault Usa a TLB (quando implementada) Usa frames livres
No programa : if (tabelaPaginas[1] != -1) { int fisico = tabelaPaginas[1] * 8 + 0; cout << "Endereco Fisico 0x" << hex << fisico << endl; } else { cout << "Nao mapeado (page fault)." << endl; }
4. Segmentação : Verifica se o offset cabe dentro do segmento Soma base + offset NÃO existe page fault (segmentação usa realocação dinâmica) NÃO existe TLB NÃO existe frame Não divide em páginas, divide em segmentos
NO CODIGO : int segmento = 1, offset = 0; if (offset < tabelaSegmentos[segmento].tamanho) { int fisico = tabelaSegmentos[segmento].base + offset; cout << "Endereco Fisico 0x" << hex << fisico << endl; } else { cout << "Erro: Offset fora do segmento." << endl; }

Trabalho de MV
de Arquitetura de Computadores
UNICENTRO - PARANA

♡ LINKS OUT ♡

this scrolls & stops on hover! place image codes here!

Layout by Ren