Theory
ग़ायब 40 MB का रहस्य
मान लीजिए आप अपने college computer lab में बैठे हैं, एक भारी Android development project load करने की कोशिश करते हुए जिसे 40 MB निरंतर RAM चाहिए। आप system monitor जाँचते हैं, और यह साफ़ 50 MB मुफ़्त memory दिखाता है। Perfect, है ना? पर जब आप run click करते हैं, आपको एक बुरा 'Out of Memory' crash मिलता है। 50 MB मुफ़्त जगह वाला एक system एक 40 MB program समायोजित करने में कैसे विफल हो सकता है? जवाब fragmentation नामक एक छुपी memory-बर्बाद करने वाली बीमारी में है, जो operating systems को आपके code को देखने का तरीक़ा पूरी तरह बदलने पर मजबूर करती है।
Theory
Movie Theater Seating का जाल
कल्पना कीजिए आप और तीन दोस्त एक movie theater जाते हैं। ticket window executive आपको बताता है, 'हाँ, हमारे पास 4 ख़ाली seats उपलब्ध हैं!' पर जब आप अंदर जाते हैं, आप एक ख़ाली seat सामने की पंक्ति में, दो बीच में, और एक आख़िरी पंक्ति में पाते हैं। आपके group के लिए काफ़ी seats हैं, पर आप 4 के एक contiguous block के रूप में साथ नहीं बैठ सकते। यह external fragmentation है। अब एक अलग नियम की कल्पना कीजिए जहाँ theater हर व्यक्ति को एक पूरा 3-seat couch book करने को मजबूर करता है भले वे अकेले आएँ। अगर आप उस couch पर अकेले बैठते हैं, आपके block के अंदर 2 seats बर्बाद होती हैं। वह internal fragmentation है!
Theory
Fragmentation और Segmentation समझना
memory management में, memory बर्बादी दो तरीक़ों से होती है। Internal Fragmentation तब होती है जब memory fixed partitions में बँटी होती है, और एक process को उसकी ज़रूरत से थोड़ा बड़ा एक slot दिया जाता है, उस partition के अंदर बची जगह पूरी तरह बर्बाद और किसी और द्वारा अनुपयोगी छोड़ते हुए। External Fragmentation तब होती है जब variable partitions समय के साथ मुफ़्त memory के छोटे, बिखरे blocks बनाते हैं: कुल मुफ़्त memory एक नई process के लिए काफ़ी बड़ी है, पर इसे allocate नहीं किया जा सकता क्योंकि यह निरंतर नहीं है। external fragmentation ठीक करने के लिए, operating systems Segmentation इस्तेमाल करते हैं, एक non-contiguous memory allocation technique जहाँ एक program को इसकी प्राकृतिक logical units (जैसे main functions, stacks, या global variables) में बाँटा जाता है जिन्हें segments कहते हैं, उन्हें physical RAM के अलग हिस्सों में store करने की अनुमति देते हुए।
At a glance
Internal और External memory fragmentation के बीच मुख्य अंतर।
| Feature | Internal Fragmentation | External Fragmentation |
|---|---|---|
| यह कहाँ होती है | एक allocated partition block के अंदर | allocated partition blocks के बीच |
| प्राथमिक कारण | Fixed size memory partitioning | Variable size memory partitioning |
| समाधान | variable partitioning या छोटे slots इस्तेमाल करें | Compaction या non-contiguous allocation |
| Process Status | Process slot घेरती है पर एक हिस्सा बर्बाद करती है | कोई process बिखरे slots घेर नहीं सकती |
Think first
एक Classic University Exam Numerics समस्या हल करना
एक system में इस क्रम में तीन मुफ़्त memory blocks हैं: 20 KB, 50 KB, और 30 KB। दो processes आती हैं: P1 को 15 KB चाहिए और P2 को 45 KB। अगर system fixed partitioning इस्तेमाल करता है जहाँ हर process एक पूरा block लेती है, internal fragmentation calculate कीजिए। अगर एक तीसरी process P3 को 40 KB चाहिए बाद में आती है, समझाइए कि यह क्यों विफल होती है और fragmentation प्रकार का नाम बताइए।
Show the answer
कदम-दर-कदम calculate करते हैं:
1. P1 (15 KB) को पहला block (20 KB) allocate होता है। इस block के अंदर बर्बाद जगह = 20 KB - 15 KB = 5 KB। यह Internal Fragmentation है।
2. P2 (45 KB) को दूसरा block (50 KB) allocate होता है। इस block के अंदर बर्बाद जगह = 50 KB - 45 KB = 5 KB। यह भी Internal Fragmentation है।
3. अब तक कुल Internal Fragmentation = 5 KB + 5 KB = 10 KB।
4. अब, P3 (40 KB) आती है। बचा एकमात्र block तीसरा block (30 KB) है, जो बहुत छोटा है। P3 load नहीं हो सकती।
अगर हम इसके बजाय variable partitioning इस्तेमाल करते? P1 20 KB block से बिल्कुल 15 KB लेती (एक 5 KB hole छोड़ते हुए)। P2 50 KB block से बिल्कुल 45 KB लेती (एक 5 KB hole छोड़ते हुए)। तीसरा block 30 KB रहता है। system में कुल मुफ़्त जगह 5 KB + 5 KB + 30 KB = 40 KB होती। P3 को बिल्कुल 40 KB चाहिए, पर यह load नहीं हो सकती क्योंकि मुफ़्त जगह तीन अलग holes (5 KB, 5 KB, 30 KB) के रूप में बिखरी है। इस विफलता को External Fragmentation कहते हैं।
Quiz
Segmentation इस्तेमाल करते समय Operating System एक ख़ास memory address कैसे खोजता है?
- हर एक बार address 0000 से पूरी RAM scan करके
- एक जोड़ी इस्तेमाल करते हुए Segment Table देखकर: Segment Number और Offset
- पूरे program को आँख मूँदकर fixed 4 KB blocks में बदलकर
- user को physical address hex codes ख़ुद enter करने को कहकर
Show the answer
एक जोड़ी इस्तेमाल करते हुए Segment Table देखकर: Segment Number और Offset
Segmentation एक logical address इस्तेमाल करता है जिसमें एक tuple होती है: (segment number, offset)। CPU segment number को एक Segment Table में देखता है ताकि उस segment का base physical address और limit खोजे। यह फिर RAM में ठीक स्थान खोजने के लिए offset को base address में जोड़ता है, protection और flexibility सुनिश्चित करते हुए।
Think first
Segment Table Guard जाँच
मान लीजिए एक segment का base address 2000 और एक limit 150 है। क्या होता है अगर एक process उस segment के भीतर 160 के एक offset तक पहुँचने की कोशिश करे? फैलाने से पहले एक अनुमान लगाइए।
Show the answer
system तुरंत एक trap या एक segmentation fault error generate करेगा! segment limit segment के क़ानूनी आकार को दर्शाती है। क्योंकि offset (160) अनुमत limit (150) से ज़्यादा है, hardware की address-translation unit एक अवैध memory access प्रयास का पता लगाती है और दूसरे programs की रक्षा के लिए इसे तुरंत रोक देती है।
Watch out
Fragmentation Nomenclature का जाल
university exams में, external fragmentation का मतलब यह नहीं कि memory RAM के बाहर बर्बाद होती है! students अक्सर अपनी answer sheets में यह मज़ेदार ग़लती करते हैं। External का मतलब बर्बादी allocated blocks के बाहर और बीच में होती है क्योंकि holes बहुत बिखरे हैं। Internal का मतलब बर्बादी एक process को allocate किए एक ख़ास block के अंदर होती है। पूरे marks score करने के लिए इसे साफ़ रखिए।
Theory
असली दुनिया कनेक्शन: Segmentation Faults
क्या आपने कभी एक C या C++ program लिखा और कुख्यात 'Segmentation Fault (core dumped)' crash से टकराए? अब आप बिल्कुल जानते हैं कि पर्दे के पीछे क्या होता है। आपके code ने एक offset तक पहुँचने की कोशिश की जो एक segment की limit से आगे गया या एक read-only code segment में लिखने की कोशिश की। आधुनिक systems application execution के लिए ठोस security देने के लिए segmentation को paging के साथ जोड़ते हैं।
Summary
Key takeaways
- Internal fragmentation एक allocated fixed-size block के अंदर बर्बाद memory है।
- External fragmentation तब होती है जब कुल मुफ़्त जगह मौजूद है पर छोटे chunks में बिखरी है।
- Segmentation एक program को एक programmer के नज़रिए से मेल खाते logical blocks में तोड़ता है।
- हर segment की Segment Table में एक entry होती है जो इसका physical base address और limit size store करती है।
- अनधिकृत memory access रोकने के लिए offsets को segment limits के ख़िलाफ़ सख़्ती से जाँचा जाता है।
- Memory hook: Internal box के अंदर है, External blocks के बीच है, Segmentation logical structures का सम्मान करता है!