Scribd Logo
Upload

Welcome to Scribd!

  • 24 views

    OS Mem Alloc

    Uploaded by

    Pewdiepie Felix
    The program allocates memory blocks of different sizes to processes. It defines structs to represent memory blocks and processes, with pointers to link them together. It initializes an array of memory block sizes and creates linked lists of blocks and processes. The main menu function gets process sizes from the user, then calls allocation functions like first fit, best fit, or worst fit to assign blocks. It sorts the block list in ascending or descending order before allocating. The allocation function iterates through processes and blocks to find a block large enough for each process.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    OS Mem Alloc

    Uploaded by

    Pewdiepie Felix
    24 views6 pages
    The program allocates memory blocks of different sizes to processes. It defines structs to represent memory blocks and processes, with pointers to link them together. It initializes an array of memory block sizes and creates linked lists of blocks and processes. The main menu function gets process sizes from the user, then calls allocation functions like first fit, best fit, or worst fit to assign blocks. It sorts the block list in ascending or descending order before allocating. The allocation function iterates through processes and blocks to find a block large enough for each process.

    Original Title

    OS_Mem_Alloc

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The program allocates memory blocks of different sizes to processes. It defines structs to represent memory blocks and processes, with pointers to link them together. It initializes an array of memory block sizes and creates linked lists of blocks and processes. The main menu function gets process sizes from the user, then calls allocation functions like first fit, best fit, or worst fit to assign blocks. It sorts the block list in ascending or descending order before allocating. The allocation function iterates through processes and blocks to find a block large enough for each process.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    24 views6 pages

    OS Mem Alloc

    Uploaded by

    Pewdiepie Felix
    The program allocates memory blocks of different sizes to processes. It defines structs to represent memory blocks and processes, with pointers to link them together. It initializes an array of memory block sizes and creates linked lists of blocks and processes. The main menu function gets process sizes from the user, then calls allocation functions like first fit, best fit, or worst fit to assign blocks. It sorts the block list in ascending or descending order before allocating. The allocation function iterates through processes and blocks to find a block large enough for each process.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 6

    Program

    #include<stdio.h>
    #include<stdlib.h>

    struct mem
    {
    int block_no;
    int size;
    struct process *occ_proc;
    struct mem *next;
    }*start = NULL;

    struct process
    {
    int proc_no;
    struct mem *block;
    int proc_size;
    struct process *next;
    }*p_start = NULL;

    int i;
    typedef struct process process;
    typedef struct mem mem;

    void Display();
    void Menu();
    void Allocate();
    void Sort(int);
    void Swap(mem*, mem*);

    int main()
    {
    int block_size[] = {100, 500, 200, 300, 600};

    int block_length = sizeof(block_size)/sizeof(int);


    mem *prev = NULL;
    for(i = 0; i < block_length; ++i)
    {
    mem *m = (mem*)malloc(sizeof(mem));
    if(i == 0) start = m;
    m->size = block_size[i];
    m->occ_proc = NULL;

    m->block_no = i + 1;
    if(start != m)
    prev->next = m;
    prev = m;
    }
    prev->next = NULL;

    Menu();

    return 0;
    }

    void Display()
    {
    process *temp = p_start;
    printf("\nProcess No\t\tProcess size\t\tBlock No\t\tRemaining
    space\n");
    while(temp)
    {

    printf("%d\t\t\t%d\t\t\t", temp->proc_no, temp->proc_size);

    if(!temp->block)
    printf("Unallocated\n");
    else
    printf("%d\t\t\t%d\n", temp->block->block_no, temp->block-
    >size);

    temp = temp->next;
    }

    void Menu()
    {
    char choice;
    int n;
    int occupied_block[10];
    do
    {

    printf("\n******************************\nInput number of
    processes : ");
    scanf("%d", &n);
    process *prevp = NULL;
    for(i = 0; i < n ; ++i)
    {
    printf("\nInput process size for P%d : ", i + 1);
    int s;

    process *p = (process*)malloc(sizeof(process));
    if(i == 0)
    p_start = p;

    scanf("%d",&p->proc_size);

    p->block = NULL;
    p->proc_no = i + 1;
    if(p_start != p)
    prevp->next = p;
    prevp = p;
    }
    prevp->next = NULL;
    printf("\nSelect option : \n1. First fit\n2. Best fit\n3.
    Worst fit\n4. Exit\n");
    scanf(" %c", &choice);

    switch(choice)
    {
    case '2':
    Sort(1);
    break;
    case '3':
    Sort(0);
    break;
    case '4':
    return;
    }

    Allocate();
    Display();
    }while(1);

    void Allocate()
    {
    process *temp1 = p_start;
    mem *temp2;
    while(temp1)
    {
    temp2 = start;
    while(temp2)
    {
    if(temp2->size >= temp1->proc_size && !temp2->occ_proc)
    {
    temp2->size -= temp1->proc_size;
    temp2->occ_proc = temp1;
    temp1->block = temp2;
    break;
    }
    temp2 = temp2->next;
    }
    temp1 = temp1->next;
    }
    }

    void Swap(mem *m1, mem *m2)


    {
    int blockno_temp = m1->block_no;
    m1->block_no = m2->block_no;
    m2->block_no = blockno_temp;

    int size_temp = m1->size;


    m1->size = m2->size;
    m2->size = size_temp;

    process *temp_occ = m1->occ_proc;


    m1->occ_proc = m2->occ_proc;
    m2->occ_proc = temp_occ;

    }
    void Sort(int asc)
    {
    mem *m_temp1 = start;
    mem *min_block = NULL;

    while(m_temp1->next)
    {
    min_block = m_temp1;

    mem *m_temp2 = m_temp1->next;


    while(m_temp2)
    {
    if((m_temp2->size <= min_block->size) == (asc == 1))
    min_block = m_temp2;

    m_temp2 = m_temp2->next;
    }

    Swap(min_block, m_temp1);
    m_temp1 = m_temp1->next;
    }
    }

    You might also like