2. First Fit

First-Fit Allocation

Operating System (OS) में memory management एक important function है जो memory resources का efficient allocation और utilization सुनिश्चित करता है। जब processes start होते हैं, तो उन्हें execution के लिए memory blocks allocate किए जाते हैं।

👉 OS इन processes को memory देने के लिए कुछ memory allocation algorithms use करता है।

Main Algorithms (मुख्य एल्गोरिदम):

ये सभी Contiguous Memory Allocation techniques हैं:

  1. First Fit
  2. Best Fit
  3. Worst Fit
  4. Next Fit

First-Fit Memory Allocation (फर्स्ट फिट मेमोरी एलोकेशन)

Definition (परिभाषा):
First Fit method में OS memory blocks को शुरुआत (start) से check करता है और पहला ऐसा block choose करता है जो process को fit कर सके।

Working (कार्य करने का तरीका):

  • किसी भी process Pn के लिए OS available memory blocks को check करता है
  • जो पहला free block process के size के बराबर या उससे बड़ा होता है, उसे allocate कर देता है
  • बाकी blocks check नहीं किए जाते

Simple Meaning (आसान भाषा में):

First Fit मतलब — पहली suitable जगह मिलते ही memory दे दो

Advantages (फायदे):

  • Fast और simple algorithm
  • Implementation आसान

Disadvantages (नुकसान):

  • Memory fragmentation हो सकता है
  • कभी-कभी space properly utilize नहीं होता

6_096mdsbhfjdsnj

First-Fit Memory Allocation Algorithm (फर्स्ट फिट एल्गोरिदम)

Steps (स्टेप्स):

  1. Process list के पहले process से शुरू करें
  2. हर process Pn के लिए:
    • Step 1: Memory blocks को शुरुआत (first block) से search करें
    • Step 2: Check करें कि block free है और उसका size ≥ process size है
    • Step 3: अगर suitable block मिल जाए → उसे allocate करें और block को occupied mark करें
    • Step 4: अगर कोई block नहीं मिलता → process को unallocated / waiting mark करें
  3. यही steps सभी processes के लिए repeat करें

Pseudocode (सरल कोड):

 
FirstFit(memory_blocks[], processes[]):
for each process Pn in processes:
for each memory block B in memory_blocks:
if B is free and B.size >= Pn.size:
Allocate B to Pn
Mark B as occupied
Break
if no block found:
Mark Pn as unallocated
 

Advantages (फायदे):

  • Simple और easy to implement
  • Fast allocation (पहले ही block में मिल जाता है)
  • Small और similar size processes के लिए अच्छा

Disadvantages (नुकसान):

  • External Fragmentation → memory छोटे-छोटे parts में बंट जाती है
  • Internal Fragmentation → extra memory waste हो सकती है
  • हमेशा best allocation नहीं देता
  • Large processes के लिए slow हो सकता है (कई blocks search करने पड़ते हैं)