n प्रक्रियाओं की संख्या और मेमोरी ब्लॉक के m आकार के साथ दिया गया है और कार्य पहले फिट मेमोरी प्रबंधन एल्गोरिदम का उपयोग करके संबंधित प्रक्रिया के लिए सबसे अच्छा फिट मेमोरी ब्लॉक ढूंढना है।
फर्स्ट फिट मेमोरी मैनेजमेंट एल्गोरिथम क्या है?
कई मेमोरी पार्टिशनिंग एल्गोरिदम उपलब्ध हैं जिनका उपयोग ऑपरेटिंग सिस्टम द्वारा -
जैसी प्रक्रियाओं के लिए मेमोरी ब्लॉक आवंटित करने के लिए किया जाता है।- प्रथम फ़िट एल्गोरिथम
- अगला फ़िट एल्गोरिथम
- सर्वश्रेष्ठ फ़िट एल्गोरिथम
- सबसे खराब फिट एल्गोरिथम
- त्वरित फ़िट एल्गोरिथम
फर्स्ट फिट एल्गोरिथम सभी के बीच प्रक्रियाओं को मेमोरी ब्लॉक आवंटित करने की सबसे सरल तकनीक है। इस एल्गोरिथम में, पॉइंटर मेमोरी में सभी फ्री ब्लॉक्स का ट्रैक रखता है और आने वाली प्रक्रिया के लिए मेमोरी ब्लॉक आवंटित करने के अनुरोध को स्वीकार करता है। उसके बाद पॉइंटर प्रक्रिया के लिए सबसे बड़ा पहला फ्री ब्लॉक खोजना शुरू करता है और उस मेमोरी ब्लॉक को आने वाली प्रक्रिया में आवंटित करता है। इसमें दो पार्टिशन बनाए जाते हैं, एक होल के लिए होता है और दूसरा प्रोसेस को स्टोर करेगा।
लाभ फर्स्ट फ़िट एल्गोरिथम का उपयोग करना आने वाली प्रक्रियाओं के लिए सबसे तेज़ मेमोरी आवंटन है क्योंकि यह नई प्रक्रियाओं के लिए सबसे बड़ा फ़र्स्ट फ़िट एल्गोरिथम आवंटित करता है।
नुकसान फ़र्स्ट फ़िट एल्गोरिथम का उपयोग करने से मेमोरी की बर्बादी होती है जिससे अन्य प्रक्रियाओं के लिए मेमोरी की कमी हो जाएगी।
उदाहरण
Input-: block_size[] = {300, 50, 200, 350, 70}
process_size[] = {200, 47, 212, 426, 10}
Output-:
Process No. Process Size Block no.
1 200 1
2 47 1
3 212 4
4 426 Not Allocated
5 10 1 निम्नलिखित कार्यक्रम में प्रयुक्त दृष्टिकोण इस प्रकार है -
- ब्लॉक और प्रक्रियाओं को एक सरणी में इनपुट करें
- सभी मेमोरी ब्लॉक को फ्री में सेट करें
- जांचें कि क्या (एक प्रक्रिया का आकार) <=(मेमोरी ब्लॉक का आकार) फिर प्रक्रिया को मेमोरी ब्लॉक में आवंटित करता है
- अन्यथा अन्य ब्लॉकों को तब तक ट्रेस करते रहें जब तक (एक प्रक्रिया का आकार) <=(मेमोरी ब्लॉक का आकार) सही नहीं होगा।
एल्गोरिदम
Start
Step 1-> declare function to calculate the best fit memory block
void First_Fit(int block_size[], int total_blocks, int process_size[], int total_process)
Declare int allocation[total_process]
Call function memset(allocation, -1, sizeof(allocation))
Loop For i = 0 and i < total_process and i++
Loop for j = 0 and j < total_blocks and j++
IF block_size[j] >= process_size[i]
Set allocation[i] = j
Set block_size[j] -= process_size[i]
End
End
End
Loop For i = 0 and i < total_process and i++
IF allocation[i] != -1
Set allocation[i] + 1
End
Else
Print Not Allocated
End
End
Step 2-> In main()
Declare an array for blocks as int block_size[] = {300, 50, 200, 350, 70}
Declare an array for processes int process_size[] = {200, 47, 212, 426, 10}
Calculate total blocks int total_blocks = sizeof(block_size) / sizeof(block_size[0]
Calculate total processes int total_process = sizeof(process_size) / sizeof(process_size[0])
Call First_Fit(block_size, total_blocks, process_size, total_process)
Stop उदाहरण
#include<bits/stdc++.h>
using namespace std;
// Function to allocate memory to
// blocks as per First fit algorithm
void First_Fit(int block_size[], int total_blocks, int process_size[], int total_process) {
int allocation[total_process];
memset(allocation, -1, sizeof(allocation));
//this for loop wll pick eact process and allocate a first fit block to it
for (int i = 0; i < total_process; i++) {
for (int j = 0; j < total_blocks; j++) {
if (block_size[j] >= process_size[i]) {
allocation[i] = j;
block_size[j] -= process_size[i];
break;
}
}
}
cout << "\nProcess No.\tProcess Size\tBlock no.\n";
for (int i = 0; i < total_process; i++) {
cout << " " << i+1 << "\t\t" << process_size[i] << "\t\t";
if (allocation[i] != -1)
cout << allocation[i] + 1;
else
cout << "Not Allocated";
cout << endl;
}
}
int main() {
//create array to store block sizes
int block_size[] = {300, 50, 200, 350, 70};
//create array to store process sizes
int process_size[] = {200, 47, 212, 426, 10};
//variable total_blocks that contain total number of blocks
int total_blocks = sizeof(block_size) / sizeof(block_size[0]);
//variable total_process that contain total number of blocks
int total_process = sizeof(process_size) / sizeof(process_size[0]);
//calling the function First_fit
First_Fit(block_size, total_blocks, process_size, total_process);
return 0 ;
} आउटपुट
Process No. Process Size Block no. 1 200 1 2 47 1 3 212 4 4 426 Not Allocated 5 10 1
