ब्लॉक आकार और प्रक्रिया आकार वाले दो सरणियों को देखते हुए; कार्य स्मृति प्रबंधन में सर्वश्रेष्ठ फ़िट एल्गोरिथम के अनुसार परिणामों को प्रिंट करना है।
सर्वश्रेष्ठ फ़िट एल्गोरिथम क्या है?
बेस्ट फिट एक मेमोरी मैनेजमेंट एल्गोरिथम है; यह सबसे छोटा मुक्त विभाजन आवंटित करने से संबंधित है जो अनुरोध करने की प्रक्रिया की आवश्यकता को पूरा करता है। इस एल्गोरिथम में हम पूरे मेमोरी ब्लॉक की तलाश करते हैं और प्रक्रिया के लिए सबसे छोटे और सबसे उपयुक्त ब्लॉक की जांच करते हैं और फिर तत्काल निकट ब्लॉक की तलाश करते हैं जिसका उपयोग पर्याप्त प्रक्रिया को पूरा करने के लिए किया जा सकता है।
इसलिए हम ब्लॉक का आकार और प्रक्रिया का आकार लेंगे और प्रक्रिया के आउटपुट को वापस कर देंगे और प्रक्रिया को कौन सा ब्लॉक आवंटित किया जाना है।
उदाहरण
Input: bsize[] = {100, 500, 200, 300, 400}
psize[] = {112, 518, 110, 526}
Output:
Process No. Process Size Block no.
1 112 3
2 518 Not Allocated
3 110 4
4 526 Not Allocated उपरोक्त समस्या को हल करने के लिए दृष्टिकोण का उपयोग किया जाएगा -
- प्रक्रिया विज्ञापन ब्लॉक आकार का इनपुट लें।
- शुरुआत में सभी मेमोरी ब्लॉक को फ्री में सेट करें।
- प्रत्येक प्रक्रिया को लें और न्यूनतम ब्लॉक आकार खोजें जो एक ब्लॉक को आवंटित किया जा सकता है जिसका अर्थ है पूरे ब्लॉक का न्यूनतम जो एक प्रक्रिया आकार से बड़ा है।
- यदि मिल जाए तो उसे वर्तमान प्रक्रिया के लिए आवंटित करें अन्यथा उस प्रक्रिया को छोड़ कर आगे की प्रक्रिया की जांच करें।
एल्गोरिदम
Start
Step 1-> In function void bestfit(int bsize[], int m, int psize[], int n)
Declare int alloc[n]
Call function memset(alloc, -1, sizeof(alloc))
Loop For i=0 and i<n and i++
Declare and Initialize bestIdx = -1
Loop For j=0 and j<m and j++
If bsize[j] >= psize[i] then,
If bestIdx == -1 then,
Set bestIdx = j
Else If bsize[bestIdx] > bsize[j] then,
Set bestIdx = j
If bestIdx != -1 then,
Set alloc[i] = bestIdx
Set bsize[bestIdx] -= psize[i]
Loop For i = 0 and i < n and i++
Print i+1, psize[i]
If alloc[i] != -1
Print alloc[i] + 1
Else
Print "Not Allocated"
Print newline
Step 2->In function int main()
Declare and initialize bsize[] = {100, 500, 200, 300, 400}
Declare and initialize psize[] = {112, 518, 110, 526}
Set m = sizeof(bsize)/sizeof(bsize[0])
Set n = sizeof(psize)/sizeof(psize[0])
Call function bestfit(bsize, m, psize, n)
Stop उदाहरण
#include <iostream>
#include <memory>
using namespace std;
// To allocate the memory to blocks as per Best fit
// algorithm
void bestfit(int bsize[], int m, int psize[], int n) {
// To store block id of the block allocated to a
// process
int alloc[n];
// Initially no block is assigned to any process
memset(alloc, -1, sizeof(alloc));
// pick each process and find suitable blocks
// according to its size ad assign to it
for (int i=0; i<n; i++) {
// Find the best fit block for current process
int bestIdx = -1;
for (int j=0; j<m; j++) {
if (bsize[j] >= psize[i]) {
if (bestIdx == -1)
bestIdx = j;
else if (bsize[bestIdx] > bsize[j])
bestIdx = j;
}
}
// If we could find a block for current process
if (bestIdx != -1) {
// allocate block j to p[i] process
alloc[i] = bestIdx;
// Reduce available memory in this block.
bsize[bestIdx] -= psize[i];
}
}
cout << "\nProcess No.\tProcess Size\tBlock no.\n";
for (int i = 0; i < n; i++) {
cout << " " << i+1 << "\t\t\t\t" << psize[i] << "\t\t\t\t";
if (alloc[i] != -1)
cout << alloc[i] + 1;
else
cout << "Not Allocated";
cout << endl;
}
}
// Driver code
int main() {
int bsize[] = {100, 500, 200, 300, 400};
int psize[] = {112, 518, 110, 526};
int m = sizeof(bsize)/sizeof(bsize[0]);
int n = sizeof(psize)/sizeof(psize[0]);
bestfit(bsize, m, psize, n);
return 0 ;
} आउटपुट
Process No. Process Size Block no. 1 112 3 2 518 Not Allocated 3 110 4 4 526 Not Allocated