Logical vs Physical Memory Addresses: Full Comparison 2026

The following example demonstrates how C programs work exclusively with logical addresses, and how the same logical address value (the pointer) can exist in multiple processes simultaneously without conflict — because each process has its own independent logical address space:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int value = 42;
    int *ptr = &value;

    // ptr holds a LOGICAL address — not the actual RAM location
    // Two different processes can both have a pointer with this value
    // without conflict, because each lives in its own address space
    printf("Logical (virtual) address: %p\n", (void*)ptr);
    printf("Value at logical address:  %d\n", *ptr);

    // Dynamic allocation also returns logical addresses
    int *heap_val = (int*)malloc(sizeof(int));
    *heap_val = 100;
    printf("Heap logical address: %p\n", (void*)heap_val);
    printf("Value: %d\n", *heap_val);

    // The MMU silently translates every access above to
    // physical RAM addresses — invisible to this program
    free(heap_val);
    return 0;
}

// Example output:
// Logical (virtual) address: 0x7fff5fbff6ac
// Value at logical address:  42
// Heap logical address:      0x55a3c2f4a2b0
// Value: 100
// Note: physical RAM addresses for these locations are
// completely different and never visible to this program

This simulation demonstrates how the MMU splits a logical address into page number and offset, then uses a page table to derive the physical address — the core of how every memory access works in a paged operating system:

#include <stdio.h>
#include <stdint.h>

#define PAGE_SIZE       256     // 256 bytes per page (simplified)
#define NUM_PAGES       16      // Process has 16 logical pages
#define PHYSICAL_FRAMES 8       // Only 8 physical frames available

// Simplified page table: maps logical page number to physical frame number
int page_table[NUM_PAGES] = {
    3, 7, 1, 5, -1, 2, -1, 6,   // Pages 0-7 (-1 = not loaded in RAM)
    0, 4, -1, -1, -1, -1, -1, -1 // Pages 8-15
};

void translate_address(uint16_t logical_addr) {
    // Step 1: Extract page number and offset from logical address
    int page_number = logical_addr / PAGE_SIZE;  // Upper bits
    int page_offset = logical_addr % PAGE_SIZE;  // Lower bits

    printf("\n--- Address Translation ---\n");
    printf("Logical Address:  0x%04X (%d)\n", logical_addr, logical_addr);
    printf("Page Number:      %d\n", page_number);
    printf("Page Offset:      %d\n", page_offset);

    // Step 2: Look up physical frame in page table (MMU operation)
    if (page_number >= NUM_PAGES) {
        printf("ERROR: Segmentation fault — address out of bounds\n");
        return;
    }

    int frame_number = page_table[page_number];

    if (frame_number == -1) {
        printf("PAGE FAULT: Page %d not in physical memory — OS loads from disk\n",
               page_number);
        return;
    }

    // Step 3: Compute physical address
    // Physical address = (frame_number * PAGE_SIZE) + page_offset
    uint16_t physical_addr = (frame_number * PAGE_SIZE) + page_offset;

    printf("Physical Frame:   %d\n", frame_number);
    printf("Physical Address: 0x%04X (%d)\n", physical_addr, physical_addr);
}

int main() {
    // Test various logical addresses
    translate_address(100);   // Page 0, offset 100 -> Frame 3
    translate_address(300);   // Page 1, offset 44  -> Frame 7
    translate_address(1024);  // Page 4, offset 0   -> Page fault
    return 0;
}

// Output:
// --- Address Translation ---
// Logical Address:  0x0064 (100)
// Page Number:      0
// Page Offset:      100
// Physical Frame:   3
// Physical Address: 0x02C4 (868)
//
// --- Address Translation ---
// Logical Address:  0x012C (300)
// Page Number:      1
// Page Offset:      44
// Physical Frame:   7
// Physical Address: 0x07EC (2028)
//
// PAGE FAULT: Page 4 not in physical memory — OS loads from disk