Limited Frames - Frame Allocation Problem | OneNoughtOne

0/236

Operating SystemsFrame Allocation & Thrashing

Frame Allocation Problem

LevelIntermediate

Duration60 mins

TopicFrame Allocation & Thrashing

1 / 5

Limited Frames

The Fundamental Constraint

At the heart of every memory management challenge lies a simple, immutable truth: physical memory is finite, but the demand for it is virtually unlimited. Every process believes it deserves as much memory as it needs, yet the system has only so many physical frames to distribute.

This scarcity creates the frame allocation problem—one of the most consequential decisions an operating system must make. Give a process too few frames, and it thrashes, spending more time waiting for pages than doing useful work. Give it too many, and other processes starve, or the system cannot support as many concurrent processes as it should.

The elegance—and difficulty—of frame allocation lies in finding the balance point where every process has enough memory to run efficiently, while the system maximizes overall throughput and fairness.

What You Will Master

By the end of this page, you will deeply understand why physical memory scarcity is the driving force behind frame allocation policies, how to calculate available frames, and why this constraint shapes nearly every design decision in virtual memory systems.

The Nature of Physical Memory Scarcity

To understand why frame allocation is challenging, we must first appreciate the fundamental asymmetry between virtual and physical memory.

Virtual memory illusion:

Virtual memory creates a powerful abstraction. Each process believes it has access to a vast, contiguous address space—potentially spanning terabytes on 64-bit systems. From the process's perspective, memory is abundant and private. It can allocate, access, and manipulate addresses without concern for other processes or the physical hardware.

Physical memory reality:

Beneath this illusion, physical memory (RAM) is a fixed resource. A system with 16 GB of RAM has exactly 16 GB—no more, no less. If pages are 4 KB, that translates to approximately 4 million frames. This sounds like a lot, but consider:

The operating system kernel requires a significant portion (often 1-4 GB or more)
Device drivers and I/O buffers consume frames
Each running process needs frames for code, data, heap, and stack
File system caches and buffers require frames
Memory-mapped files and shared libraries occupy frames

Typical Memory Consumers in a 16 GB System
Consumer	Typical Usage	Frames (4 KB pages)	Notes
Kernel + Drivers	1-2 GB	256K-512K	Non-pageable, always resident
System Caches	2-4 GB	512K-1M	Page cache, buffer cache, slab
Desktop Environment	1-2 GB	256K-512K	Window manager, compositor
Browser (10 tabs)	2-4 GB	512K-1M	Modern browsers are memory-hungry
IDE / Editor	1-2 GB	256K-512K	Indexing, language servers
Background Services	1-2 GB	256K-512K	Databases, daemons, agents
Total Pressure	8-16 GB	2M-4M	Often exceeds physical RAM

The overcommitment reality:

Modern systems routinely overcommit memory—the total virtual memory allocated to all processes exceeds physical RAM. This is intentional and beneficial:

Sparse usage: Most processes allocate more memory than they actively use at any instant
Demand paging: Pages are only loaded when accessed, not when allocated
Sharing: Code pages, libraries, and files can be shared across processes
Copy-on-write: Forked processes initially share memory with parents

However, overcommitment means that at any moment, the system must decide which pages reside in physical frames and which remain on disk. This decision is frame allocation.

The Core Tension

Virtual memory allows processes to believe they have abundant memory. Physical memory enforces the reality of scarcity. Frame allocation is the bridge between illusion and reality—it determines which parts of the illusion are backed by fast RAM and which are relegated to slow disk storage.

Calculating Available Frames

Before allocating frames to processes, the operating system must determine how many frames are actually available for allocation. This is not simply the total RAM divided by page size—several categories of memory are reserved or unavailable.

Total frames calculation:

Total Frames = Physical RAM Size / Page Size
             = 16 GB / 4 KB
             = 16 × 2³⁰ bytes / 4 × 2¹⁰ bytes
             = 4 × 2²⁰ frames
             = 4,194,304 frames

Reserved frames:

Not all frames are available for user process allocation:

Kernel memory: The kernel's code, data structures, and buffers are typically non-pageable (always resident) and occupy a fixed portion of physical memory.
Hardware reservations: Some memory addresses are mapped to hardware devices (memory-mapped I/O), firmware tables (BIOS/UEFI), or reserved by the hardware for specific purposes.
Kernel structures: Page tables themselves consume memory. For each process, representing its virtual address space requires frames for page table entries.
DMA buffers: Direct Memory Access buffers must reside in specific memory regions accessible by hardware devices.

frame_calculation.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
/*
 * Frame Availability Calculation
 *
 * This demonstrates how an OS calculates frames available
 * for user process allocation.
 */
 
#include <stdio.h>
#include <stdint.h>
 
#define PAGE_SIZE           4096    // 4 KB pages
#define GB                  (1UL << 30)
#define MB                  (1UL << 20)
 
typedef struct {
    uint64_t total_ram;
    uint64_t reserved_hardware;     // BIOS, MMIO regions
    uint64_t kernel_resident;       // Kernel code + data
    uint64_t kernel_structures;     // Page tables, slab caches
    uint64_t dma_reserved;          // DMA buffers
    uint64_t page_cache_minimum;    // Min for file caching
} MemoryPartition;
 
typedef struct {
    uint64_t total_frames;
    uint64_t reserved_frames;
    uint64_t allocatable_frames;
    uint64_t free_list_frames;      // Currently free
} FrameStatistics;
 
FrameStatistics calculate_frame_availability(MemoryPartition *mp) {
    FrameStatistics stats;
    
    // Total frames from total RAM
    stats.total_frames = mp->total_ram / PAGE_SIZE;
    
    // Sum all reserved memory
    uint64_t reserved_bytes = mp->reserved_hardware +
                              mp->kernel_resident +
                              mp->kernel_structures +
                              mp->dma_reserved +
                              mp->page_cache_minimum;
    
    stats.reserved_frames = (reserved_bytes + PAGE_SIZE - 1) / PAGE_SIZE;
    
    // Frames available for user process allocation
    stats.allocatable_frames = stats.total_frames - stats.reserved_frames;
    
    // Free frames would be tracked dynamically
    stats.free_list_frames = 0;  // Placeholder
    
    return stats;
}
 
void print_statistics(FrameStatistics *stats) {
    printf("
Frame Allocation Statistics:
");
    printf("=================================
");
    printf("Total Frames:       %lu
", stats->total_frames);
    printf("Reserved Frames:    %lu
", stats->reserved_frames);
    printf("Allocatable:        %lu
", stats->allocatable_frames);
    printf("
");
    printf("Allocatable Memory: %.2f GB
", 
           (double)stats->allocatable_frames * PAGE_SIZE / GB);
}
 
/*
 * Example for a 16 GB system:
 *
 * Total RAM:           16 GB
 * Hardware Reserved:   256 MB (BIOS, MMIO)
 * Kernel Resident:     512 MB (kernel code/data)
 * Kernel Structures:   768 MB (page tables, slabs)
 * DMA Reserved:        128 MB (device buffers)
 * Page Cache Min:      512 MB (ensure file I/O works)
 * ---------------------
 * Reserved Total:      ~2.2 GB
 * Allocatable:         ~13.8 GB
 *
 * This ~13.8 GB is what can be distributed among user processes.
 */

Dynamic availability:

The number of frames available for allocation isn't static. It changes based on:

Page cache pressure: The OS can reclaim pages used for caching files when memory is needed
Kernel memory usage: Some kernel allocations can grow or shrink (e.g., network buffers during heavy traffic)
Swapping decisions: As processes are swapped out, their frames become available for others
Hardware hotplug: On some systems, memory can be added or removed dynamically

The operating system maintains several lists to track frame status:

Free list: Frames immediately available for allocation
Active list: Frames in use, recently accessed
Inactive list: Frames in use, not recently accessed (candidates for reclamation)
Dirty list: Frames with modified data that must be written before reclamation

The Multiplexing Challenge

Frame allocation is fundamentally a resource multiplexing problem. Limited physical frames must be shared among multiple competing processes, each with its own memory requirements and access patterns.

Why multiplexing is hard:

Unlike CPU scheduling, where time can be sliced in small increments and shared rapidly, memory frames cannot be so easily multiplexed:

Switching cost: Changing which process uses a frame is expensive—it requires disk I/O to save the old page and load the new one. This is orders of magnitude slower than a context switch.
Locality requirements: Processes don't access memory randomly. They exhibit locality of reference, accessing small subsets of their address space intensively. A process needs a certain number of frames to hold its working set; fewer frames cause constant page faults.
Minimum thresholds: Below a certain number of frames, a process cannot make forward progress. Each instruction might require multiple pages (instruction page, data page, stack page), creating a hard minimum.
Non-preemptible during access: Once a page is being accessed, it cannot be immediately reclaimed. The process may be mid-instruction, requiring the page until the instruction completes.

CPU Time Multiplexing

•Granularity: Milliseconds
•Switch cost: ~1-10 microseconds
•Minimum quantum: 1 ms feasible
•Sharing model: Time-sliced
•Overhead: Very low
•Starvation: Easily prevented

Memory Frame Multiplexing

•Granularity: Pages (4 KB+)
•Switch cost: ~5-15 milliseconds (disk I/O)
•Minimum allocation: 10s-100s of frames
•Sharing model: Space-divided
•Overhead: Extremely high if wrong
•Starvation: Can cause thrashing

The 10,000x difference:

Consider the cost difference between switching contexts and switching pages:

Context switch: Save registers, switch page tables, restore registers. ~1-10 μs
Page fault with disk I/O: Trap to kernel, locate page on disk, initiate I/O, wait for disk, load page, update page table, restart instruction. ~5-15 ms

This is a 1,000-15,000x difference. A process experiencing page faults for even 1% of its memory accesses can see performance degradation of 100x or more. This is why frame allocation decisions have such dramatic impact on system performance.

The Cliff Effect

Unlike CPU scheduling where giving a process less time means proportionally slower execution, memory allocation has a cliff effect. Give a process 90% of needed frames, and it might run at 80% efficiency. Give it 60%, and it might run at 5% efficiency due to constant page faults. This non-linear degradation makes frame allocation particularly challenging.

Frame Scarcity Scenarios

To build intuition about limited frames, let's examine several scenarios that illustrate how scarcity manifests in real systems.

Scenario 1: Single large process

A scientific computing application attempts to process a 20 GB dataset on a system with 16 GB RAM. Even with all frames allocated to this one process, it cannot fit its entire working set in memory. The OS must:

Page out portions of the dataset not currently being processed
Manage I/O scheduling to minimize disk seeks
Hopefully the algorithm exhibits locality, accessing data in predictable patterns

Scenario 2: Many small processes

A web server spawns 100 worker processes, each requiring 200 MB for optimal operation. Total demand: 20 GB. With 16 GB RAM:

Each process could get ~160 MB (80% of optimal)
Marginal processes might trigger page faults
Under load, some workers might thrash

Scenario 3: Mixed workload

A desktop system runs:

Browser: 4 GB
IDE: 2 GB
Database: 3 GB
Various utilities: 1 GB
OS overhead: 2 GB
Total: 12 GB on 16 GB system

This seems fine until the user opens a large file in the IDE, triggering additional memory demand that pushes the system into memory pressure.

scarcity_simulation.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
/*
 * Frame Scarcity Simulation
 *
 * This simulation demonstrates how the operating system
 * must cope with frame scarcity across multiple processes.
 */
 
#include <stdio.h>
#include <stdbool.h>
 
#define MAX_PROCESSES 10
#define TOTAL_FRAMES 1000   // Simulated available frames
 
typedef struct {
    int pid;
    int requested_frames;   // What process wants
    int minimum_frames;     // Below this: cannot run
    int optimal_frames;     // For full efficiency
    int allocated_frames;   // What it actually gets
    double efficiency;      // Performance fraction
} ProcessMemory;
 
/*
 * Calculate efficiency based on allocated vs needed frames.
 * Models the non-linear degradation of insufficient memory.
 */
double calculate_efficiency(int allocated, int minimum, int optimal) {
    if (allocated < minimum) {
        return 0.0;  // Cannot make progress
    }
    
    if (allocated >= optimal) {
        return 1.0;  // Full efficiency
    }
    
    // Non-linear model: efficiency drops sharply as we approach minimum
    // This models the "cliff effect" of memory pressure
    double range = optimal - minimum;
    double above_min = allocated - minimum;
    double ratio = above_min / range;
    
    // Quadratic falloff - more realistic than linear
    return ratio * ratio;
}
 
void simulate_allocation(ProcessMemory procs[], int n, int strategy) {
    int remaining = TOTAL_FRAMES;
    
    printf("
=== Allocation Strategy: %s ===
",
           strategy == 0 ? "Equal" : 
           strategy == 1 ? "Proportional" : "Priority");
    
    // Calculate total demand
    int total_requested = 0;
    int total_minimum = 0;
    for (int i = 0; i < n; i++) {
        total_requested += procs[i].requested_frames;
        total_minimum += procs[i].minimum_frames;
    }
    
    printf("Total requested: %d frames
", total_requested);
    printf("Total minimum:   %d frames
", total_minimum);
    printf("Available:       %d frames
", TOTAL_FRAMES);
    
    if (total_minimum > TOTAL_FRAMES) {
        printf("WARNING: Cannot satisfy minimum requirements!
");
    }
    
    // Perform allocation based on strategy
    int allocated_sum = 0;
    for (int i = 0; i < n; i++) {
        switch (strategy) {
            case 0:  // Equal allocation
                procs[i].allocated_frames = TOTAL_FRAMES / n;
                break;
                
            case 1:  // Proportional to request
                procs[i].allocated_frames = 
                    (procs[i].requested_frames * TOTAL_FRAMES) / total_requested;
                break;
                
            case 2:  // Ensure minimum, then distribute rest
                procs[i].allocated_frames = procs[i].minimum_frames;
                break;
        }
        allocated_sum += procs[i].allocated_frames;
    }
    
    // Strategy 2: distribute remaining proportionally
    if (strategy == 2) {
        int remaining_frames = TOTAL_FRAMES - allocated_sum;
        for (int i = 0; i < n; i++) {
            int extra_wanted = procs[i].optimal_frames - procs[i].minimum_frames;
            int total_extra = total_requested - total_minimum;
            if (total_extra > 0) {
                procs[i].allocated_frames += 
                    (extra_wanted * remaining_frames) / total_extra;
            }
        }
    }
    
    // Calculate efficiencies and print results
    printf("
%-5s %-8s %-8s %-8s %-8s %-10s
", 
           "PID", "Min", "Optimal", "Request", "Alloc", "Efficiency");
    printf("-------------------------------------------------
");
    
    double total_efficiency = 0;
    for (int i = 0; i < n; i++) {
        procs[i].efficiency = calculate_efficiency(
            procs[i].allocated_frames,
            procs[i].minimum_frames,
            procs[i].optimal_frames
        );
        
        printf("%-5d %-8d %-8d %-8d %-8d %.2f%%
",
               procs[i].pid,
               procs[i].minimum_frames,
               procs[i].optimal_frames,
               procs[i].requested_frames,
               procs[i].allocated_frames,
               procs[i].efficiency * 100);
        
        total_efficiency += procs[i].efficiency;
    }
    
    printf("-------------------------------------------------
");
    printf("Average Efficiency: %.2f%%
", (total_efficiency / n) * 100);
}

Key Insight

The simulation reveals why allocation strategy matters enormously. Equal allocation might seem fair but can leave large processes thrashing while small processes have excess frames. Proportional allocation better matches actual needs but may starve small but critical processes. There is no universally optimal strategy—each involves tradeoffs.

System-Wide Implications

The limited frame constraint doesn't just affect individual processes—it has profound system-wide implications that shape operating system design.

1. Admission Control

The OS may need to limit how many processes can run concurrently. If admitting another process would reduce everyone's frame allocation below useful levels, it's better to make the new process wait. This is fundamentally different from CPU scheduling, where adding another process simply means everyone gets smaller time slices.

2. Degree of Multiprogramming

The degree of multiprogramming is the number of processes in memory simultaneously. Too low, and the CPU sits idle during I/O waits. Too high, and processes thrash. The optimal degree depends on available frames and process characteristics.

3. Memory Pressure Response

When frames are scarce, the system must take action:

Reclaim pages from file cache
Invoke the page replacement algorithm more aggressively
Consider swapping entire processes out
In extreme cases, invoke the OOM (Out Of Memory) killer

Memory Pressure Levels

•Low pressure: Free frames available, file cache can grow, allocation is instant
•Medium pressure: Free frames depleted, reclaiming from file cache, slight slowdown in allocations
•High pressure: Actively paging out user memory, page replacement algorithm running continuously
•Critical pressure: Swapping processes to disk, significant I/O overhead, system becoming sluggish
•OOM condition: No memory available even after aggressive reclamation, must kill processes to survive

4. Performance Cliffs

As memory pressure increases, performance doesn't degrade linearly. Systems exhibit performance cliffs where small increases in memory pressure cause dramatic performance drops:

Memory Utilization	Typical Performance
0-60%	Full speed, frames abundant
60-80%	Minor slowdowns, file cache shrinking
80-90%	Noticeable delays, page reclamation active
90-95%	Significant slowdown, swap activity
95-100%	Thrashing zone, system may be unusable

The Thrashing Disaster

When every process is given too few frames, they all fault constantly. The disk becomes saturated with paging I/O. CPU utilization drops to near zero as all processes wait for pages. The system appears frozen. This is thrashing—and it's entirely preventable with proper frame allocation policies. We'll explore thrashing in depth in later modules.

Historical Perspective

Understanding the history of memory scarcity provides valuable context for modern systems.

The early days (1960s-1970s):

Total RAM measured in kilobytes to low megabytes
A 256 KB system was considered well-equipped
Virtual memory was revolutionary because physical memory was so scarce
Frame allocation was manual—operators decided which jobs ran together

The PC era (1980s-1990s):

Early PCs had 64 KB to 640 KB of usable RAM
DOS applications carefully managed memory overlays
Windows 3.x introduced virtual memory on PCs
The "640K ought to be enough" myth reflects how scarce memory seemed

The modern era (2000s-present):

Systems commonly have 8-64 GB RAM
But applications have grown faster than RAM:
- Chrome with tabs: gigabytes
- Modern IDEs: gigabytes
- Databases: as much as available
- Machine learning: hundreds of gigabytes for model training

The constancy of scarcity:

Despite a millionfold increase in RAM capacity, memory scarcity persists. Developers expand their applications to fill available memory. Parkinson's Law applies to memory: "Work expands to fill the time available for its completion"—and software expands to fill available memory.

Evolution of Memory Scarcity
Era	Typical RAM	Typical Application	Scarcity Ratio
1970s Mainframe	2 MB	Batch job: 256 KB	8:1 oversubscription
1990s Desktop	16 MB	Office suite: 4 MB	4:1 possible
2000s Desktop	512 MB	Browser + Office: 256 MB	2:1 comfortable
2010s Laptop	8 GB	Modern workflow: 6 GB	1.3:1 tight
2020s Workstation	32 GB	Dev environment: 20+ GB	1.5:1 still constrained

The More Things Change...

Despite enormous increases in physical RAM, the fundamental problem remains: aggregate demand exceeds supply. The frame allocation problem is as relevant today as it was in the earliest virtual memory systems. The scale has changed; the challenge has not.

Implications for System Design

The reality of limited frames shapes operating system design in profound ways.

Lazy allocation everywhere:

Because frames are precious, OSes delay allocation as long as possible:

Demand paging: Don't load pages until accessed
Copy-on-write: Don't copy pages until modified
Zero-fill-on-demand: Don't allocate writable pages until written
Overcommit: Allow allocations that exceed physical memory

Reclamation mechanisms:

Because demand exceeds supply, OSes must constantly reclaim frames:

Page replacement algorithms (LRU, Clock, etc.)
Page cache shrinkage under pressure
Swap space for backing evicted pages
OOM killer as last resort

Admission and load control:

To prevent thrashing, OSes may limit concurrency:

Working set tracking to estimate process needs
Page fault frequency monitoring
Automatic process suspension/swapping
Memory cgroups and limits in containers

Design Principles Derived from Frame Scarcity

•Assume overcommitment: Design for the case where total virtual memory exceeds physical memory
•Delay everything possible: Allocate frames only when absolutely necessary
•Have a reclamation strategy: Know how to get frames back when needed
•Monitor and adapt: Track memory pressure and adjust behavior accordingly
•Fail gracefully: When memory is exhausted, fail predictably rather than randomly
•Prioritize wisely: Not all pages are equally important—know which to keep

For System Designers

Every feature that consumes memory should consider frame allocation implications. Caches should be tunable and shrinkable. Allocations should be lazy. Memory usage should be monitorable. The assumption of abundant memory leads to systems that collapse under load—assume scarcity and design accordingly.

Summary: The Scarcity Imperative

We've established the fundamental constraint that drives all frame allocation decisions: physical memory is finite while virtual memory and process demands are essentially unlimited.

This page has built the conceptual foundation for understanding frame allocation. The key insights are:

Key Takeaways

•Physical memory is fixed — Unlike virtual memory, RAM capacity is a hard constraint
•Overcommitment is normal — Total virtual allocations routinely exceed physical memory
•Frame switching is expensive — Unlike CPU time, reallocating frames requires slow disk I/O
•Non-linear degradation — Insufficient frames cause disproportionate performance loss
•Scarcity is eternal — Despite RAM growth, demand grows faster; the problem persists
•Design assumes scarcity — Every OS mechanism reflects the reality of limited frames

What's next:

Now that we understand why frame scarcity exists and its implications, we'll examine process requirements—how to determine how many frames each process actually needs. This leads directly to allocation strategies that balance efficiency, fairness, and system stability.

Page Complete

You now understand the fundamental constraint of limited frames and why it makes frame allocation one of the most critical decisions in operating system design. Next, we'll explore how to determine what each process actually requires from this limited pool.