7a:T80d,/** * Global Page Replacement - Conceptual Model * * When a page fault occurs, the victim selection algorithm * examines frames across ALL processes in the system. */ struct frame { int frame_number; pid_t owning_process; // Process that owns this frame int page_number; // Page mapped in this frame bool reference_bit; // For LRU approximation bool modified_bit; // Dirty bit time_t last_access_time; // For true LRU (if tracked) }; struct global_frame_table { struct frame *frames; int total_frames; int free_frame_count; list_head_t free_list; // Free frames list_head_t active_list; // All frames in use }; /** * Global replacement victim selection * Examines ALL frames in the system, not just the faulting process */ int select_global_victim(struct global_frame_table *gft, pid_t faulting_process) { struct frame *best_victim = NULL; int best_score = INT_MIN; /* Iterate over ALL frames in the system */ list_for_each_entry(frame, &gft->active_list, list) { int score = compute_replacement_score(frame); /* Note: We consider frames from ANY process, * not just 'faulting_process' */ if (score > best_score) { best_score = score; best_victim = frame; } } if (best_victim != NULL) { /* The victim might belong to process A while * the fault occurred in process B - this is the * essence of global replacement */ pid_t victim_owner = best_victim->owning_process; /* Update the victim process's page table */ invalidate_pte(victim_owner, best_victim->page_number); /* Handle dirty page if necessary */ if (best_victim->modified_bit) { schedule_page_write(best_victim); } return best_victim->frame_number; } return -1; // No frames available (shouldn't happen) }7b:Tdea,/** * Global Frame Management Infrastructure * * These structures enable system-wide frame tracking * and efficient global victim selection. */ /* Core frame descriptor - one per physical frame */ struct page_frame { int frame_id; atomic_t ref_count; // Reference count for sharing unsigned long flags; // PG_locked, PG_dirty, etc. struct list_head lru_list; // Position in LRU list struct address_space *mapping; // File mapping (if any) pgoff_t index; // Page index in mapping struct mem_cgroup *mem_cg; // Memory control group void *virtual_address; // Kernel virtual address }; /* Page frame flags */ #define PG_locked (1 << 0) // Frame is locked in memory #define PG_referenced (1 << 1) // Reference bit (accessed recently) #define PG_dirty (1 << 2) // Page modified #define PG_active (1 << 3) // On active list #define PG_swapcache (1 << 4) // In swap cache #define PG_unevictable (1 << 5) // Cannot be evicted (mlock'd) /* Global LRU lists - the heart of global replacement */ struct lruvec { struct list_head lists[NR_LRU_LISTS]; unsigned long anon_cost; // Anonymous page costs unsigned long file_cost; // File-backed page costs atomic_long_t nonresident_age; // Non-resident tracking unsigned long refaults; // Refault tracking spinlock_t lru_lock; // Protect list operations }; /* LRU list types */ enum lru_list { LRU_INACTIVE_ANON, // Cold anonymous pages LRU_ACTIVE_ANON, // Hot anonymous pages LRU_INACTIVE_FILE, // Cold file-backed pages LRU_ACTIVE_FILE, // Hot file-backed pages LRU_UNEVICTABLE, // Locked pages NR_LRU_LISTS }; /** * Move a page between LRU lists (global operation) * This affects the page's priority for eviction system-wide */ void lru_cache_add(struct page_frame *page) { struct lruvec *lruvec = mem_cgroup_page_lruvec(page); enum lru_list lru = page_lru(page); spin_lock(&lruvec->lru_lock); /* Add to global LRU list - visible to all processes */ list_add(&page->lru_list, &lruvec->lists[lru]); update_lru_sizes(lruvec, lru, 1); spin_unlock(&lruvec->lru_lock); } /** * Shrink LRU list - global victim selection * Called when system memory pressure is high */ unsigned long shrink_lru_list(struct lruvec *lruvec, unsigned long nr_to_scan, struct scan_control *sc) { struct list_head *lru_list; struct page_frame *page; unsigned long nr_reclaimed = 0; lru_list = &lruvec->lists[active_lru(sc)]; /* Scan pages from ANY process */ while (!list_empty(lru_list) && nr_to_scan > 0) { page = list_entry(lru_list->prev, struct page_frame, lru_list); /* Check if page can be reclaimed */ if (page_evictable(page) && !PageLocked(page)) { /* Try to reclaim - may affect any process */ if (try_to_unmap(page)) { if (PageDirty(page)) pageout(page); // Write back free_page_frame(page); nr_reclaimed++; } } list_move(&page->lru_list, &lruvec->lists[inactive_lru(sc)]); nr_to_scan--; } return nr_reclaimed; }7c:Tc8a,/** * Global Clock Algorithm Implementation * * A single clock hand sweeps across ALL physical frames, * providing LRU approximation across all processes. */ struct global_clock { struct frame *frames; // All physical frames int total_frames; int hand; // Current clock hand position spinlock_t lock; }; static struct global_clock gclock; /** * Initialize global clock structure * Called during system boot */ void init_global_clock(int num_frames) { gclock.frames = kmalloc(sizeof(struct frame) * num_frames); gclock.total_frames = num_frames; gclock.hand = 0; spin_lock_init(&gclock.lock); for (int i = 0; i < num_frames; i++) { gclock.frames[i].frame_number = i; gclock.frames[i].owning_process = -1; // Free gclock.frames[i].reference_bit = 0; gclock.frames[i].modified_bit = 0; } } /** * Select victim using global clock algorithm * Returns frame number of selected victim */ int global_clock_select_victim(pid_t requesting_process) { spin_lock(&gclock.lock); int frames_scanned = 0; /* Sweep through ALL frames, regardless of owner */ while (frames_scanned < gclock.total_frames * 2) { struct frame *current = &gclock.frames[gclock.hand]; /* Skip frames that cannot be evicted */ if (is_frame_locked(current) || is_frame_pinned(current)) { advance_hand(); frames_scanned++; continue; } /* Check reference bit */ if (current->reference_bit == 0) { /* VICTIM FOUND - could be from ANY process! */ pid_t victim_owner = current->owning_process; /* This is the key: we don't care if victim_owner * equals requesting_process or not */ /* Prepare for eviction */ struct victim_info victim = { .frame_number = current->frame_number, .owning_process = victim_owner, .page_number = current->page_number, .is_dirty = current->modified_bit }; advance_hand(); spin_unlock(&gclock.lock); return victim.frame_number; } /* Give second chance: clear reference bit */ current->reference_bit = 0; advance_hand(); frames_scanned++; } spin_unlock(&gclock.lock); /* No victim found - extremely high memory pressure */ return -1; // Trigger OOM or wait } static void advance_hand(void) { gclock.hand = (gclock.hand + 1) % gclock.total_frames; } /** * Example: Global clock in action * * System state: * Frame 0: Process A, Page 5, ref=1 * Frame 1: Process B, Page 2, ref=0 <- Victim selected * Frame 2: Process A, Page 8, ref=1 * Frame 3: Process C, Page 1, ref=1 * Frame 4: Process B, Page 7, ref=0 * * If Process C causes a page fault: * - Clock hand might be at Frame 0 * - Skips Frame 0 (ref=1, clears to ref=0) * - Selects Frame 1 (ref=0) as victim * - Process B loses its page 2! * - Process C gets Frame 1 for its new page */7d:T9fd,""" Noisy Neighbor Problem Demonstration This example shows how one process can degrade others through global replacement frame stealing. """ import time import threading # Shared system state (simulated) TOTAL_FRAMES = 100 frames_per_process = {} def memory_hog(): """Process that touches huge amounts of memory""" process_id = "hog" # Initially, system gives this process just 33 frames frames_per_process[process_id] = 33 print(f"Memory hog starting with {frames_per_process[process_id]} frames") # Now allocate massive working set # With global replacement, it STEALS from others for i in range(10): # Each iteration causes page faults # Global replacement gives more frames to satisfy demand frames_per_process[process_id] += 5 # These frames come FROM other processes! for other in frames_per_process: if other != process_id and frames_per_process[other] > 10: frames_per_process[other] -= 2 print_frame_distribution() time.sleep(1) def database_process(): """Critical database process - needs consistent memory""" process_id = "database" frames_per_process[process_id] = 33 while True: current_frames = frames_per_process.get(process_id, 0) if current_frames < 20: print(f"⚠️ DATABASE DEGRADED: Only {current_frames} frames!") print(" Query latency will spike dramatically") time.sleep(1) def web_server(): """Web server process - loses frames to the hog""" process_id = "webserver" frames_per_process[process_id] = 34 while True: current_frames = frames_per_process.get(process_id, 0) if current_frames < 25: print(f"⚠️ WEB SERVER SLOW: {current_frames} frames insufficient") time.sleep(1) def print_frame_distribution(): total = sum(frames_per_process.values()) print(f" Frame distribution (total: {total}/{TOTAL_FRAMES}):") for proc, frames in frames_per_process.items(): bar = '█' * (frames // 2) print(f" {proc:12}: {bar} ({frames})") # Output after several iterations: # # Frame distribution (total: 100/100): # hog : ████████████████████████████████ (78) # database : ██████ (12) # BELOW WORKING SET! # webserver : █████ (10) # SEVERELY STARVED! # # Result: Memory hog causes database and web server to thrash72:{"json":{"id":"seed_7f6e91e175864abb5765a35be3dd867e","slug":"global-vs-local-replacement","category":"Operating Systems","topic":"Global vs Local Replacement","title":"Global vs Local Replacement","description":"Master the fundamental distinction between global and local page replacement policies. Understand how the scope of replacement decisions affects process isolation, system performance, and overall memory management strategy.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_dc4edcc6a2c445891a8bddb593c05231","title":"Global Replacement","order":0,"content":[{"id":"opening-hook","title":"The System-Wide Memory Pool","content":[{"data":{"content":"When a running process demands a new page and physical memory is exhausted, the operating system faces a pivotal decision: **from which pool of frames should the victim page be selected?** This seemingly simple question has profound implications for system behavior, performance isolation, and overall memory utilization.\n\n**Global replacement** represents one of the two fundamental approaches to this problem—an approach where the operating system treats all of physical memory as a single, shared resource. When any process needs a frame, the replacement algorithm considers *every frame in memory*, regardless of which process currently owns it."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand how global replacement works, why operating systems favor it for throughput optimization, its impact on process behavior, and the sophisticated mechanisms required to implement it effectively. You will gain the analytical skills to evaluate when global replacement excels and when its characteristics may prove problematic.","variant":"info"},"type":"callout"}]},{"id":"understanding-global-replacement","title":"Understanding Global Replacement","content":[{"data":{"content":"At its core, **global replacement** means that when a page fault occurs and no free frames are available, the page replacement algorithm examines all frames in physical memory to select the optimal victim—regardless of which process those frames belong to.\n\n**The fundamental principle:**\n\nIn a global replacement scheme, physical memory is conceptualized as a unified resource pool shared among all processes. The operating system maintains complete authority over frame allocation, dynamically redistributing memory based on observed demand patterns. A process experiencing heavy page faults may effectively 'steal' frames from processes with lower memory pressure."},"type":"text"},{"data":{"fileName":"global_replacement_concept.c","languages":[{"code":"$7a","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"content":"**Key characteristics of global replacement:**\n\n- **Unified memory pool**: All frames are candidates for replacement\n- **Cross-process selection**: A process's fault may evict another process's page\n- **Dynamic reallocation**: Memory distribution changes based on workload demand\n- **No per-process guarantees**: A process cannot rely on keeping any specific number of frames\n- **System-wide optimization**: Replacement decisions optimize for overall system performance"},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"how-global-replacement-works","title":"How Global Replacement Works","content":[{"data":{"content":"To truly understand global replacement, we must trace through the complete lifecycle of a page fault under this policy. The mechanics reveal both the elegance and complexity of treating memory as a shared resource.\n\n**Step-by-step page fault handling with global replacement:**"},"type":"text"},{"data":{"type":"ordered","items":["**Page Fault Trigger**: Process P accesses virtual address V, and the page table entry shows the valid bit is 0 (page not in memory)","**Hardware Trap**: The MMU raises a page fault exception, transferring control to the operating system's page fault handler","**Free Frame Check**: The OS checks the free frame list. If a free frame exists, skip to step 7","**Global Victim Selection**: The replacement algorithm scans the global frame table, examining frames owned by *all* processes","**Victim Identified**: The algorithm selects the optimal victim frame F, which may belong to *any* process Q (Q may or may not equal P)","**Page-Out (if dirty)**: If the victim page has been modified, write it to the swap area on disk","**Update Victim's Page Table**: Mark process Q's page table entry invalid for the evicted page","**Page-In**: Read the faulting page from disk (or zero-fill for anonymous pages) into frame F","**Update Faulting Process's Page Table**: Set process P's page table entry for virtual address V to point to frame F with valid = 1","**Resume Execution**: Return from the fault handler and re-execute the faulting instruction"],"title":{"icon":"Zap","text":"Global Replacement Page Fault Sequence","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"height":"500px","mermaidSyntax":"flowchart TD\n A[Page Fault in Process P] --> B{Free Frame Available?}\n B -->|Yes| G[Allocate Free Frame]\n B -->|No| C[Scan Global Frame Table]\n C --> D[Select Best Victim\nfrom ANY Process]\n D --> E{Victim Page\nModified?}\n E -->|Yes| F[Write Page to Disk]\n E -->|No| H[Mark Victim Invalid]\n F --> H\n H --> I[Victim Process Q\nLoses Frame]\n I --> G\n G --> J[Load Faulting Page]\n J --> K[Update Process P's\nPage Table]\n K --> L[Resume Process P]\n \n style D fill:#ff9999,stroke:#cc0000,stroke-width:2px\n style I fill:#ffcc99,stroke:#ff9900,stroke-width:2px"},"type":"mermaid-excalidraw"},{"data":{"content":"**The critical observation:**\n\nNotice how in step 5, the victim frame can belong to *any* process in the system. If Process A causes a page fault but the LRU page in memory belongs to Process B, Process B loses a frame to satisfy Process A's demand. This is the defining characteristic of global replacement—and the source of both its power and its complications."},"type":"text"}],"titleType":"number","titleNumber":2},{"id":"implementation-mechanisms","title":"Implementation Mechanisms","content":[{"data":{"content":"Implementing global replacement requires sophisticated data structures that track frame status across the entire system. The operating system must maintain a global view of all physical memory, enabling efficient victim selection under heavy load.\n\n**Core data structures for global replacement:**"},"type":"text"},{"data":{"fileName":"global_frame_management.c","languages":[{"code":"$7b","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Info","title":"Linux Implementation: The LRU Lists","content":"Linux implements global replacement through a multi-tier LRU system. Pages move between 'active' and 'inactive' lists based on access patterns. When memory pressure occurs, the kernel's kswapd daemon scans the inactive lists across all zones to find reclaimable pages, regardless of owning process. This is a sophisticated implementation of global replacement with additional heuristics for distinguishing file-backed and anonymous pages.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"clock-algorithm-global","title":"The Clock Algorithm (Global Version)","content":[{"data":{"content":"The Clock algorithm—a practical LRU approximation—demonstrates clearly how global replacement operates across process boundaries. When implemented globally, the clock hand sweeps across frames belonging to all processes, treating physical memory as a circular buffer.\n\n**Global Clock algorithm characteristics:**"},"type":"text"},{"data":{"rows":[["Clock Hand Position","Single hand for entire physical memory","Unified traversal across all process frames"],["Reference Bit Checking","Examines reference bits of all frames","Finds least recently used page system-wide"],["Victim Selection","First frame with reference bit = 0","May belong to any process"],["Second Chance","Applied equally to all processes","Recently accessed pages protected regardless of owner"],["Fairness","Based on access patterns, not process identity","Active processes gain frames; idle processes lose them"]],"caption":"Global Clock Algorithm Properties","headers":["Property","Global Behavior","Significance"]},"type":"table"},{"data":{"fileName":"global_clock.c","languages":[{"code":"$7c","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"content":"**The power of global clock:**\n\nIn the example above, Process C needed a frame and Process B was the 'victim'—not because Process B was doing anything wrong, but simply because its Page 2 hadn't been accessed recently. The global clock algorithm automatically shifts memory toward active processes and away from idle ones."},"type":"text"}],"titleType":"number","titleNumber":4},{"id":"advantages-global-replacement","title":"Advantages of Global Replacement","content":[{"data":{"content":"Global replacement offers compelling benefits that explain why it remains the dominant strategy in modern operating systems. Understanding these advantages illuminates the design philosophies underlying memory management.\n\n**Primary advantages:**"},"type":"text"},{"data":{"items":["**Maximum Memory Utilization** — No frames sit idle while one process thrashes. Memory flows to where demand exists, ensuring every frame serves an active purpose.","**Automatic Load Balancing** — Processes automatically receive frames proportional to their working set requirements. A memory-intensive process naturally acquires more frames than a CPU-bound process.","**Better System Throughput** — By optimizing globally, the system minimizes total page faults, improving overall throughput even if individual processes experience variable performance.","**No Wasted Reservations** — Unlike fixed allocation schemes, there are no pre-reserved frames sitting unused while other processes starve for memory.","**Adaptive to Workload Changes** — As process memory demands shift over time, global replacement automatically redistributes frames without administrator intervention.","**Simpler Administration** — No need to tune per-process memory limits. The system self-optimizes based on observed behavior."],"title":{"icon":"CheckCircle","text":"Key Benefits of Global Replacement","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"left":[{"data":{"items":["System-wide page fault minimization","Idle process pages reclaimed quickly","Active processes run at full speed","Total work completed maximized"],"title":"Throughput Optimization","variant":"accent"},"type":"list"}],"right":[{"data":{"items":["100% of RAM productively utilized","No fragmentation of frame allocations","Memory responds to actual usage","Natural working set sizing"],"title":"Resource Efficiency","variant":"accent"},"type":"list"}]},"type":"two-column"},{"data":{"icon":"Zap","title":"Why Servers Prefer Global Replacement","content":"Server environments particularly benefit from global replacement. Consider a web server where thousands of connections experience varying load patterns throughout the day. Global replacement automatically dedicates more memory to peak-load processes while reclaiming frames from idle connection handlers. This dynamic adaptation is far more efficient than any static allocation could be.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"disadvantages-risks","title":"Disadvantages and Risks","content":[{"data":{"content":"While global replacement offers significant performance benefits, it introduces risks that system designers must carefully consider. The shared memory pool model creates potential failure modes absent in isolated allocation schemes.\n\n**Primary risks and disadvantages:**"},"type":"text"},{"data":{"items":["**Process Interference** — A memory-hungry process can steal frames from other processes, potentially degrading innocent bystanders' performance dramatically.","**Unpredictable Performance** — A process's performance depends not just on its own behavior but on all other processes in the system. The same code may run fast or slow depending on co-located workloads.","**Cascading Thrashing** — One process's excessive memory demand can trigger chain reactions where multiple processes fall below their minimum working set, causing system-wide thrashing.","**Denial of Service Vulnerability** — Malicious or buggy processes can monopolize memory, starving legitimate processes without explicit permission.","**Difficult Capacity Planning** — Because process memory allocation is dynamic, it's harder to predict and guarantee performance for specific workloads.","**Fairness Violations** — Low-priority background tasks may steal frames from high-priority interactive applications during the replacement algorithm's scans."],"title":{"icon":"AlertCircle","text":"Risks of Global Replacement","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"icon":"AlertCircle","title":"The Noisy Neighbor Problem","content":"In cloud computing, global replacement within a host can create 'noisy neighbors'—virtual machines that consume disproportionate memory at the expense of co-located VMs. This is why cloud providers often use memory isolation mechanisms (like cgroups in Linux) to limit each tenant's access to the global frame pool, partially overriding pure global replacement to achieve fairness guarantees.","variant":"warning"},"type":"callout"},{"data":{"fileName":"noisy_neighbor_example.py","languages":[{"code":"$7d","label":"Python","value":"python"}],"showLineNumbers":true},"type":"code"}],"titleType":"number","titleNumber":6},{"id":"mitigating-risks","title":"Mitigating Global Replacement Risks","content":[{"data":{"content":"Modern operating systems employ several techniques to retain global replacement's benefits while limiting its downsides. These mechanisms add constraints to the pure global model, creating hybrid approaches.\n\n**Key mitigation strategies:**"},"type":"text"},{"data":{"rows":[["**Memory Cgroups**","Limit maximum memory consumption per process group","Strong isolation between control groups"],["**OOM Killer**","Terminate runaway processes before system-wide collapse","Last resort protection; kills rather than constrains"],["**Memory Soft Limits**","Allow burst above limit but reclaim aggressively when others need memory","Moderate; allows flexibility with eventual constraints"],["**Working Set Estimation**","Monitor process working sets; resist allocation below estimated WSS","Moderate; prevents catastrophic undersizing"],["**Priority-Based Scanning**","Scan low-priority processes first during reclamation","Protects important processes from frame stealing"],["**mlock() System Call**","Allow processes to lock critical pages in memory","Strong for specific pages; limited capacity"]],"caption":"Global Replacement Risk Mitigation Techniques","headers":["Technique","How It Works","Protection Level"]},"type":"table"},{"data":{"fileName":"memory_cgroup_example.sh","languages":[{"code":"#!/bin/bash\n# Using Linux cgroups to constrain global replacement scope\n\n# Create a memory cgroup for potentially hungry processes\nsudo cgcreate -g memory:/memory_limited\n\n# Set maximum memory limit to 1GB\n# This process cannot steal frames beyond this limit\nsudo cgset -r memory.max=1073741824 memory_limited\n\n# Set high-water mark for reclamation priority (soft limit)\nsudo cgset -r memory.high=536870912 memory_limited\n\n# Run the memory-intensive process in this cgroup\nsudo cgexec -g memory:memory_limited ./memory_hog_process\n\n# Effect: Even with global replacement, this process\n# is constrained to steal frames only up to the limit.\n# Other processes are protected from this \"noisy neighbor.\"\n\n# Check current memory usage\ncat /sys/fs/cgroup/memory_limited/memory.current\n# Output: bytes currently used\n\n# Check page fault statistics\ncat /sys/fs/cgroup/memory_limited/memory.stat\n# pgfault: total page faults\n# pgmajfault: major page faults (from disk)","label":"Bash","value":"bash"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Lightbulb","title":"Best Practice: Layered Defense","content":"Production systems typically combine multiple mitigation strategies. A robust configuration might use cgroups for hard limits, soft limits for flexible burst handling, priority-based scanning for QoS differentiation, and the OOM killer as an emergency backstop. This layered approach preserves global replacement's efficiency while providing isolation when needed.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"real-world-implementations","title":"Real-World Implementations","content":[{"data":{"content":"Major operating systems implement global replacement with varying degrees of sophistication. Understanding these implementations reveals how theory translates to practice.\n\n**Linux implementation:**"},"type":"text"},{"data":{"items":["**kswapd daemon**: Background thread that proactively reclaims pages when memory pressure approaches high-water marks","**Direct reclaim**: Synchronous page reclamation when allocation cannot wait for kswapd","**Multi-tier LRU**: Active/inactive lists with separate anonymous and file-backed categories","**Zone-based management**: HIGHMEM, NORMAL, DMA zones with independent pressure tracking","**Memory compaction**: Defragments physical memory for large contiguous allocations","**NUMA-aware reclamation**: Prefers reclaiming local node pages before remote ones"],"title":"Linux Global Replacement","variant":"accent"},"type":"list"},{"data":{"content":"**Windows implementation:**"},"type":"text"},{"data":{"items":["**Working Set Manager**: Trims process working sets when memory pressure increases","**Superfetch**: Proactively loads frequently used pages into available RAM","**Modified Page Writer**: Background thread that flushes dirty pages to disk","**Standby List**: Pages retained in memory after removal from working sets, enabling fast reactivation","**Memory Prioritization**: Priority-based frame allocation to protect foreground applications"],"title":"Windows Global Replacement","variant":"accent"},"type":"list"},{"data":{"icon":"Info","title":"Hybrid Approaches in Practice","content":"Both Linux and Windows technically use global replacement but augment it with per-process tracking (working sets) and constraints (cgroups/job objects). This hybrid model captures most of global replacement's efficiency benefits while providing tools for administrators to enforce isolation when required. Pure global replacement—with absolutely no per-process consideration—is rare in production systems.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":8},{"id":"summary","title":"Summary: Global Replacement","content":[{"data":{"content":"We have thoroughly explored global page replacement—a memory management strategy that treats all frames as a shared, system-wide resource."},"type":"text"},{"data":{"type":"ordered","items":["**Definition** — Global replacement selects victim pages from all frames in physical memory, regardless of owning process","**Mechanism** — A single replacement algorithm (e.g., global clock) scans all frames, potentially selecting frames from any process as victims","**Primary benefit** — Maximizes memory utilization and system throughput by directing frames to where demand exists","**Primary risk** — Enables process interference, where one process's memory hunger degrades others' performance","**Mitigation** — Modern systems use cgroups, soft limits, priority scanning, and working set guards to constrain pure global behavior","**Real-world hybrid** — Linux and Windows implement global replacement with per-process awareness, combining efficiency with isolation tools"],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**Next: Local Replacement**\n\nIn the next page, we examine the contrasting approach—local replacement—where page replacement decisions are constrained to each process's own frame allocation. We will explore how this isolation model protects processes from each other while potentially sacrificing overall system efficiency."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand global replacement in depth—from its fundamental principle of shared memory pools to implementation details, advantages, risks, and real-world mitigations. This knowledge prepares you to evaluate memory management policies and understand why modern operating systems favor global replacement with carefully designed safeguards.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":9}],"isLocked":false},{"id":"seed_36204464bd85406e636e98dbd67c8f15","title":"Local Replacement","order":1,"content":null,"isLocked":true},{"id":"seed_c63c62f7403a09964d0b6505b730f81d","title":"Process Interference","order":2,"content":null,"isLocked":true},{"id":"seed_aab9db76fa338c830b27b29c57f841f0","title":"Performance Implications","order":3,"content":null,"isLocked":true},{"id":"seed_fe24fcd1174ac4d9d0e48eafa3fa0e0f","title":"Choosing Strategy","order":4,"content":null,"isLocked":true}]}}