Programa para el algoritmo Best Fit en la gestión de memoria utilizando la lista enlazada

Algoritmo de mejor ajuste para la gestión de memoria: la partición de memoria en la que hay una pérdida mínima en la asignación del proceso es la partición de memoria de mejor ajuste que se asigna al proceso.
Ya hemos discutido un algoritmo de mejor ajuste usando arreglos en este artículo . Sin embargo, aquí vamos a ver otro enfoque utilizando una lista enlazada donde también es posible eliminar los Nodes asignados.
Ejemplos: 
 

Input : blockSize[] = {100, 500, 200}
        processSize[] = {95, 417, 112, 426} 
Output :
Block with size 426 can't be allocated
Tag    Block ID    Size
0          0        95
1          1        417
2          2        112
After deleting node with tag id 1.
Tag    Block ID    Size
0        0         95
2        2        112
3        1        426

Enfoque: la idea es asignar una identificación de etiqueta única a cada bloque de memoria. Cada proceso de diferentes tamaños recibe una identificación de bloque, lo que significa a qué bloque de memoria pertenecen, y una identificación de etiqueta única para eliminar un proceso en particular para liberar espacio. Cree una lista gratuita de tamaños de bloque de memoria dados y una lista asignada de procesos.
Crear una lista asignada: 
cree una lista asignada de tamaños de proceso dados al encontrar el bloque de memoria más apropiado o mejor para asignar memoria. Si no se encuentra el bloque de memoria, simplemente imprímalo. De lo contrario, cree un Node y agréguelo a la lista vinculada asignada.
Borrar proceso: 
Cada proceso recibe una identificación de etiqueta única. Elimine el Node de proceso de la lista vinculada asignada para liberar espacio para otros procesos. Después de eliminar, use la identificación del bloque del Node eliminado para aumentar el tamaño del bloque de memoria en la lista libre.
A continuación se muestra la implementación del enfoque: 
 

C++

// C++ implementation of program
// for best fit algorithm for memory
// management using linked list
 
#include <bits/stdc++.h>
using namespace std;
 
// Two global counters
int g = 0, k = 0;
 
// Structure for free list
struct free {
    int tag;
    int size;
    struct free* next;
}* free_head = NULL, *prev_free = NULL;
 
// Structure for allocated list
struct alloc {
    int block_id;
    int tag;
    int size;
    struct alloc* next;
}* alloc_head = NULL, *prev_alloc = NULL;
 
// Function to create free
// list with given sizes
void create_free(int c)
{
    struct free* p = (struct free*)
        malloc(sizeof(struct free));
    p->size = c;
    p->tag = g;
    p->next = NULL;
    if (free_head == NULL)
        free_head = p;
    else
        prev_free->next = p;
    prev_free = p;
    g++;
}
 
// Function to print free list which
// prints free blocks of given sizes
void print_free()
{
    struct free* p = free_head;
    cout << "Tag\tSize\n";
    while (p != NULL) {
        cout << p->tag << "\t"
             << p->size << "\n";
        p = p->next;
    }
}
 
// Function to print allocated list which
// prints allocated blocks and their block ids
void print_alloc()
{
    struct alloc* p = alloc_head;
    cout << "Tag\tBlock ID\tSize\n";
    while (p != NULL) {
        cout << p->tag << "\t  " << p->block_id
             << "\t\t" << p->size << "\n";
        p = p->next;
    }
}
 
// Function to allocate memory to
// blocks as per Best fit algorithm
void create_alloc(int c)
{
    // create node for process of given size
    struct alloc* q = (struct alloc*)
        malloc(sizeof(struct alloc));
    q->size = c;
    q->tag = k;
    q->next = NULL;
    struct free* p = free_head;
 
    // Temporary node r of free
    // type to find the best and
    // most suitable free node to
    // allocate space
    struct free* r = (struct free*)
        malloc(sizeof(struct free));
    r->size = 99999;
 
    // Loop to find best choice
    while (p != NULL) {
        if (q->size <= p->size) {
            if (p->size < r->size)
                r = p;
        }
        p = p->next;
    }
 
    // Node found to allocate
    // space from
    if (r->size != 99999) {
        // Adding node to allocated list
        q->block_id = r->tag;
        r->size -= q->size;
        if (alloc_head == NULL)
            alloc_head = q;
        else {
            prev_alloc = alloc_head;
            while (prev_alloc->next != NULL)
                prev_alloc = prev_alloc->next;
            prev_alloc->next = q;
        }
        k++;
    }
 
    // Node with size not found
    else
        cout << "Block with size "
             << c << " can't be allocated\n";
}
 
// Function to delete node from
// allocated list to free some space
void delete_alloc(int t)
{
    // Standard delete function
    // of a linked list node
    struct alloc *p = alloc_head, *q = NULL;
 
    // First, find the node according
    while (p != NULL)
    // to given tag id
    {
        if (p->tag == t)
            break;
        q = p;
        p = p->next;
    }
    if (p == NULL)
        cout << "Tag ID doesn't exist\n";
    else if (p == alloc_head)
        alloc_head = alloc_head->next;
    else
        q->next = p->next;
    struct free* temp = free_head;
    while (temp != NULL) {
        if (temp->tag == p->block_id) {
            temp->size += p->size;
            break;
        }
        temp = temp->next;
    }
}
 
// Driver Code
int main()
{
    int blockSize[] = { 100, 500, 200 };
    int processSize[] = { 95, 417, 112, 426 };
    int m = sizeof(blockSize)
            / sizeof(blockSize[0]);
    int n = sizeof(processSize)
            / sizeof(processSize[0]);
 
    for (int i = 0; i < m; i++)
        create_free(blockSize[i]);
 
    for (int i = 0; i < n; i++)
        create_alloc(processSize[i]);
 
    print_alloc();
 
    // block of tag id 1 deleted
    // to free space for block of size 426
    delete_alloc(1);
 
    create_alloc(426);
    cout << "After deleting block"
         << " with tag id 1.\n";
    print_alloc();
}

Python3

# Python3 implementation of the First
# sit memory management algorithm
# using linked list
 
# Two global counters
g = 0; k = 0
 
# Structure for free list
class free:
    def __init__(self):
        self.tag=-1
        self.size=0
        self.next=None
free_head = None; prev_free = None
 
# Structure for allocated list
class alloc:
    def __init__(self):
        self.block_id=-1
        self.tag=-1
        self.size=0
        self.next=None
 
alloc_head = None;prev_alloc = None
 
# Function to create free
# list with given sizes
def create_free(c):
    global g,prev_free,free_head
    p = free()
    p.size = c
    p.tag = g
    p.next = None
    if free_head is None:
        free_head = p
    else:
        prev_free.next = p
    prev_free = p
    g+=1
 
 
# Function to print free list which
# prints free blocks of given sizes
def print_free():
    p = free_head
    print("Tag\tSize")
    while (p != None) :
        print("{}\t{}".format(p.tag,p.size))
        p = p.next
     
 
 
# Function to print allocated list which
# prints allocated blocks and their block ids
def print_alloc():
    p = alloc_head
    print("Tag\tBlock ID\tSize")
    while (p is not None) :
        print("{}\t{}\t{}\t".format(p.tag,p.block_id,p.size))
        p = p.next
     
 
 
# Function to allocate memory to
# blocks as per First fit algorithm
def create_alloc(c):
    global k,alloc_head
    # create node for process of given size
    q = alloc()
    q.size = c
    q.tag = k
    q.next = None
    p = free_head
 
    # Iterate to find first memory
    # block with appropriate size
    while (p != None) :
        if (q.size <= p.size):
            break
        p = p.next
     
 
    # Node found to allocate
    if (p != None) :
        # Adding node to allocated list
        q.block_id = p.tag
        p.size -= q.size
        if (alloc_head == None):
            alloc_head = q
        else :
            prev_alloc = alloc_head
            while (prev_alloc.next != None):
                prev_alloc = prev_alloc.next
            prev_alloc.next = q
         
        k+=1
     
    else: # Node found to allocate space from
        print("Block of size {} can't be allocated".format(c))
 
# Function to delete node from
# allocated list to free some space
def delete_alloc(t):
    global alloc_head
    # Standard delete function
    # of a linked list node
    p = alloc_head; q = None
 
    # First, find the node according
    # to given tag id
    while (p != None) :
        if (p.tag == t):
            break
        q = p
        p = p.next
     
    if (p == None):
        print("Tag ID doesn't exist")
    elif (p == alloc_head):
        alloc_head = alloc_head.next
    else:
        q.next = p.next
    temp = free_head
    while (temp != None) :
        if (temp.tag == p.block_id) :
            temp.size += p.size
            break
         
        temp = temp.next
     
 
 
# Driver Code
if __name__ == '__main__':
    blockSize = [100, 500, 200]
    processSize = [417, 112, 426, 95]
    m = len(blockSize)
    n = len(processSize)
 
    for i in range(m):
        create_free(blockSize[i])
 
    for i in range(n):
        create_alloc(processSize[i])
 
    print_alloc()
 
    # Block of tag id 0 deleted
    # to free space for block of size 426
    delete_alloc(0)
 
    create_alloc(426)
    print("After deleting block with tag id 0.")
    print_alloc()
Producción: 

Block with size 426 can't be allocated
Tag    Block ID    Size
0      0        95
1      1        417
2      2        112
After deleting block with tag id 1.
Tag    Block ID    Size
0      0        95
2      2        112
3      1        426

 

Publicación traducida automáticamente

Artículo escrito por sarthak_eddy y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *