aadit/MIT-Curricular
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: aadit:main
Branches Tags
aadit:main
aadit:s-branch-3
aadit:s-branch-2
aadit:s-branch-1
..
compare: aadit:s-branch-2
Branches Tags
aadit:main
aadit:s-branch-3
aadit:s-branch-2
aadit:s-branch-1

No commits in common. "main" and "s-branch-2" have entirely different histories.
main ... s-branch-2

10 changed files with 7 additions and 1186 deletions
Show stats Expand all files Collapse all files

169
OS/C/Week10/q2.c
View file

@ -1,169 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <limits.h> // For INT_MAX
// Structure to represent a frame and its last used time
typedef struct {
int page_number;
int last_used_time;
} Frame;
// Function to find if a page exists in frames and return its index
// Also updates the last_used_time if found
int find_page(Frame frames[], int n_frames, int page, int current_time) {
for (int i = 0; i < n_frames; i++) {
if (frames[i].page_number == page) {
frames[i].last_used_time = current_time; // Update time on hit
return i; // Page found (Hit)
}
}
return -1; // Page not found (Fault)
}
// Function to find the index of the Least Recently Used (LRU) page
int find_lru_index(Frame frames[], int n_frames) {
int min_time = INT_MAX;
int lru_index = 0;
for (int i = 0; i < n_frames; i++) {
// Frame must contain a valid page (not -1)
if (frames[i].page_number != -1 && frames[i].last_used_time < min_time) {
min_time = frames[i].last_used_time;
lru_index = i;
}
}
return lru_index;
}
// Function to print the current state of frames
void print_frames(Frame frames[], int n_frames) {
printf("[");
for (int i = 0; i < n_frames; i++) {
if (frames[i].page_number == -1) {
printf(" - ");
} else {
printf(" %d ", frames[i].page_number);
}
}
printf("]\n");
}
int main() {
int n_frames, n_pages;
int *pages = NULL; // Reference string
Frame *frames = NULL; // Frames in memory
int page_faults = 0;
int page_hits = 0;
int current_time = 0; // Counter to track usage time
int frame_idx = 0; // Index for filling empty frames initially
// 1. Get Inputs
printf("Enter the number of frames: ");
if (scanf("%d", &n_frames) != 1 || n_frames <= 0) {
fprintf(stderr, "Error: Invalid number of frames.\n");
return 1;
}
printf("Enter the number of pages in the reference string: ");
if (scanf("%d", &n_pages) != 1 || n_pages <= 0) {
fprintf(stderr, "Error: Invalid number of pages.\n");
return 1;
}
// 2. Allocate Memory
pages = (int *)malloc(n_pages * sizeof(int));
if (pages == NULL) {
perror("Failed to allocate memory for pages");
return 1;
}
frames = (Frame *)malloc(n_frames * sizeof(Frame));
if (frames == NULL) {
perror("Failed to allocate memory for frames");
free(pages); // Clean up already allocated memory
return 1;
}
printf("Enter the page reference string (space-separated %d integers):\n", n_pages);
for (int i = 0; i < n_pages; i++) {
if (scanf("%d", &pages[i]) != 1) {
fprintf(stderr, "Error reading page reference string.\n");
free(pages);
free(frames);
return 1;
}
}
// 3. Initialize Frames
for (int i = 0; i < n_frames; i++) {
frames[i].page_number = -1; // -1 indicates empty frame
frames[i].last_used_time = -1; // Initialize time
}
printf("\n--- LRU Simulation Start ---\n");
printf("Frames: %d | Reference String Length: %d\n\n", n_frames, n_pages);
// 4. Process Page References
for (int i = 0; i < n_pages; i++) {
current_time++; // Increment time step for each reference
int current_page = pages[i];
printf("Ref: %d -> ", current_page);
int found_index = find_page(frames, n_frames, current_page, current_time);
if (found_index != -1) {
// Page Hit
page_hits++;
printf("Hit ");
} else {
// Page Fault
page_faults++;
printf("Fault ");
// Find a place for the new page
int replace_index = -1;
// Check for an empty frame first
for(int k=0; k < n_frames; k++){
if(frames[k].page_number == -1){
replace_index = k;
break;
}
}
if (replace_index != -1) {
// Use the empty frame
frames[replace_index].page_number = current_page;
frames[replace_index].last_used_time = current_time;
printf("(loaded into empty frame %d) ", replace_index);
} else {
// No empty frames, find LRU page to replace
replace_index = find_lru_index(frames, n_frames);
printf("(replaced P%d in frame %d) ", frames[replace_index].page_number, replace_index);
frames[replace_index].page_number = current_page;
frames[replace_index].last_used_time = current_time;
}
}
print_frames(frames, n_frames); // Show frame status after each step
}
// 5. Output Results
printf("\n--- LRU Simulation End ---\n");
printf("Total Page References: %d\n", n_pages);
printf("Total Page Hits: %d\n", page_hits);
printf("Total Page Faults: %d\n", page_faults);
if (n_pages > 0) {
printf("Hit Rate: %.2f%%\n", (double)page_hits / n_pages * 100.0);
printf("Fault Rate: %.2f%%\n", (double)page_faults / n_pages * 100.0);
} else {
printf("Hit Rate: N/A\n");
printf("Fault Rate: N/A\n");
}
// 6. Free Memory
free(pages);
free(frames);
return 0;
}

176
OS/C/Week10/qq1.c
View file

@ -1,176 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
// Function to check if a page exists in frames
bool isPagePresent(int* frames, int num_frames, int page) {
for (int i = 0; i < num_frames; i++) {
if (frames[i] == page) {
return true;
}
}
return false;
}
// FIFO Page Replacement Algorithm
void fifo(int* reference_string, int num_pages, int num_frames) {
int* frames = (int*)malloc(num_frames * sizeof(int));
int page_faults = 0;
int frame_index = 0;
// Initialize frames with -1 (indicating empty)
for (int i = 0; i < num_frames; i++) {
frames[i] = -1;
}
printf("\nFIFO Page Replacement Algorithm:\n");
printf("Reference String: ");
for (int i = 0; i < num_pages; i++) {
printf("%d ", reference_string[i]);
}
printf("\n\n");
for (int i = 0; i < num_pages; i++) {
printf("Page %d: ", reference_string[i]);
// Check if page already exists in frames
if (!isPagePresent(frames, num_frames, reference_string[i])) {
// Replace page at current frame_index
frames[frame_index] = reference_string[i];
frame_index = (frame_index + 1) % num_frames;
page_faults++;
printf("Page Fault! Frames: ");
} else {
printf("No Page Fault. Frames: ");
}
// Print current state of frames
for (int j = 0; j < num_frames; j++) {
if (frames[j] == -1) {
printf("[ ] ");
} else {
printf("[%d] ", frames[j]);
}
}
printf("\n");
}
printf("\nTotal Page Faults (FIFO): %d\n", page_faults);
free(frames);
}
// Function to find index of page that will be used farthest in future
int findOptimalPage(int* reference_string, int* frames, int num_frames, int num_pages, int current_position) {
int farthest = -1;
int index = -1;
for (int i = 0; i < num_frames; i++) {
int j;
for (j = current_position + 1; j < num_pages; j++) {
if (frames[i] == reference_string[j]) {
if (j > farthest) {
farthest = j;
index = i;
}
break;
}
}
// If page is never used in future
if (j == num_pages) {
return i;
}
}
// If all pages will be used in future, return the one used farthest
return (index == -1) ? 0 : index;
}
// Optimal Page Replacement Algorithm
void optimal(int* reference_string, int num_pages, int num_frames) {
int* frames = (int*)malloc(num_frames * sizeof(int));
int page_faults = 0;
// Initialize frames with -1 (indicating empty)
for (int i = 0; i < num_frames; i++) {
frames[i] = -1;
}
printf("\nOptimal Page Replacement Algorithm:\n");
printf("Reference String: ");
for (int i = 0; i < num_pages; i++) {
printf("%d ", reference_string[i]);
}
printf("\n\n");
for (int i = 0; i < num_pages; i++) {
printf("Page %d: ", reference_string[i]);
// Check if page already exists in frames
if (!isPagePresent(frames, num_frames, reference_string[i])) {
int free_frame = -1;
// Check if there's an empty frame
for (int j = 0; j < num_frames; j++) {
if (frames[j] == -1) {
free_frame = j;
break;
}
}
if (free_frame != -1) {
// If empty frame exists, use it
frames[free_frame] = reference_string[i];
} else {
// Find optimal page to replace
int replace_index = findOptimalPage(reference_string, frames, num_frames, num_pages, i);
frames[replace_index] = reference_string[i];
}
page_faults++;
printf("Page Fault! Frames: ");
} else {
printf("No Page Fault. Frames: ");
}
// Print current state of frames
for (int j = 0; j < num_frames; j++) {
if (frames[j] == -1) {
printf("[ ] ");
} else {
printf("[%d] ", frames[j]);
}
}
printf("\n");
}
printf("\nTotal Page Faults (Optimal): %d\n", page_faults);
free(frames);
}
int main() {
int num_pages, num_frames;
printf("Enter number of frames: ");
scanf("%d", &num_frames);
printf("Enter number of pages in reference string: ");
scanf("%d", &num_pages);
int* reference_string = (int*)malloc(num_pages * sizeof(int));
printf("Enter the reference string (page numbers):\n");
for (int i = 0; i < num_pages; i++) {
scanf("%d", &reference_string[i]);
}
// Run FIFO algorithm
fifo(reference_string, num_pages, num_frames);
// Run Optimal algorithm
optimal(reference_string, num_pages, num_frames);
free(reference_string);
return 0;
}

201
OS/C/Week11/q1.c
View file

@ -1,201 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define MAX 100
// Function for SSTF (Shortest Seek Time First)
void sstf(int arr[], int n, int head) {
int visited[MAX] = {0}, total_seek = 0, current = head;
printf("\nSSTF Sequence:\n%d ", current);
for (int count = 0; count < n; count++) {
int index = -1, minDist = 1e9;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
int dist = abs(arr[i] - current);
if (dist < minDist) {
minDist = dist;
index = i;
}
}
}
visited[index] = 1;
total_seek += minDist;
current = arr[index];
printf("-> %d ", current);
}
printf("\nTotal Seek Time: %d\n", total_seek);
}
// Helper function: Bubble sort in ascending order
void sortAsc(int arr[], int n) {
for (int i = 0; i < n - 1; i++)
for (int j = i + 1; j < n; j++)
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// Helper function: Bubble sort in descending order
void sortDesc(int arr[], int
for (int i = 0; i < n - 1; i++)
for (int j = i + 1; j < n; j++)
if (arr[i] < arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// Function for SCAN (Elevator Algorithm)
// Assumes movement is towards the left first, then reverses.
void scan(int arr[], int n, int head, int disk_size) {
int left[MAX], right[MAX], l = 0, r = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < head)
left[l++] = arr[i];
else
right[r++] = arr[i];
}
sortDesc(left, l);
sortAsc(right, r);
int total_seek = 0, current = head;
printf("\nSCAN Sequence:\n%d ", current);
// Service left side (moving toward 0)
for (int i = 0; i < l; i++) {
total_seek += abs(current - left[i]);
current = left[i];
printf("-> %d ", current);
}
// If not already at 0, move to 0
if (current != 0) {
total_seek += current;
current = 0;
printf("-> %d ", current);
}
// Then service right side (moving right)
for (int i = 0; i < r; i++) {
total_seek += abs(right[i] - current);
current = right[i];
printf("-> %d ", current);
}
printf("\nTotal Seek Time: %d\n", total_seek);
}
// Function for C-SCAN (Circular SCAN)
// Assumes movement to the right; after reaching the end, the head jumps to 0.
void cscan(int arr[], int n, int head, int disk_size) {
int left[MAX], right[MAX], l = 0, r = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < head)
left[l++] = arr[i];
else
right[r++] = arr[i];
}
sortAsc(left, l);
sortAsc(right, r);
int total_seek = 0, current = head;
printf("\nC-SCAN Sequence:\n%d ", current);
// Service requests to the right
for (int i = 0; i < r; i++) {
total_seek += abs(right[i] - current);
current = right[i];
printf("-> %d ", current);
}
// Go to the end if not reached
if (current != disk_size - 1) {
total_seek += abs(disk_size - 1 - current);
current = disk_size - 1;
printf("-> %d ", current);
}
// Jump to beginning (simulate wrap-around)
total_seek += (disk_size - 1);
current = 0;
printf("-> %d ", current);
// Service the left side
for (int i = 0; i < l; i++) {
total_seek += abs(left[i] - current);
current = left[i];
printf("-> %d ", current);
}
printf("\nTotal Seek Time: %d\n", total_seek);
}
// Function for C-LOOK
// Assumes movement to the right; after the furthest request, it jumps to the smallest request.
void clook(int arr[], int n, int head) {
int left[MAX], right[MAX], l = 0, r = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < head)
left[l++] = arr[i];
else
right[r++] = arr[i];
}
sortAsc(left, l);
sortAsc(right, r);
int total_seek = 0, current = head;
printf("\nC-LOOK Sequence:\n%d ", current);
// Service the right side
for (int i = 0; i < r; i++) {
total_seek += abs(right[i] - current);
current = right[i];
printf("-> %d ", current);
}
// Jump to the leftmost request if any exist on the left
if (l > 0) {
total_seek += abs(current - left[0]);
current = left[0];
printf("-> %d ", current);
for (int i = 1; i < l; i++) {
total_seek += abs(left[i] - current);
current = left[i];
printf("-> %d ", current);
}
}
printf("\nTotal Seek Time: %d\n", total_seek);
}
int main() {
int choice, n, head, disk_size;
int arr[MAX];
printf("Menu:\n");
printf("1. SSTF\n");
printf("2. SCAN\n");
printf("3. C-SCAN\n");
printf("4. C-LOOK\n");
printf("Enter your choice: ");
scanf("%d", &choice);
printf("Enter number of requests: ");
scanf("%d", &n);
printf("Enter the request queue (space separated): ");
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
printf("Enter initial head position: ");
scanf("%d", &head);
if (ce == 2 || choice == 3) { // SCAN and C-SCAN require the disk size
printf("Enter disk size: ");
scanf("%d", &disk_size);
}
switch (choice) {
case 1:
sstf(arr, n, head);
break;
case 2:
scan(arr, n, head, disk_size);
break;
case 3:
cscan(arr, n, head, disk_size);
break;
case 4:
clook(arr, n, head);
break;
default:
printf("Invalid choice!\n");
}
return 0;
}

234
OS/C/Week11/qq1.c
View file

@ -1,234 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
void sstf(int requests[], int n, int head) {
int total_seek = 0;
int completed = 0;
int visited[100] = {0};
int current = head;
printf("\nSSTF Disk Scheduling\n");
printf("Seek Sequence: %d", head);
while (completed < n) {
int min_distance = INT_MAX;
int min_index = -1;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
int distance = abs(requests[i] - current);
if (distance < min_distance) {
min_distance = distance;
min_index = i;
}
}
}
visited[min_index] = 1;
current = requests[min_index];
total_seek += min_distance;
completed++;
printf(" -> %d", current);
}
printf("\nTotal Seek Time: %d\n", total_seek);
}
void scan(int requests[], int n, int head, int disk_size) {
int total_seek = 0;
int direction = 1; // 1 for moving right, 0 for moving left
int current = head;
printf("\nSCAN Disk Scheduling\n");
printf("Seek Sequence: %d", head);
// Sort requests
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (requests[j] > requests[j + 1]) {
int temp = requests[j];
requests[j] = requests[j + 1];
requests[j + 1] = temp;
}
}
}
// Find position of head in sorted array
int index;
for (index = 0; index < n; index++) {
if (requests[index] >= head)
break;
}
// Move right
for (int i = index; i < n; i++) {
current = requests[i];
printf(" -> %d", current);
total_seek += abs(current - head);
head = current;
}
// Move to the end of disk
printf(" -> %d", disk_size - 1);
total_seek += abs(disk_size - 1 - head);
head = disk_size - 1;
// Move left
for (int i = index - 1; i >= 0; i--) {
current = requests[i];
printf(" -> %d", current);
total_seek += abs(current - head);
head = current;
}
printf("\nTotal Seek Time: %d\n", total_seek);
}
void cscan(int requests[], int n, int head, int disk_size) {
int total_seek = 0;
int current = head;
printf("\nC-SCAN Disk Scheduling\n");
printf("Seek Sequence: %d", head);
// Sort requests
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (requests[j] > requests[j + 1]) {
int temp = requests[j];
requests[j] = requests[j + 1];
requests[j + 1] = temp;
}
}
}
// Find position of head in sorted array
int index;
for (index = 0; index < n; index++) {
if (requests[index] >= head)
break;
}
// Move right
for (int i = index; i < n; i++) {
current = requests[i];
printf(" -> %d", current);
total_seek += abs(current - head);
head = current;
}
// Move to the end of disk
printf(" -> %d", disk_size - 1);
total_seek += abs(disk_size - 1 - head);
// Move to the beginning
printf(" -> 0");
total_seek += disk_size - 1;
head = 0;
// Move right again
for (int i = 0; i < index; i++) {
current = requests[i];
printf(" -> %d", current);
total_seek += abs(current - head);
head = current;
}
printf("\nTotal Seek Time: %d\n", total_seek);
}
void clook(int requests[], int n, int head) {
int total_seek = 0;
int current = head;
printf("\nC-LOOK Disk Scheduling\n");
printf("Seek Sequence: %d", head);
// Sort requests
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (requests[j] > requests[j + 1]) {
int temp = requests[j];
requests[j] = requests[j + 1];
requests[j + 1] = temp;
}
}
}
// Find position of head in sorted array
int index;
for (index = 0; index < n; index++) {
if (requests[index] >= head)
break;
}
// Move right
for (int i = index; i < n; i++) {
current = requests[i];
printf(" -> %d", current);
total_seek += abs(current - head);
head = current;
}
// Move to first request
for (int i = 0; i < index; i++) {
current = requests[i];
printf(" -> %d", current);
total_seek += abs(current - head);
head = current;
}
printf("\nTotal Seek Time: %d\n", total_seek);
}
int main() {
int requests[100], n, head, disk_size, choice;
printf("Enter the number of disk requests: ");
scanf("%d", &n);
printf("Enter the disk requests: ");
for (int i = 0; i < n; i++) {
scanf("%d", &requests[i]);
}
printf("Enter the initial head position: ");
scanf("%d", &head);
printf("Enter the disk size (0 to size-1): ");
scanf("%d", &disk_size);
do {
printf("\n\nDisk Scheduling Algorithms\n");
printf("1. SSTF (Shortest Seek Time First)\n");
printf("2. SCAN\n");
printf("3. C-SCAN\n");
printf("4. C-LOOK\n");
printf("5. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);
switch (choice) {
case 1:
sstf(requests, n, head);
break;
case 2:
scan(requests, n, head, disk_size);
break;
case 3:
cscan(requests, n, head, disk_size);
break;
case 4:
clook(requests, n, head);
break;
case 5:
printf("Exiting program...\n");
break;
default:
printf("Invalid choice!\n");
}
} while (choice != 5);
return 0;
}

0
OS/C/Week11/test.c
View file

153
OS/C/Week12/rtos.c
View file

@ -1,153 +0,0 @@
#include <stdio.h>
// Define Task structure (simplified for memorization)
typedef struct {
int id; // Task ID
int period; // Period (also deadline for simplicity)
int execution_time; // Worst-case execution time (WCET)
// --- Simulation State ---
int remaining_execution; // Remaining execution time for current instance
int absolute_deadline; // Absolute deadline for current instance
int time_to_arrival; // Time until the next instance arrives/is released
} Task;
// --- Global Variables ---
// Define the tasks for the simulation (Example Set)
// Format: {id, Period, ExecutionTime, 0, 0, 0} <-- Initial state values
Task tasks[] = {
{1, 5, 2, 0, 0, 0}, // Task 1: Period=5, Exec Time=2
{2, 8, 3, 0, 0, 0} // Task 2: Period=8, Exec Time=3
// Add more tasks here if needed
};
// Calculate number of tasks automatically
int num_tasks = sizeof(tasks) / sizeof(Task);
// Set simulation duration (e.g., Hyperperiod or a fixed time)
// LCM(5, 8) = 40
int simulation_time = 40;
// --- Rate Monotonic (RM) Simulation ---
void simulate_rm() {
printf("--- Rate Monotonic Scheduling ---\n");
// Reset task states for the simulation run
for (int i = 0; i < num_tasks; i++) {
tasks[i].remaining_execution = 0;
tasks[i].absolute_deadline = 0;
tasks[i].time_to_arrival = 0; // All tasks start at time 0
}
// Main simulation loop
for (int time = 0; time < simulation_time; time++) {
// 1. Check for task arrivals (release time)
for (int i = 0; i < num_tasks; i++) {
if (tasks[i].time_to_arrival == 0) {
// Check if the previous instance of this task missed its deadline
if (tasks[i].remaining_execution > 0) {
printf("!!! Time %d: Task %d MISSED DEADLINE !!!\n", time, tasks[i].id);
// Simple handling: Continue with the new instance, old one is lost
}
// Release new instance of the task
tasks[i].remaining_execution = tasks[i].execution_time;
tasks[i].absolute_deadline = time + tasks[i].period; // Deadline = Period
tasks[i].time_to_arrival = tasks[i].period; // Set timer for the *next* arrival
}
tasks[i].time_to_arrival--; // Decrement time until the next arrival for all tasks
}
// 2. Select highest priority task to run (RM: Shortest Period has highest priority)
int task_to_run = -1; // -1 indicates CPU Idle
int highest_priority = 10000; // Initialize with a low priority (large period)
for (int i = 0; i < num_tasks; i++) {
// Check if task is ready (has arrived and needs execution)
if (tasks[i].remaining_execution > 0) {
// RM priority check: Lower period value means higher priority
if (tasks[i].period < highest_priority) {
highest_priority = tasks[i].period;
task_to_run = i; // Select this task
}
}
}
// 3. Execute the selected task (or remain idle)
if (task_to_run != -1) {
// Task selected to run
printf("Time %d: Task %d running\n", time, tasks[task_to_run].id);
tasks[task_to_run].remaining_execution--; // Execute for one time unit
// Optional: Check if task just finished
// if (tasks[task_to_run].remaining_execution == 0) {
// printf("Time %d: Task %d finished\n", time + 1, tasks[task_to_run].id);
// }
} else {
// No task ready to run
printf("Time %d: CPU Idle\n", time);
}
}
printf("--- RM Simulation Complete ---\n");
}
// --- Earliest Deadline First (EDF) Simulation ---
void simulate_edf() {
printf("\n--- Earliest Deadline First Scheduling ---\n");
// Reset task states
for (int i = 0; i < num_tasks; i++) {
tasks[i].remaining_execution = 0;
tasks[i].absolute_deadline = 0;
tasks[i].time_to_arrival = 0;
}
// Main simulation loop
for (int time = 0; time < simulation_time; time++) {
// 1. Check for task arrivals (same as RM)
for (int i = 0; i < num_tasks; i++) {
if (tasks[i].time_to_arrival == 0) {
if (tasks[i].remaining_execution > 0) {
printf("!!! Time %d: Task %d MISSED DEADLINE !!!\n", time, tasks[i].id);
}
tasks[i].remaining_execution = tasks[i].execution_time;
tasks[i].absolute_deadline = time + tasks[i].period;
tasks[i].time_to_arrival = tasks[i].period;
}
tasks[i].time_to_arrival--;
}
// 2. Select highest priority task to run (EDF: Earliest Absolute Deadline has highest priority)
int task_to_run = -1;
int earliest_deadline = 10000; // Initialize with a late deadline
for (int i = 0; i < num_tasks; i++) {
// Check if task is ready
if (tasks[i].remaining_execution > 0) {
// EDF priority check: Lower deadline value means higher priority (earlier deadline)
if (tasks[i].absolute_deadline < earliest_deadline) {
earliest_deadline = tasks[i].absolute_deadline;
task_to_run = i; // Select this task
}
}
}
// 3. Execute the selected task (same as RM)
if (task_to_run != -1) {
printf("Time %d: Task %d running\n", time, tasks[task_to_run].id);
tasks[task_to_run].remaining_execution--;
// Optional: Check finish
// if (tasks[task_to_run].remaining_execution == 0) {
// printf("Time %d: Task %d finished\n", time + 1, tasks[task_to_run].id);
// }
} else {
printf("Time %d: CPU Idle\n", time);
}
}
printf("--- EDF Simulation Complete ---\n");
}
// --- Main Function ---
int main() {
// Run Rate Monotonic simulation
simulate_rm();
// Run Earliest Deadline First simulation
simulate_edf();
return 0; // Indicate successful execution
}

81
OS/C/Week9/q1-smol.c
View file

@ -1,81 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#define BLOCKS 4
#define REQUESTS 5
// Memory configuration
int memory[BLOCKS] = {100, 50, 25, 10};
int allocated[BLOCKS] = {0, 0, 0, 0};
// Helper: Reset allocation state
void resetAllocation() {
for(int i = 0; i < BLOCKS; i++) {
allocated[i] = 0;
}
}
// Print memory status
void printMemory() {
printf("\nMemory Status:\n");
for(int i = 0; i < BLOCKS; i++) {
printf("[Size: %d, %s] -> ", memory[i],
allocated[i] ? "Allocated" : "Free");
}
printf("NULL\n\n");
}
// First Fit allocation
void firstFit(int size) {
for(int i = 0; i < BLOCKS; i++) {
if (!allocated[i] && memory[i] >= size) {
allocated[i] = 1;
printf("Allocated %d bytes using First Fit\n", size);
return;
}
}
printf("First Fit: No suitable block found for %d bytes\n", size);
}
// Best Fit allocation
void bestFit(int size) {
int best = -1;
int bestSize = 999999;
for(int i = 0; i < BLOCKS; i++) {
if(!allocated[i] && memory[i] >= size && memory[i] < bestSize) {
bestSize = memory[i];
best = i;
}
}
if(best != -1) {
allocated[best] = 1;
printf("Allocated %d bytes using Best Fit\n", size);
} else {
printf("Best Fit: No suitable block found for %d bytes\n", size);
}
}
// Main function: run allocation sequence
int main() {
int requests[REQUESTS] = {15, 35, 60, 10, 5};
printf("=== FIRST FIT ===\n");
printMemory();
for(int i = 0; i < REQUESTS; i++) {
firstFit(requests[i]);
printMemory();
}
resetAllocation();
printf("=== BEST FIT ===\n");
printMemory();
for(int i = 0; i < REQUESTS; i++) {
bestFit(requests[i]);
printMemory();
}
return 0;
}

12
OS/C/practice/test.sh
View file

@ -1,6 +1,8 @@
if [[ $# -lt 3 ]]; then read -p "Enter a number: " num
echo "Usage: $0 <filename1> <filename2>" if [[ $num -gt 10 ]]; then
exit 1 echo "Number is greater than 10"
elif [[ $num -eq 10 ]]; then
echo "Number is exactly 10"
else
echo "Number is less than 10"
fi fi
if

46
OS/endsem/bashq.sh
View file

@ -1,46 +0,0 @@
#!/bin/bash
# Ask for the directory
echo "Enter directory path:"
read dir
while true; do
echo ""
echo "Menu:"
echo "1. Convert .txt files to .py in $dir"
echo "2. List ownership properties (ls -l) of all files in $dir"
echo "3. Count .sh files and subdirectories in $dir"
echo "4. Exit"
echo -n "Choose an option: "
read option
case $option in
1)
for file in "$dir"/*.txt; do
if [ -f "$file" ]; then
new="${file%.txt}.py"
mv "$file" "$new"
echo "Renamed: $file -> $new"
fi
done
;;
2)
ls -l "$dir"
;;
3)
sh_count=$(ls -1 "$dir"/*.sh 2>/dev/null | wc -l)
dir_count=$(ls -d "$dir"/*/ 2>/dev/null | wc -w)
echo ".sh file count: $sh_count"
echo "Subdirectory count: $dir_count"
;;
4)
echo "Exiting..."
break
;;
*)
echo "Invalid option. Please try again."
;;
esac
done
echo "Bye!"

121
OS/endsem/cq.c
View file

@ -1,121 +0,0 @@
#include <stdio.h>
#include <pthread.h>
#include <limits.h>
#define MAX_PROC 10
#define MAX_REF 100
#define MAX_FRAMES 10
typedef struct {
int id; // Process ID
int frames; // Number of frames for this process
int n; // Number of page references
int ref[MAX_REF]; // Array of page references
int faults; // Page faults counter
} Process;
Process procs[MAX_PROC];
int proc_count = 0;
void *simulateOptimal(void *arg) {
Process *p = (Process *)arg;
int frameArr[MAX_FRAMES];
int i, j;
// Initialize frames as empty (-1)
for (i = 0; i < p->frames; i++) {
frameArr[i] = -1;
}
p->faults = 0;
// Process each page reference
for (i = 0; i < p->n; i++) {
int page = p->ref[i];
int found = 0;
// Check if page is already in a frame
for (j = 0; j < p->frames; j++) {
if (frameArr[j] == page) {
found = 1;
break;
}
}
if (found)
continue;
// Page fault occurs
p->faults++;
// Look for an empty frame (-1)
int empty = -1;
for (j = 0; j < p->frames; j++) {
if (frameArr[j] == -1) {
empty = j;
break;
}
}
if (empty != -1) {
frameArr[empty] = page;
continue;
}
// No empty frame; choose a victim using Optimal algorithm:
int replace = 0, farthest = -1;
for (j = 0; j < p->frames; j++) {
int k, nextUse = INT_MAX;
for (k = i + 1; k < p->n; k++) {
if (frameArr[j] == p->ref[k]) {
nextUse = k;
break;
}
}
if (nextUse > farthest) {
farthest = nextUse;
replace = j;
}
}
frameArr[replace] = page;
}
printf("Process %d: Faults = %d\n", p->id, p->faults);
return NULL;
}
int main() {
int i, j;
pthread_t threads[MAX_PROC];
// Input the number of processes
printf("Enter number of processes (max %d): ", MAX_PROC);
scanf("%d", &proc_count);
if (proc_count > MAX_PROC) proc_count = MAX_PROC;
// Input process details
for (i = 0; i < proc_count; i++) {
procs[i].id = i + 1;
printf("\nProcess %d:\n", procs[i].id);
printf("Enter number of frames (max %d): ", MAX_FRAMES);
scanf("%d", &procs[i].frames);
if (procs[i].frames > MAX_FRAMES) procs[i].frames = MAX_FRAMES;
printf("Enter number of page references (max %d): ", MAX_REF);
scanf("%d", &procs[i].n);
if (procs[i].n > MAX_REF) procs[i].n = MAX_REF;
printf("Enter %d page references (space separated): ", procs[i].n);
for (j = 0; j < procs[i].n; j++) {
scanf("%d", &procs[i].ref[j]);
}
}
// Create a thread for each process simulation
for (i = 0; i < proc_count; i++) {
pthread_create(&threads[i], NULL, simulateOptimal, &procs[i]);
}
int totalFaults = 0;
// Wait for all threads to complete
for (i = 0; i < proc_count; i++) {
pthread_join(threads[i], NULL);
totalFaults += procs[i].faults;
}
// Calculate and display average faults
printf("\nAverage Page Faults: %.2f\n", (float)totalFaults / proc_count);
return 0;
}