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

/*
 * Equal Frame Allocation
 *
 * The simplest allocation strategy: divide frames equally.
 */
 
#include <stdio.h>
#include <stdlib.h>
 
#define MAX_PROCESSES 100
 
typedef struct {
    int pid;
    int size_pages;          // Total address space size
    int working_set_size;    // Current WSS
    int allocated_frames;    // Frames allocated
    int page_faults;         // Fault count for efficiency calc
} Process;
 
typedef struct {
    int total_frames;
    int reserved_frames;     // For OS, not allocatable
    int num_processes;
    Process processes[MAX_PROCESSES];
} System;
 
/*
 * Simple equal allocation
 */
void equal_allocation(System *sys) {
    int available = sys->total_frames - sys->reserved_frames;
    int per_process = available / sys->num_processes;
    
    printf("Equal Allocation Strategy
");
    printf("=========================
");
    printf("Available frames: %d
", available);
    printf("Processes: %d
", sys->num_processes);
    printf("Frames per process: %d
 
", per_process);
    
    for (int i = 0; i < sys->num_processes; i++) {
        sys->processes[i].allocated_frames = per_process;
    }
}
 
/*
 * Analyze efficiency of equal allocation
 */
void analyze_equal_allocation(System *sys) {
    printf("%-5s %-12s %-12s %-12s %-10s
",
           "PID", "WSS", "Allocated", "Difference", "Status");
    printf("-----------------------------------------------------
");
    
    int total_wasted = 0;
    int total_deficit = 0;
    int thrashing = 0;
    
    for (int i = 0; i < sys->num_processes; i++) {
        Process *p = &sys->processes[i];
        int diff = p->allocated_frames - p->working_set_size;
        const char *status;
        
        if (diff >= 0) {
            status = "OK";
            total_wasted += diff;
        } else {
            if (-diff > p->working_set_size / 2) {
                status = "THRASHING";
                thrashing++;
            } else {
                status = "Struggling";
            }
            total_deficit -= diff;
        }
        
        printf("%-5d %-12d %-12d %-12d %-10s
",
               p->pid, p->working_set_size, 
               p->allocated_frames, diff, status);
    }
    
    printf("-----------------------------------------------------
");
    printf("Total frames wasted: %d
", total_wasted);
    printf("Total frame deficit: %d
", total_deficit);
    printf("Processes thrashing: %d
 
", thrashing);
    
    if (total_wasted > 0 && total_deficit > 0) {
        printf("INEFFICIENCY: %d frames wasted while %d processes starve!
",
               total_wasted, thrashing);
        printf("Equal allocation fails when process sizes differ.
");
    }
}
 
/*
 * Example scenario showing equal allocation problems:
 *
 * System: 1000 frames, 5 processes
 * Each process gets: 200 frames
 *
 * Process A: WSS = 50  -> 150 frames wasted
 * Process B: WSS = 80  -> 120 frames wasted
 * Process C: WSS = 150 -> 50 frames wasted
 * Process D: WSS = 400 -> 200 frame deficit, THRASHING
 * Process E: WSS = 320 -> 120 frame deficit, struggling
 *
 * Total wasted: 320 frames  
 * Total deficit: 320 frames
 * 
 * The inefficiency is symmetric: we could reallocate wasted
 * frames to struggling processes, but equal allocation doesn't.
 */

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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

/*
 * Proportional Frame Allocation
 *
 * Allocates frames based on process size relative to total.
 */
 
#include <stdio.h>
#include <stdlib.h>
 
#define MAX_PROCESSES 100
#define MIN_FRAMES 4          // Architectural minimum
 
typedef struct {
    int pid;
    int size;                 // Size metric (VM size, WSS, etc.)
    int allocated;
    int min_guaranteed;       // Never go below this
} ProcessInfo;
 
/*
 * Proportional allocation with minimum guarantee
 */
void proportional_allocation(ProcessInfo procs[], int n, 
                             int available_frames) {
    printf("Proportional Allocation
");
    printf("=======================
 
");
    
    // Calculate total size
    int total_size = 0;
    for (int i = 0; i < n; i++) {
        total_size += procs[i].size;
    }
    
    printf("Total process size: %d pages
", total_size);
    printf("Available frames: %d
 
", available_frames);
    
    // First pass: allocate proportionally
    int allocated_sum = 0;
    for (int i = 0; i < n; i++) {
        // Proportional share
        int share = (procs[i].size * available_frames) / total_size;
        
        // Ensure minimum
        if (share < procs[i].min_guaranteed) {
            share = procs[i].min_guaranteed;
        }
        
        procs[i].allocated = share;
        allocated_sum += share;
    }
    
    // Handle rounding: distribute remaining frames
    int remaining = available_frames - allocated_sum;
    while (remaining > 0) {
        // Give extra frames to largest processes first
        for (int i = 0; i < n && remaining > 0; i++) {
            procs[i].allocated++;
            remaining--;
        }
    }
    
    // Handle overallocation: take from largest processes
    while (remaining < 0) {
        for (int i = n-1; i >= 0 && remaining < 0; i--) {
            if (procs[i].allocated > procs[i].min_guaranteed) {
                procs[i].allocated--;
                remaining++;
            }
        }
    }
    
    // Print results
    printf("%-5s %-10s %-12s %-10s
",
           "PID", "Size", "Proportion", "Allocated");
    printf("----------------------------------------
");
    
    for (int i = 0; i < n; i++) {
        double proportion = (double)procs[i].size / total_size * 100;
        printf("%-5d %-10d %9.1f%%   %-10d
",
               procs[i].pid, procs[i].size, proportion, procs[i].allocated);
    }
    
    printf("----------------------------------------
");
    printf("Total allocated: %d
", available_frames);
}
 
/*
 * Compare proportional vs equal allocation
 */
void compare_strategies() {
    ProcessInfo procs[] = {
        {1, 100, 0, MIN_FRAMES},
        {2, 200, 0, MIN_FRAMES},
        {3, 300, 0, MIN_FRAMES},
        {4, 50,  0, MIN_FRAMES},
        {5, 350, 0, MIN_FRAMES},
    };
    int n = 5;
    int available = 500;
    
    printf("
=== Comparison: Equal vs Proportional ===
 
");
    
    // Calculate total size
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += procs[i].size;
    }
    
    printf("%-5s %-8s %-10s %-12s
",
           "PID", "Size", "Equal", "Proportional");
    printf("--------------------------------------
");
    
    int equal_per_proc = available / n;
    for (int i = 0; i < n; i++) {
        int prop = (procs[i].size * available) / total;
        printf("%-5d %-8d %-10d %-12d
",
               procs[i].pid, procs[i].size, equal_per_proc, prop);
    }
    
    printf("
With proportional allocation:
");
    printf("  - Small processes (50 pages) get 25 frames
");
    printf("  - Large processes (350 pages) get 175 frames
");
    printf("  - Better match between need and allocation
");
}
 
/*
 * Advantages of proportional allocation:
 * 1. Larger processes get more frames (matches intuition)
 * 2. Reduces waste from over-allocating small processes
 * 3. Reduces thrashing in large processes
 *
 * Disadvantages:
 * 1. Assumes size ~ need (not always true)
 * 2. What size metric to use?
 * 3. Still doesn't consider urgency or priority
 * 4. A process with huge VM but tiny WSS gets too much
 */

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
141
142
143
144
145
146
147
148
149
150
151
152
153
154

/*
 * Priority-Based Frame Allocation
 *
 * Allocates frames considering both size and priority.
 */
 
#include <stdio.h>
#include <stdlib.h>
 
typedef enum {
    PRIORITY_REALTIME = 4,
    PRIORITY_INTERACTIVE = 3,
    PRIORITY_NORMAL = 2,
    PRIORITY_BACKGROUND = 1,
    PRIORITY_IDLE = 0
} Priority;
 
typedef struct {
    int pid;
    const char *name;
    int size;               // Working set size
    Priority priority;
    double multiplier;      // Priority-based multiplier
    int allocated;
    int minimum;            // Guaranteed minimum
} PriorityProcess;
 
double get_multiplier(Priority p) {
    switch (p) {
        case PRIORITY_REALTIME:     return 3.0;
        case PRIORITY_INTERACTIVE:  return 1.5;
        case PRIORITY_NORMAL:       return 1.0;
        case PRIORITY_BACKGROUND:   return 0.5;
        case PRIORITY_IDLE:         return 0.25;
        default:                    return 1.0;
    }
}
 
const char* priority_name(Priority p) {
    switch (p) {
        case PRIORITY_REALTIME:     return "Real-time";
        case PRIORITY_INTERACTIVE:  return "Interactive";
        case PRIORITY_NORMAL:       return "Normal";
        case PRIORITY_BACKGROUND:   return "Background";
        case PRIORITY_IDLE:         return "Idle";
        default:                    return "Unknown";
    }
}
 
void priority_allocation(PriorityProcess procs[], int n, 
                         int available_frames) {
    printf("Priority-Based Allocation
");
    printf("=========================
 
");
    
    // Calculate effective sizes
    double total_effective = 0;
    for (int i = 0; i < n; i++) {
        procs[i].multiplier = get_multiplier(procs[i].priority);
        total_effective += procs[i].size * procs[i].multiplier;
    }
    
    // First pass: ensure all minimums
    int minimum_total = 0;
    for (int i = 0; i < n; i++) {
        minimum_total += procs[i].minimum;
    }
    
    if (minimum_total > available_frames) {
        printf("ERROR: Cannot satisfy minimum requirements!
");
        return;
    }
    
    int distributable = available_frames - minimum_total;
    
    // Allocate based on priority-weighted size
    for (int i = 0; i < n; i++) {
        double effective_size = procs[i].size * procs[i].multiplier;
        int extra = (int)((effective_size / total_effective) * distributable);
        procs[i].allocated = procs[i].minimum + extra;
    }
    
    // Display results
    printf("Available: %d frames, Minimum reserved: %d, "
           "Distributable: %d
 
", 
           available_frames, minimum_total, distributable);
    
    printf("%-15s %-6s %-12s %-6s %-10s %-10s
",
           "Process", "Size", "Priority", "Mult", "Effective", "Allocated");
    printf("----------------------------------------------------------------
");
    
    for (int i = 0; i < n; i++) {
        printf("%-15s %-6d %-12s ×%-5.1f %-10.0f %-10d
",
               procs[i].name,
               procs[i].size,
               priority_name(procs[i].priority),
               procs[i].multiplier,
               procs[i].size * procs[i].multiplier,
               procs[i].allocated);
    }
}
 
/*
 * Priority-based reclamation under memory pressure
 */
void reclaim_from_low_priority(PriorityProcess procs[], int n, 
                               int frames_needed) {
    printf("
Memory Pressure: Need to reclaim %d frames
", frames_needed);
    printf("Reclaiming from lowest priority processes first:
 
");
    
    int reclaimed = 0;
    
    // Start with lowest priority
    for (Priority p = PRIORITY_IDLE; p <= PRIORITY_REALTIME && reclaimed < frames_needed; p++) {
        for (int i = 0; i < n && reclaimed < frames_needed; i++) {
            if (procs[i].priority == p && 
                procs[i].allocated > procs[i].minimum) {
                int can_take = procs[i].allocated - procs[i].minimum;
                int taking = (can_take < frames_needed - reclaimed) ? 
                             can_take : frames_needed - reclaimed;
                
                printf("  Taking %d frames from %s (was %d, now %d)
",
                       taking, procs[i].name,
                       procs[i].allocated,
                       procs[i].allocated - taking);
                
                procs[i].allocated -= taking;
                reclaimed += taking;
            }
        }
    }
    
    if (reclaimed < frames_needed) {
        printf("
WARNING: Could only reclaim %d of %d needed frames!
",
               reclaimed, frames_needed);
        printf("Consider swapping or terminating processes.
");
    }
}

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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

/*
 * Dynamic Frame Allocation
 *
 * Adapts allocation based on observed process behavior
 * and system-wide memory pressure.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
 
#define HIGH_PRESSURE_THRESHOLD 0.9    // 90% memory used
#define LOW_PRESSURE_THRESHOLD  0.7    // 70% memory used
#define PFF_HIGH  10.0                 // Faults/sec - need more frames
#define PFF_LOW   1.0                  // Faults/sec - can reduce frames
 
typedef enum {
    PRESSURE_LOW,
    PRESSURE_MEDIUM,
    PRESSURE_HIGH,
    PRESSURE_CRITICAL
} MemoryPressure;
 
typedef struct {
    int pid;
    int allocated_frames;
    int minimum_frames;
    int maximum_frames;       // Upper limit
    
    // Observed behavior
    double page_fault_rate;   // Faults per second
    int working_set_estimate;
    time_t last_adjustment;
    
    // Adjustment tracking
    int frames_to_give;       // Positive = should get more
    bool can_take_frames;     // Can we take from this process?
} DynamicProcess;
 
typedef struct {
    int total_frames;
    int used_frames;
    MemoryPressure pressure;
    int adjustment_interval_ms;
} SystemState;
 
/*
 * Determine memory pressure level
 */
MemoryPressure calculate_pressure(SystemState *state) {
    double utilization = (double)state->used_frames / state->total_frames;
    
    if (utilization > 0.95) return PRESSURE_CRITICAL;
    if (utilization > 0.90) return PRESSURE_HIGH;
    if (utilization > 0.70) return PRESSURE_MEDIUM;
    return PRESSURE_LOW;
}
 
/*
 * Page Fault Frequency based adjustment
 *
 * If fault rate is high, process needs more frames.
 * If fault rate is low, frames could be taken.
 */
void pff_adjustment(DynamicProcess procs[], int n) {
    printf("PFF-Based Allocation Adjustment
");
    printf("================================
 
");
    
    for (int i = 0; i < n; i++) {
        DynamicProcess *p = &procs[i];
        
        printf("PID %d: Fault rate = %.2f/sec
", 
               p->pid, p->page_fault_rate);
        
        if (p->page_fault_rate > PFF_HIGH) {
            // Need more frames
            int need = (p->working_set_estimate - p->allocated_frames);
            need = (need > 0) ? need : p->allocated_frames / 10;
            p->frames_to_give = need;
            p->can_take_frames = false;
            printf("  -> NEEDS %d more frames (high fault rate)
", need);
            
        } else if (p->page_fault_rate < PFF_LOW) {
            // Can potentially give up frames
            int excess = p->allocated_frames - p->working_set_estimate;
            excess = (excess > 0) ? excess : 0;
            p->frames_to_give = 0;
            p->can_take_frames = (excess > 0);
            printf("  -> CAN GIVE UP ~%d frames (low fault rate)
", excess);
            
        } else {
            // In acceptable range
            p->frames_to_give = 0;
            p->can_take_frames = false;
            printf("  -> STABLE (acceptable fault rate)
");
        }
    }
}
 
/*
 * Rebalance frames between processes
 */
void rebalance_frames(DynamicProcess procs[], int n, SystemState *state) {
    printf("
Rebalancing Frames
");
    printf("==================
 
");
    
    // Find processes that need frames
    int total_need = 0;
    for (int i = 0; i < n; i++) {
        if (procs[i].frames_to_give > 0) {
            total_need += procs[i].frames_to_give;
        }
    }
    
    if (total_need == 0) {
        printf("No processes need additional frames.
");
        return;
    }
    
    printf("Total frames needed: %d
", total_need);
    
    // Find frames that can be taken
    int available = 0;
    for (int i = 0; i < n; i++) {
        if (procs[i].can_take_frames) {
            int excess = procs[i].allocated_frames - 
                        procs[i].working_set_estimate;
            if (excess > 0) {
                available += excess;
            }
        }
    }
    
    // Also check free frames
    int free_frames = state->total_frames - state->used_frames;
    available += free_frames;
    
    printf("Available to redistribute: %d
 
", available);
    
    // Redistribute (simplified)
    int to_distribute = (available < total_need) ? available : total_need;
    
    for (int i = 0; i < n && to_distribute > 0; i++) {
        if (procs[i].frames_to_give > 0) {
            int give = (procs[i].frames_to_give < to_distribute) ?
                       procs[i].frames_to_give : to_distribute;
            
            // Respect maximum
            if (procs[i].allocated_frames + give > procs[i].maximum_frames) {
                give = procs[i].maximum_frames - procs[i].allocated_frames;
            }
            
            printf("PID %d: Adding %d frames (%d -> %d)
",
                   procs[i].pid, give,
                   procs[i].allocated_frames,
                   procs[i].allocated_frames + give);
            
            procs[i].allocated_frames += give;
            to_distribute -= give;
        }
    }
    
    if (to_distribute < total_need) {
        printf("
Note: Only partially satisfied needs.
");
        printf("Consider swapping out low-priority processes.
");
    }
}

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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

/*
 * Practical Allocation Implementation
 *
 * Demonstrates key implementation aspects of frame allocation.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
 
typedef struct {
    int id;
    int rss;            // Resident Set Size
    int limit;          // Maximum allowed frames
    int min_required;   // Minimum required frames
    int shared_pages;   // Pages shared with other processes
} ProcessAllocation;
 
typedef struct {
    int total_frames;
    int free_frames;
    int cache_frames;   // File cache, can be reclaimed
    int process_count;
    ProcessAllocation *processes;
} FrameManager;
 
/*
 * Check if allocation is within limits
 */
bool can_allocate(FrameManager *fm, ProcessAllocation *proc) {
    // Check process limit
    if (proc->rss >= proc->limit) {
        printf("PID %d: At allocation limit (%d frames)
",
               proc->id, proc->limit);
        return false;
    }
    
    // Check system-wide availability
    if (fm->free_frames == 0) {
        printf("PID %d: No free frames available
", proc->id);
        return false;
    }
    
    return true;
}
 
/*
 * Try to allocate a frame to a process
 */
bool allocate_frame(FrameManager *fm, ProcessAllocation *proc) {
    if (!can_allocate(fm, proc)) {
        // Try reclamation
        if (fm->cache_frames > 0) {
            // Reclaim from page cache
            fm->cache_frames--;
            fm->free_frames++;
            printf("  Reclaimed 1 frame from page cache
");
        } else {
            // Need to swap or deny
            printf("  No reclaimable frames!
");
            return false;
        }
    }
    
    // Allocate from free list
    fm->free_frames--;
    proc->rss++;
    
    return true;
}
 
/*
 * Reclaim frames from a process
 */
int reclaim_frames(FrameManager *fm, ProcessAllocation *proc, int count) {
    int reclaimed = 0;
    int can_reclaim = proc->rss - proc->min_required;
    
    if (can_reclaim <= 0) {
        printf("PID %d: Cannot reclaim - at minimum
", proc->id);
        return 0;
    }
    
    int to_reclaim = (count < can_reclaim) ? count : can_reclaim;
    
    // Don't count shared pages as reclaimable (simplification)
    if (proc->shared_pages > 0) {
        int private = proc->rss - proc->shared_pages;
        if (private - proc->min_required < to_reclaim) {
            to_reclaim = private - proc->min_required;
            if (to_reclaim < 0) to_reclaim = 0;
        }
    }
    
    proc->rss -= to_reclaim;
    fm->free_frames += to_reclaim;
    reclaimed = to_reclaim;
    
    printf("PID %d: Reclaimed %d frames (RSE now %d)
",
           proc->id, reclaimed, proc->rss);
    
    return reclaimed;
}
 
/*
 * Enforce allocation limits
 */
void enforce_limits(FrameManager *fm) {
    printf("
Enforcing Allocation Limits
");
    printf("===========================
 
");
    
    for (int i = 0; i < fm->process_count; i++) {
        ProcessAllocation *p = &fm->processes[i];
        
        if (p->rss > p->limit) {
            int excess = p->rss - p->limit;
            printf("PID %d: %d frames over limit
", p->id, excess);
            
            int reclaimed = reclaim_frames(fm, p, excess);
            if (reclaimed < excess) {
                printf("  WARNING: Could not fully enforce limit!
");
            }
        }
    }
}
 
/*
 * Handle memory pressure
 */
void handle_memory_pressure(FrameManager *fm, int target_free) {
    printf("
Memory Pressure Handler
");
    printf("Target free frames: %d, Current: %d
 
", 
           target_free, fm->free_frames);
    
    while (fm->free_frames < target_free) {
        // First: page cache
        if (fm->cache_frames > 0) {
            int take = (fm->cache_frames < 10) ? fm->cache_frames : 10;
            fm->cache_frames -= take;
            fm->free_frames += take;
            printf("Reclaimed %d frames from page cache
", take);
            continue;
        }
        
        // Second: find process with most excess
        ProcessAllocation *victim = NULL;
        int max_excess = 0;
        
        for (int i = 0; i < fm->process_count; i++) {
            ProcessAllocation *p = &fm->processes[i];
            int excess = p->rss - p->min_required;
            if (excess > max_excess) {
                max_excess = excess;
                victim = p;
            }
        }
        
        if (victim && max_excess > 0) {
            int take = (max_excess < 10) ? max_excess : 10;
            reclaim_frames(fm, victim, take);
        } else {
            printf("CRITICAL: Cannot reclaim more frames!
");
            printf("Consider OOM killer or swapping.
");
            break;
        }
    }
}