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

modified and updated

Browse source
This commit is contained in:
sherlock 2025-04-11 08:30:13 +05:30
parent 44e766514e
commit 6ff1894732
6 changed files with 674 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -0,0 +1,153 @@
#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
}