The 32-bit addressing space theoretically limits memory access to 4GB (2^32 bytes). This constraint stems from the CPU's ability to reference memory locations using 32-bit pointers. However, several techniques allow 32-bit systems to circumvent this limitation in practical implementations.

Intel introduced PAE in the Pentium Pro processor, extending physical address space to 36 bits (64GB) while maintaining 32-bit virtual addresses. The operating system manages this through page table hierarchies:

// Example of PAE-aware memory allocation in C
#include <windows.h>

void* AllocateLargeMemory(size_t size) {
    MEMORYSTATUSEX status = { sizeof(status) };
    GlobalMemoryStatusEx(&status);
    
    if (status.ullTotalPhys > 4 * 1024 * 1024 * 1024ULL) {
        return VirtualAlloc(NULL, size, MEM_RESERVE | MEM_PHYSICAL, PAGE_READWRITE);
    }
    return NULL;
}

Commonly used in database servers like SQL Server, AWE allows mapping portions of physical memory into a 32-bit process's address space:

-- SQL Server AWE configuration
sp_configure 'show advanced options', 1;
RECONFIGURE;
sp_configure 'awe enabled', 1;
RECONFIGURE;
GO

Similar to EMS memory in 8086 systems, modern implementations use memory windowing:

• Memory is divided into banks
• The OS manages a mapping window
• Applications request bank switches when accessing non-windowed memory

When working with large memory on 32-bit systems:

The fundamental limitation stems from 32-bit architecture's addressing capability. With 2^32 possible addresses, the theoretical maximum is 4GB (4,294,967,296 bytes). However, modern 32-bit systems employ several techniques to surpass this limit:

Intel introduced PAE in Pentium Pro processors, extending physical address space to 36 bits (64GB). The OS manages this through page table hierarchy:

// Example of PAE-enabled page table structure
typedef struct {
    uint32_t present : 1;
    uint32_t rw : 1;
    uint32_t user : 1;
    uint32_t pwt : 1;
    uint32_t pcd : 1;
    uint32_t accessed : 1;
    uint32_t dirty : 1;
    uint32_t page_size : 1;
    uint32_t global : 1;
    uint32_t available : 3;
    uint64_t physical_address : 36; // Extended addressing
} pae_page_entry;

Microsoft's API for memory-intensive applications like SQL Server:

// Windows AWE API usage example
#include <windows.h>

void UseAWE() {
    PVOID lpMemReserved = VirtualAlloc(NULL, 256MB, MEM_RESERVE | MEM_PHYSICAL, PAGE_READWRITE);
    ULONG_PTR aPFNs[256];
    AllocateUserPhysicalPages(GetCurrentProcess(), &aPFNs[0], 256);
    MapUserPhysicalPages(lpMemReserved, 256, &aPFNs[0]);
    // Memory window now accessible beyond 4GB limit
}

Red Hat Enterprise Linux's 32-bit PAE kernel splits the address space:

• 0-3GB: User space
• 3-4GB: Kernel space with PAE mapping

While these techniques enable >4GB physical RAM, per-process limits still apply: