From 86ff7c0f353e64c5b40f89ccdfd1361fc4017f7f Mon Sep 17 00:00:00 2001 From: sherlock Date: Fri, 4 Apr 2025 08:57:29 +0530 Subject: [PATCH] added optimised OS codes --- OS/C/Week10/aq1 | Bin 0 -> 33584 bytes OS/C/Week10/aq1.c | 50 +++++++++ OS/C/Week10/aq2 | Bin 0 -> 33552 bytes OS/C/Week10/aq2.c | 78 +++++++++++++ OS/C/Week10/q1.c | 198 +++++++++++++++++++++++++++++++++ OS/C/Week10/q2.c | 0 OS/C/Week9/aq1 | Bin 0 -> 50432 bytes OS/C/Week9/aq1.c | 125 +++++++++++++++++++++ OS/C/Week9/q1.c | 272 ++++++++++++++++++++++++++++++++++++++++++++++ 9 files changed, 723 insertions(+) create mode 100755 OS/C/Week10/aq1 create mode 100644 OS/C/Week10/aq1.c create mode 100755 OS/C/Week10/aq2 create mode 100644 OS/C/Week10/aq2.c create mode 100644 OS/C/Week10/q1.c create mode 100644 OS/C/Week10/q2.c create mode 100755 OS/C/Week9/aq1 create mode 100644 OS/C/Week9/aq1.c create mode 100644 OS/C/Week9/q1.c diff --git a/OS/C/Week10/aq1 b/OS/C/Week10/aq1 new file mode 100755 index 0000000000000000000000000000000000000000..299cf2306608dc5e25a765f8c8632981b97fd079 GIT binary patch literal 33584 zcmeI5Yiv|S6vxl)w)7#Tg*FtZv>OPd5YvKStVrs@LQBJ=O{uYhcq#3c7W$ArkP70G zwF#gfx=CaF0>v2cZUsY#k*(3R%?2?%Vk(Im5)3g>w+2iwQBx4=|IEE@ZtV-8v8kjfx2G0x~z0;x0>%7Ya>gKftdv%siN!6o;}T$f-2JA^{33u)bb=0)_Gqe zC7Qe=Z8UVfskvoa(}*e3-@0c^f6J{AtlRy?S^mIK6(8+Km03<$kMv=6sfy3xZHTU~T2Z<}cNcBgXr6}4 zN&?iXMAQx#S@^7yA-cZ3!FCK2`pd#tRb1wLOQT6>SVyEx9G97A>k2olUA?MsI7hq@ zaY5&@h=W1lcvSuTTW$bZ6$Or=@5>i<&%&1pFjRY_32xu&OLi_ zZNlTQIUyQ^C0m`aqy};6$7nj)(?mvcox0^w-S&9%40zyCt2mv7=1cZPP z5CTF#2nYcoAOwVf5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP z5CTF#2nYcoAOwVf5D)@FKnVOz0z)CK|L)#NfxAA<-xJCVVtP9{^Zc7N>KJg4-CS%ziHB5#R-wU=s?s{F6X^FIwAJ&w#E&oLZ&FyPjMaa#P&@LBlMEMM>+ zaC8Ra;^W`oSUFBLzbwzc81skc#>LQ71HOJ98cI|Bm3jX8?BAUc>PRn-aA` zE1XmQXUydTb46@NN)^Yf?jD`Y(k8Pv!oA54pG{9$yw;iKk|=r_P+dg zoB2OHJ~Gce56E-Gga1C)U_94&mT+gdga1d_$FYzeyt_9)fd5#3uS5R|_hL^cN4W+m zD${IFvb7Uz?J2hQG_#%W+^~%1RnDuVl8xM;{KEVq%3n6GGJ%SUOVu6VNAbXMvDbXJ zm+$_%P_yv;bS^ISJNm=-hbO~Jvht+t(WAY|UhD@Y*~|X8Hm_GFd#yoUWtJZyAOwVf z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTHrKO^9T=VC}T zguiuez6$^i6x&Mz)VIVxKCDsiM5T${eWaG>u#QA_50pZ$eA2tJXbxJQXd?9=+OAUg>G1 z_`33%dP>B*4={iW4^Ptg%j8%SG98kH2EQADb$(|8YHq4B2fucmzpHN7`8(`(oxi1S z*Uj)uKFkaxtdPgroTQHvJ}@Bszk=lUx08FZa=W=ae(~N3*s#2|kD_ooQEJ&2U@ud> zM0i!jfn&}n_33%b^q?xH*6P*DcP%F4xBRYm)|cp)_q%onoQW4M{r+xh^p)1y({JUp z9KV>6aO$;_XUZBr8>s4y{<^<^XH-#H%+S6M_r20~_0u=j9D3}%hxNyJeeW+S=svvV z`>^ZewZ`$bhG*o_l}Oldw0@04i&b|Je+$rySMMeH{X4* z{6ycE<%Mkz^Z!r#x3@a3ojTf=JN;bWoc!p5t--muKi(<28k*65`J?0`D^vaiMcXNU literal 0 HcmV?d00001 diff --git a/OS/C/Week10/aq1.c b/OS/C/Week10/aq1.c new file mode 100644 index 0000000..21da790 --- /dev/null +++ b/OS/C/Week10/aq1.c @@ -0,0 +1,50 @@ +#include +#include + +// Page Replacement: FIFO & Optimal (Minimal Code for Paper) +int main() { + int nf, np, i, j, k, pf, hit, idx, max_f, vic; // nf=frames, np=pages, pf=faults, idx=fifo_idx, max_f=max_future, vic=victim + int *rs, *f; // rs=ref_string, f=frames + + printf("F N:"); scanf("%d%d", &nf, &np); // Frames, NumPages + rs = malloc(np * sizeof(int)); + f = malloc(nf * sizeof(int)); + if(!rs || !f) return 1; // Basic alloc check + printf("RS:"); for(i=0; imax_f) {max_f=fut; vic=k;} // f[k] used later than current max? Update victim. + } + f[vic]=rs[i]; // Replace victim frame + } + } + } + printf("F:%d\n", pf); // Print Faults + + free(rs); free(f); // Free memory + return 0; +} diff --git a/OS/C/Week10/aq2 b/OS/C/Week10/aq2 new file mode 100755 index 0000000000000000000000000000000000000000..e47ee896210fc38efb492ab632d6d91069b5bc6a GIT binary patch literal 33552 zcmeI5ZETZO6vuDdZFI0VU@{zT6mdGhfPjgBV;0KBP-K&LAKeS-S7v7N~CNFg@b|4t!X8g{kjbg)vZ~VIwO&+xL}i{_Lt&O z=SQ^)ajy^&ijQ^~e`2X&M_|w%5}TROBy5Ud*)AcRD5pT(P_xijQgfW>{WGO6OuxcPO~1JKCFK`H>$w=VqaGmqDqIau8xI{*5dXu^^tN-cZ=zv2gW5#1&{( zgT$RE$p1h@&x_6}*~E*a0!nrSdH3rNfC(@GCcp%k z025#WOn?b60Vco%m;e)C0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k z025#WOn?b60VeQ2Auv8<8NRwbFL5<$i46|TP7V%LBnP7vNrcxgep?xPUx@vqHWAb2 zis5RD7}J)b%oSs*zq&Sd3jJC%o)njMe0dV}@5?a8um{MV4%?;opCG%~m|IgDI}Ur$ zHam$ch^3lMCKE21v|IAGjl3H#|HvZlqxO+v=UBoPPyTGnKlWg*n0gH3?fLn8DJF_X z#o?)q9fGf4$H&Vu{6#1HwHf|K%ba7!;Lk21)2e&tr`NW_w+7$8XZtY4WG~E&$=(}C zYSBvNOLJ9%U8U}CXiG9-TD!q&%){D=p~Fd!tH?VJ&0tQn8u)XnH!8yq|8@}2Y?!)6;I>+*b>3V;m`_4m2Wcr zyCZIK8&x3YlJ54>-Crk4Qo5f`;#9vAKXiY%0A5OzC)IAc)?5-H|G3#3A%9fTct}M3 z@(&YW0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k025#WOn?b60Vco% zm;e)C0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k025#WOn?b60VeRD z6L4S!H}nZ8Jqn<|1%L{~^hkjEmbl)ke^*>M@!Etl)uPX{-~j;(K7MYggf2v%Yz_MT zLUwrD+q+tXd@>m547UmyYVmfq(o~BS)2O6}2W;ZK9@Jz*476jgcO|hBL=lh@DApbb>>6*5W7r(Z9bCKH@{QStE`|Qc%7hn3Kt0sOk r|Npk%_2I)+v$h@Hq22XUuj9Gqedo`tbYHk*s=a*Afqi0c!_mJ1XHj7o literal 0 HcmV?d00001 diff --git a/OS/C/Week10/aq2.c b/OS/C/Week10/aq2.c new file mode 100644 index 0000000..a5dadf7 --- /dev/null +++ b/OS/C/Week10/aq2.c @@ -0,0 +1,78 @@ +#include +#include // For malloc, free + +// C program for LRU Page Replacement Simulation +// Optimized for minimal code size (e.g., for writing on paper) + +int main() { + int nf, np, i, j, pg, idx, lru, pf = 0, time = 0, min_t; + // nf=num frames, np=num pages, pf=page faults, time=logical clock + // idx=found index, lru=least recently used index, pg=current page + + // Input frame count (nf) and page reference string length (np) + printf("Frames Pages:"); scanf("%d%d", &nf, &np); + + // Dynamic Allocation + int *f = malloc(nf * sizeof(int)); // f: frames array + int *c = malloc(nf * sizeof(int)); // c: counter/lru time array + int *p = malloc(np * sizeof(int)); // p: page reference string array + + // Input page reference string + printf("Pages:"); + for(i=0; i +#include +#include // For INT_MAX in optimal + +// Function to check if a page is present in frames +int isPresent(int page, int *frames, int num_frames) { + for (int i = 0; i < num_frames; i++) { + if (frames[i] == page) { + return 1; // Present + } + } + return 0; // Not present +} + +// Function to print the current state of frames (for debugging/visualization) +void printFrames(int *frames, int num_frames) { + printf("Frames: "); + for (int i = 0; i < num_frames; i++) { + if (frames[i] == -1) { + printf("[ ] "); + } else { + printf("[%d] ", frames[i]); + } + } + printf("\n"); +} + +// FIFO Page Replacement Simulation +int simulateFIFO(int *ref_string, int num_refs, int num_frames) { + int *frames = (int *)malloc(num_frames * sizeof(int)); + if (frames == NULL) { + perror("Failed to allocate memory for frames"); + exit(EXIT_FAILURE); + } + for (int i = 0; i < num_frames; i++) { + frames[i] = -1; // Initialize frames as empty (-1 indicates empty) + } + + int page_faults = 0; + int frame_index = 0; // Points to the next frame to be replaced (FIFO queue head) + + printf("\n--- FIFO Simulation ---\n"); + for (int i = 0; i < num_refs; i++) { + int current_page = ref_string[i]; + printf("Ref: %d -> ", current_page); + + if (!isPresent(current_page, frames, num_frames)) { + page_faults++; + frames[frame_index] = current_page; + frame_index = (frame_index + 1) % num_frames; // Move to next frame in circular fashion + printf("Fault! "); + printFrames(frames, num_frames); + } else { + printf("Hit. "); + printFrames(frames, num_frames); + } + } + + free(frames); + return page_faults; +} + +// Function to find the optimal page to replace +int findOptimalVictim(int *frames, int num_frames, int *ref_string, int num_refs, int current_index) { + int victim_frame = -1; + int farthest_use = -1; // Index of the farthest future use + + for (int i = 0; i < num_frames; i++) { + int page_in_frame = frames[i]; + int next_use = INT_MAX; // Assume page is never used again initially + + // Look for the next occurrence of this page in the reference string + for (int j = current_index + 1; j < num_refs; j++) { + if (ref_string[j] == page_in_frame) { + next_use = j; + break; // Found the *next* use + } + } + + // If this page is never used again, it's the best victim + if (next_use == INT_MAX) { + return i; // Return the index of the frame holding this page + } + + // Otherwise, track the page whose next use is farthest away + if (next_use > farthest_use) { + farthest_use = next_use; + victim_frame = i; // This frame holds the current best candidate for victim + } + } + // Should always find a victim if frames are full, defaults to first if logic error/all used soon + return (victim_frame == -1) ? 0 : victim_frame; +} + + +// Optimal Page Replacement Simulation +int simulateOptimal(int *ref_string, int num_refs, int num_frames) { + int *frames = (int *)malloc(num_frames * sizeof(int)); + if (frames == NULL) { + perror("Failed to allocate memory for frames"); + exit(EXIT_FAILURE); + } + for (int i = 0; i < num_frames; i++) { + frames[i] = -1; // Initialize frames as empty + } + + int page_faults = 0; + int current_frame_count = 0; + + printf("\n--- Optimal Simulation ---\n"); + for (int i = 0; i < num_refs; i++) { + int current_page = ref_string[i]; + printf("Ref: %d -> ", current_page); + + if (!isPresent(current_page, frames, num_frames)) { + page_faults++; + printf("Fault! "); + + // Check if there are empty frames first + if (current_frame_count < num_frames) { + frames[current_frame_count] = current_page; + current_frame_count++; + } else { + // Frames are full, need to find the optimal victim + int victim_index = findOptimalVictim(frames, num_frames, ref_string, num_refs, i); + frames[victim_index] = current_page; // Replace victim + } + printFrames(frames, num_frames); + } else { + printf("Hit. "); + printFrames(frames, num_frames); + } + } + + free(frames); + return page_faults; +} + + +int main() { + int num_frames; + int num_refs; + int *ref_string; + + // Get number of frames + printf("Enter the number of page frames: "); + scanf("%d", &num_frames); + if (num_frames <= 0) { + printf("Number of frames must be positive.\n"); + return 1; + } + + // Get number of page references + printf("Enter the number of page references in the sequence: "); + scanf("%d", &num_refs); + if (num_refs <= 0) { + printf("Number of references must be positive.\n"); + return 1; + } + + // Allocate memory for reference string + ref_string = (int *)malloc(num_refs * sizeof(int)); + if (ref_string == NULL) { + perror("Failed to allocate memory for reference string"); + return 1; + } + + // Get the reference string + printf("Enter the page reference sequence (e.g., 7 0 1 2 0 ...):\n"); + for (int i = 0; i < num_refs; i++) { + if (scanf("%d", &ref_string[i]) != 1) { + printf("Invalid input for reference sequence.\n"); + free(ref_string); + return 1; + } + if (ref_string[i] < 0) { + printf("Page numbers cannot be negative.\n"); + free(ref_string); + return 1; + } + } + + // --- Run Simulations --- + int fifo_faults = simulateFIFO(ref_string, num_refs, num_frames); + int optimal_faults = simulateOptimal(ref_string, num_refs, num_frames); + + // --- Print Results --- + printf("\n--- Results ---\n"); + printf("Reference String Length: %d\n", num_refs); + printf("Number of Frames: %d\n", num_frames); + printf("FIFO Page Faults: %d\n", fifo_faults); + printf("Optimal Page Faults: %d\n", optimal_faults); + + // --- Cleanup --- + free(ref_string); + + return 0; +} diff --git a/OS/C/Week10/q2.c b/OS/C/Week10/q2.c new file mode 100644 index 0000000..e69de29 diff --git a/OS/C/Week9/aq1 b/OS/C/Week9/aq1 new file mode 100755 index 0000000000000000000000000000000000000000..a1dd58143a1290059b15597040b22b1ddbb556f3 GIT binary patch literal 50432 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 literal 0 HcmV?d00001 diff --git a/OS/C/Week9/aq1.c b/OS/C/Week9/aq1.c new file mode 100644 index 0000000..e7235d9 --- /dev/null +++ b/OS/C/Week9/aq1.c @@ -0,0 +1,125 @@ +#include +#include + +// Dynamic Storage Allocation: First Fit & Best Fit +// Optimized for minimal code size (e.g., for writing on paper) + +// Block structure: s=start, z=size, p=process_id (0 if free) +struct B {int s, z, p;} *b; +int nb = 0, cap = 4, mem_sz; // num_blocks, capacity, total_memory_size + +// insb: insert block at index idx, maintain order by start address 's' +void insb(int idx, int s, int z, int p) { + if (nb >= cap) { + cap *= 2; + b = realloc(b, cap * sizeof(struct B)); + // Note: Real-world code checks realloc failure. Skipped for brevity. + } + for (int k = nb; k > idx; k--) b[k] = b[k-1]; // Shift right + b[idx] = (struct B){s, z, p}; + nb++; +} + +// rmb: remove block at index idx +void rmb(int idx) { + for (int k = idx; k < nb - 1; k++) b[k] = b[k+1]; // Shift left + nb--; +} + +// pb: print current blocks state +void pb() { + printf("Mem:["); + // Print each block: start:size! (allocated) or start:size (free) + for(int i=0; i= sz) { f = i; break; } + } + if (f != -1) { // Block found + if (b[f].z > sz) { // Need to split block + // Insert new free block for the remainder after the allocated part + insb(f + 1, b[f].s + sz, b[f].z - sz, 0); + b[f].z = sz; // Adjust size of the now-allocated block + } + b[f].p = pid; // Mark block as allocated to pid + printf("FF OK P%d->%d@%d\n", pid, sz, b[f].s); + } else printf("FF Fail P%d(%d)\n", pid, sz); // Allocation failed + pb(); // Show memory state +} + +// bf: Best Fit allocation +void bf(int pid, int sz) { + int bi = -1, min_z = mem_sz + 1; // best_index, min_suitable_size + for (int i = 0; i < nb; i++) { // Find smallest free block large enough + if (!b[i].p && b[i].z >= sz && b[i].z < min_z) { + min_z = b[i].z; // Update best size found + bi = i; // Update best index found + } + } + if (bi != -1) { // Best fit block found + if (b[bi].z > sz) { // Need to split block + // Insert new free block for the remainder + insb(bi + 1, b[bi].s + sz, b[bi].z - sz, 0); + b[bi].z = sz; // Adjust size of the allocated block + } + b[bi].p = pid; // Mark block allocated + printf("BF OK P%d->%d@%d\n", pid, sz, b[bi].s); + } else printf("BF Fail P%d(%d)\n", pid, sz); // Allocation failed + pb(); // Show memory state +} + +// de: Deallocate block associated with pid +void de(int pid) { + int f = -1; // found index + for (int i = 0; i < nb; i++) if (b[i].p == pid) { f = i; break; } // Find block by pid + + if (f != -1) { // Block found + printf("De OK P%d@%d(%d)\n", pid, b[f].s, b[f].z); + b[f].p = 0; // Mark block as free + + // Try merging with the *next* block if it exists and is free + if (f + 1 < nb && !b[f+1].p) { + b[f].z += b[f+1].z; // Absorb next block's size + rmb(f + 1); // Remove the next block entry + } + // Try merging with the *previous* block if it exists and is free + if (f > 0 && !b[f-1].p) { + b[f-1].z += b[f].z; // Add current block's size to previous + rmb(f); // Remove the current block entry (now merged) + // f = f-1; // If index 'f' were needed after merge, adjust it + } + pb(); // Show memory state + } else printf("De Fail P%d\n", pid); // Deallocation failed (pid not found) +} + +// Main driver loop +int main() { + printf("MemSz:"); scanf("%d", &mem_sz); // Get total memory size + b = malloc(cap * sizeof(struct B)); // Allocate initial block array + if (!b) return 1; // Handle malloc failure + b[0] = (struct B){0, mem_sz, 0}; // Create the first block (all memory, free) + nb = 1; + pb(); // Show initial state + + int choice, pid, sz; + printf("1:FF 2:BF 3:Dealloc 0:Exit\n"); + // Loop until user enters 0 + while(scanf("%d", &choice) == 1 && choice) { + if (choice == 1 || choice == 2) { // Allocate request + printf("PID Sz:"); scanf("%d%d", &pid, &sz); + if (choice == 1) ff(pid, sz); else bf(pid, sz); + } else if (choice == 3) { // Deallocate request + printf("PID:"); scanf("%d", &pid); + de(pid); + } else printf("?\n"); // Invalid choice + printf("1:FF 2:BF 3:Dealloc 0:Exit\n"); // Prompt again + } + + free(b); // Free the block array memory + return 0; +} diff --git a/OS/C/Week9/q1.c b/OS/C/Week9/q1.c new file mode 100644 index 0000000..cb48a66 --- /dev/null +++ b/OS/C/Week9/q1.c @@ -0,0 +1,272 @@ +#include +#include +#include // For INT_MAX + +// Structure for a memory block +typedef struct Block { + int id; // Block ID (optional, can use address for uniqueness) + int size; // Size of the block + int allocated; // 0 if free, 1 if allocated + int process_id; // ID of process allocated to this block (-1 if free) + struct Block *next; // Pointer to the next block in the list + struct Block *prev; // Pointer to the previous block in the list (for potential merging) +} Block; + +// Global head of the memory block linked list +Block *memory_head = NULL; + +// Function to create a new block node +Block* create_block(int id, int size, int allocated, int process_id) { + Block *new_block = (Block*)malloc(sizeof(Block)); + if (!new_block) { + perror("Failed to allocate memory for block"); + exit(EXIT_FAILURE); + } + new_block->id = id; + new_block->size = size; + new_block->allocated = allocated; + new_block->process_id = process_id; + new_block->next = NULL; + new_block->prev = NULL; + return new_block; +} + +// Function to initialize the memory list with one large free block +void initialize_memory(int total_size) { + if (memory_head != NULL) { + // Simple cleanup for re-initialization (more robust needed for general use) + Block *current = memory_head; + Block *next_node; + while(current != NULL) { + next_node = current->next; + free(current); + current = next_node; + } + memory_head = NULL; // Reset head + } + memory_head = create_block(0, total_size, 0, -1); // ID 0, size, free, no process +} + +// Function to display the current state of memory blocks +void display_memory() { + Block *current = memory_head; + printf("Memory Blocks:\n"); + printf("----------------------------------------------------\n"); + printf("| ID | Size | Status | Process ID |\n"); + printf("----------------------------------------------------\n"); + while (current != NULL) { + printf("| %-2d | %-9d | %-9s | %-10d |\n", + current->id, + current->size, + current->allocated ? "Allocated" : "Free", + current->allocated ? current->process_id : -1); + current = current->next; + } + printf("----------------------------------------------------\n\n"); +} + +// Function to allocate memory using First Fit strategy +int allocate_first_fit(int process_id, int required_size) { + Block *current = memory_head; + Block *best_block = NULL; + + // Find the first free block that is large enough + while (current != NULL) { + if (!current->allocated && current->size >= required_size) { + best_block = current; + break; // First fit found + } + current = current->next; + } + + // If a suitable block is found + if (best_block != NULL) { + // Check if splitting is necessary (and worthwhile, e.g., remaining > 0) + if (best_block->size > required_size) { + // Create a new block for the remaining free space + int remaining_size = best_block->size - required_size; + // For simplicity, assigning next available ID - needs better management in real system + int new_block_id = best_block->id + 1; // simplistic ID assignment + Block *new_free_block = create_block(new_block_id, remaining_size, 0, -1); + + // Update the allocated block + best_block->size = required_size; + best_block->allocated = 1; + best_block->process_id = process_id; + + // Insert the new free block into the list + new_free_block->next = best_block->next; + new_free_block->prev = best_block; + if (best_block->next != NULL) { + best_block->next->prev = new_free_block; + } + best_block->next = new_free_block; + + // Renumber subsequent block IDs (basic approach) + Block* temp = new_free_block->next; + int current_id = new_block_id + 1; + while (temp != NULL) { + temp->id = current_id++; + temp = temp->next; + } + + } else { // Exact fit or minimal leftover space (allocate the whole block) + best_block->allocated = 1; + best_block->process_id = process_id; + } + printf("Process %d allocated %d units using First Fit in Block %d.\n", process_id, required_size, best_block->id); + return 1; // Allocation successful + } else { + printf("Process %d (size %d) could not be allocated using First Fit.\n", process_id, required_size); + return 0; // Allocation failed + } +} + + +// Function to allocate memory using Best Fit strategy +int allocate_best_fit(int process_id, int required_size) { + Block *current = memory_head; + Block *best_block = NULL; + int min_waste = INT_MAX; + + // Find the smallest free block that is large enough + while (current != NULL) { + if (!current->allocated && current->size >= required_size) { + int waste = current->size - required_size; + if (waste < min_waste) { + min_waste = waste; + best_block = current; + } + } + current = current->next; + } + + // If a suitable block is found + if (best_block != NULL) { + // Check if splitting is necessary (and worthwhile, e.g., remaining > 0) + if (best_block->size > required_size) { + // Create a new block for the remaining free space + int remaining_size = best_block->size - required_size; + int new_block_id = best_block->id + 1; // simplistic ID assignment + Block *new_free_block = create_block(new_block_id, remaining_size, 0, -1); + + // Update the allocated block + best_block->size = required_size; + best_block->allocated = 1; + best_block->process_id = process_id; + + // Insert the new free block into the list + new_free_block->next = best_block->next; + new_free_block->prev = best_block; + if (best_block->next != NULL) { + best_block->next->prev = new_free_block; + } + best_block->next = new_free_block; + + // Renumber subsequent block IDs (basic approach) + Block* temp = new_free_block->next; + int current_id = new_block_id + 1; + while (temp != NULL) { + temp->id = current_id++; + temp = temp->next; + } + + } else { // Exact fit (allocate the whole block) + best_block->allocated = 1; + best_block->process_id = process_id; + } + printf("Process %d allocated %d units using Best Fit in Block %d.\n", process_id, required_size, best_block->id); + return 1; // Allocation successful + } else { + printf("Process %d (size %d) could not be allocated using Best Fit.\n", process_id, required_size); + return 0; // Allocation failed + } +} + +// Function to free all allocated memory for the linked list +void cleanup_memory() { + Block *current = memory_head; + Block *next_node; + while (current != NULL) { + next_node = current->next; + free(current); + current = next_node; + } + memory_head = NULL; +} + + +int main() { + int total_memory; + int num_processes; + int *process_sizes = NULL; // Dynamically allocated array for process sizes + int i; + + // --- Input --- + printf("Enter the total size of memory: "); + scanf("%d", &total_memory); + if (total_memory <= 0) { + printf("Invalid memory size.\n"); + return 1; + } + + printf("Enter the number of processes: "); + scanf("%d", &num_processes); + if (num_processes <= 0) { + printf("Invalid number of processes.\n"); + return 1; + } + + // Dynamically allocate array for process sizes + process_sizes = (int*)malloc(num_processes * sizeof(int)); + if (!process_sizes) { + perror("Failed to allocate memory for process sizes"); + return 1; + } + + printf("Enter the size required for each process:\n"); + for (i = 0; i < num_processes; i++) { + printf("Process %d size: ", i + 1); + scanf("%d", &process_sizes[i]); + if (process_sizes[i] <= 0) { + printf("Invalid process size. Please enter a positive value.\n"); + free(process_sizes); + return 1; + } + } + printf("\n"); + + + // --- First Fit Simulation --- + printf("--- First Fit Allocation ---\n"); + initialize_memory(total_memory); + printf("Initial Memory State:\n"); + display_memory(); + + for (i = 0; i < num_processes; i++) { + allocate_first_fit(i + 1, process_sizes[i]); // Process IDs starting from 1 + display_memory(); // Show state after each allocation attempt + } + printf("Final Memory State after First Fit:\n"); + display_memory(); + + + // --- Best Fit Simulation --- + printf("\n--- Best Fit Allocation ---\n"); + initialize_memory(total_memory); // Re-initialize memory for a fresh start + printf("Initial Memory State:\n"); + display_memory(); + + for (i = 0; i < num_processes; i++) { + allocate_best_fit(i + 1, process_sizes[i]); // Process IDs starting from 1 + display_memory(); // Show state after each allocation attempt + } + printf("Final Memory State after Best Fit:\n"); + display_memory(); + + // --- Cleanup --- + free(process_sizes); // Free the dynamically allocated process sizes array + cleanup_memory(); // Free the memory blocks linked list + + return 0; +}