Operating SystemsOS Project Ideas

Operating System Project Ideas

LevelAdvanced

Duration120 mins

TopicOS Project Ideas

2 / 5

Custom Scheduler

Building Your Own Process Scheduler

The scheduler is the heart of any operating system—the component that decides which process runs when, for how long, and on which CPU. It directly impacts system responsiveness, throughput, fairness, and power consumption.

Building a scheduler from scratch forces you to confront fundamental questions: How do you balance interactive responsiveness with batch throughput? How do you prevent starvation? How do you handle priority inversion?

This project simulates process scheduling in user-space, implementing multiple algorithms and comparing their behavior under different workloads.

What You Will Learn

By the end of this page, you will understand scheduler architecture, implement FCFS, SJF, Round Robin, Priority, and MLFQ schedulers, measure performance metrics, and understand the tradeoffs each algorithm makes.

Scheduler Architecture

A scheduler simulation consists of several core components:

Process Control Block (PCB) — Data structure representing each process
Ready Queue(s) — Data structures holding runnable processes
Scheduling Algorithm — The selection logic
Time Accounting — Tracking turnaround, waiting, response times
Simulation Engine — The main loop advancing time

The simulation can run in discrete time (event-driven) or continuous time (tick-based). We'll use tick-based for simplicity.

scheduler_types.h
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#ifndef SCHEDULER_TYPES_H
#define SCHEDULER_TYPES_H
 
#include <stdbool.h>
 
typedef enum {
    PROCESS_NEW,
    PROCESS_READY,
    PROCESS_RUNNING,
    PROCESS_WAITING,
    PROCESS_TERMINATED
} ProcessState;
 
typedef struct {
    int pid;                // Process ID
    char name[32];          // Process name
    int arrival_time;       // When process arrives
    int burst_time;         // Total CPU time needed
    int remaining_time;     // CPU time remaining
    int priority;           // Priority (lower = higher priority)
    ProcessState state;     // Current state
 
    // Timing metrics
    int start_time;         // First time process ran (-1 if never)
    int finish_time;        // When process completed
    int waiting_time;       // Total time in ready queue
    int turnaround_time;    // finish - arrival
    int response_time;      // start - arrival
} Process;
 
typedef struct {
    Process **processes;    // Array of process pointers
    int size;               // Current number of processes
    int capacity;           // Maximum capacity
} ProcessQueue;
 
typedef struct {
    int total_processes;
    int current_time;
    double avg_turnaround;
    double avg_waiting;
    double avg_response;
    double cpu_utilization;
    double throughput;
} SchedulerMetrics;
 
#endif

Key Scheduling Metrics
Metric	Definition	Importance
Turnaround Time	Completion time − Arrival time	Overall efficiency
Waiting Time	Time spent in ready queue	Queue efficiency
Response Time	First run − Arrival time	Interactive responsiveness
Throughput	Processes completed per unit time	System productivity
CPU Utilization	% of time CPU is busy	Resource efficiency

Ready Queue Data Structures

Different scheduling algorithms require different queue implementations:

FCFS: Simple FIFO queue (linked list or circular buffer)
SJF/SRTF: Priority queue ordered by burst/remaining time
Priority: Priority queue ordered by priority value
Round Robin: FIFO queue with time quantum tracking
MLFQ: Multiple queues at different priority levels

ready_queue.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <stdlib.h>
#include <string.h>
#include "scheduler_types.h"
 
/**
 * Create a new process queue with given capacity.
 */
ProcessQueue *queue_create(int capacity) {
    ProcessQueue *q = malloc(sizeof(ProcessQueue));
    q->processes = malloc(sizeof(Process *) * capacity);
    q->size = 0;
    q->capacity = capacity;
    return q;
}
 
/**
 * Add process to the queue (FIFO behavior).
 */
void queue_enqueue(ProcessQueue *q, Process *p) {
    if (q->size >= q->capacity) {
        q->capacity *= 2;
        q->processes = realloc(q->processes, 
                               sizeof(Process *) * q->capacity);
    }
    q->processes[q->size++] = p;
}
 
/**
 * Remove and return the first process (FIFO).
 */
Process *queue_dequeue(ProcessQueue *q) {
    if (q->size == 0) return NULL;
 
    Process *p = q->processes[0];
    // Shift remaining elements
    memmove(q->processes, q->processes + 1, 
            sizeof(Process *) * (q->size - 1));
    q->size--;
    return p;
}
 
/**
 * Remove and return process with shortest remaining time.
 * Used for SJF and SRTF.
 */
Process *queue_dequeue_shortest(ProcessQueue *q) {
    if (q->size == 0) return NULL;
 
    int min_idx = 0;
    for (int i = 1; i < q->size; i++) {
        if (q->processes[i]->remaining_time < 
            q->processes[min_idx]->remaining_time) {
            min_idx = i;
        }
    }
 
    Process *p = q->processes[min_idx];
    // Remove by shifting
    memmove(q->processes + min_idx, q->processes + min_idx + 1,
            sizeof(Process *) * (q->size - min_idx - 1));
    q->size--;
    return p;
}
 
/**
 * Remove and return highest priority process.
 * Lower priority number = higher priority.
 */
Process *queue_dequeue_priority(ProcessQueue *q) {
    if (q->size == 0) return NULL;
 
    int best_idx = 0;
    for (int i = 1; i < q->size; i++) {
        if (q->processes[i]->priority < 
            q->processes[best_idx]->priority) {
            best_idx = i;
        }
    }
 
    Process *p = q->processes[best_idx];
    memmove(q->processes + best_idx, q->processes + best_idx + 1,
            sizeof(Process *) * (q->size - best_idx - 1));
    q->size--;
    return p;
}

Implementing Scheduling Algorithms

Let's implement the core scheduling algorithms. Each has distinct characteristics and tradeoffs.

schedulers.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include <stdio.h>
#include <limits.h>
#include "scheduler_types.h"
#include "ready_queue.h"
 
/**
 * First-Come, First-Served (FCFS)
 * Non-preemptive, simple FIFO ordering.
 */
void scheduler_fcfs(Process *processes[], int n) {
    ProcessQueue *ready = queue_create(n);
    int time = 0;
    int completed = 0;
    int next_arrival = 0;
 
    while (completed < n) {
        // Add newly arrived processes
        while (next_arrival < n && 
               processes[next_arrival]->arrival_time <= time) {
            queue_enqueue(ready, processes[next_arrival]);
            processes[next_arrival]->state = PROCESS_READY;
            next_arrival++;
        }
 
        if (ready->size == 0) {
            time++;  // CPU idle
            continue;
        }
 
        // Select first process in queue
        Process *current = queue_dequeue(ready);
        current->state = PROCESS_RUNNING;
 
        if (current->start_time == -1) {
            current->start_time = time;
            current->response_time = time - current->arrival_time;
        }
 
        // Run to completion (non-preemptive)
        time += current->remaining_time;
        current->remaining_time = 0;
        current->finish_time = time;
        current->state = PROCESS_TERMINATED;
        current->turnaround_time = time - current->arrival_time;
        current->waiting_time = current->turnaround_time - 
                                current->burst_time;
        completed++;
    }
 
    queue_destroy(ready);
}
 
/**
 * Round Robin with configurable time quantum.
 * Preemptive, fair time sharing.
 */
void scheduler_round_robin(Process *processes[], int n, 
                           int time_quantum) {
    ProcessQueue *ready = queue_create(n);
    int time = 0;
    int completed = 0;
    int next_arrival = 0;
 
    while (completed < n) {
        // Add newly arrived processes
        while (next_arrival < n && 
               processes[next_arrival]->arrival_time <= time) {
            queue_enqueue(ready, processes[next_arrival]);
            processes[next_arrival]->state = PROCESS_READY;
            next_arrival++;
        }
 
        if (ready->size == 0) {
            time++;
            continue;
        }
 
        Process *current = queue_dequeue(ready);
        current->state = PROCESS_RUNNING;
 
        if (current->start_time == -1) {
            current->start_time = time;
            current->response_time = time - current->arrival_time;
        }
 
        // Execute for quantum or until completion
        int exec_time = (current->remaining_time < time_quantum) 
                        ? current->remaining_time 
                        : time_quantum;
        time += exec_time;
        current->remaining_time -= exec_time;
 
        // Check for newly arrived during execution
        while (next_arrival < n && 
               processes[next_arrival]->arrival_time <= time) {
            queue_enqueue(ready, processes[next_arrival]);
            processes[next_arrival]->state = PROCESS_READY;
            next_arrival++;
        }
 
        if (current->remaining_time == 0) {
            current->finish_time = time;
            current->state = PROCESS_TERMINATED;
            current->turnaround_time = time - current->arrival_time;
            current->waiting_time = current->turnaround_time - 
                                    current->burst_time;
            completed++;
        } else {
            // Preempted - return to ready queue
            current->state = PROCESS_READY;
            queue_enqueue(ready, current);
        }
    }
 
    queue_destroy(ready);
}

Algorithm Comparison
Algorithm	Preemptive	Best For	Weakness
FCFS	No	Simple batch systems	Convoy effect
SJF	No	Minimizing avg wait	Starvation of long jobs
SRTF	Yes	Optimal avg wait	High overhead, starvation
Round Robin	Yes	Interactive systems	High context switches
Priority	Both	Differentiated service	Priority inversion, starvation
MLFQ	Yes	General purpose	Complex tuning required

Multi-Level Feedback Queue (MLFQ)

MLFQ is the gold standard of general-purpose scheduling—it adapts to process behavior without prior knowledge. The key rules:

New processes start at the highest priority queue
If a process uses its entire time quantum, demote it
If a process yields (I/O), keep it at current level
Periodically boost all processes to prevent starvation

mlfq.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#define NUM_QUEUES 4
#define BOOST_INTERVAL 100  // Time units between priority boosts
 
typedef struct {
    ProcessQueue *queues[NUM_QUEUES];
    int time_quanta[NUM_QUEUES];  // Different quantum per level
    int boost_timer;
} MLFQ;
 
MLFQ *mlfq_create(void) {
    MLFQ *mlfq = malloc(sizeof(MLFQ));
    for (int i = 0; i < NUM_QUEUES; i++) {
        mlfq->queues[i] = queue_create(64);
        // Quantum increases with lower priority
        mlfq->time_quanta[i] = (1 << i) * 10;  // 10, 20, 40, 80
    }
    mlfq->boost_timer = 0;
    return mlfq;
}
 
void mlfq_boost(MLFQ *mlfq) {
    // Move all processes to highest priority queue
    for (int i = 1; i < NUM_QUEUES; i++) {
        while (mlfq->queues[i]->size > 0) {
            Process *p = queue_dequeue(mlfq->queues[i]);
            p->priority = 0;  // Reset to highest
            queue_enqueue(mlfq->queues[0], p);
        }
    }
}
 
Process *mlfq_select(MLFQ *mlfq, int *quantum_out) {
    // Select from highest priority non-empty queue
    for (int i = 0; i < NUM_QUEUES; i++) {
        if (mlfq->queues[i]->size > 0) {
            *quantum_out = mlfq->time_quanta[i];
            return queue_dequeue(mlfq->queues[i]);
        }
    }
    return NULL;
}
 
void mlfq_requeue(MLFQ *mlfq, Process *p, bool used_full_quantum) {
    int new_priority = p->priority;
 
    if (used_full_quantum && new_priority < NUM_QUEUES - 1) {
        new_priority++;  // Demote
    }
    // If yielded early (I/O), keep same priority
 
    p->priority = new_priority;
    queue_enqueue(mlfq->queues[new_priority], p);
}

MLFQ Gaming Prevention

A clever process could game MLFQ by yielding just before its quantum expires, staying at high priority. Modern MLFQ implementations track total CPU usage at each level, demoting based on accumulated time, not just per-quantum behavior.

Summary: Custom Scheduler Project

Key Takeaways

•Schedulers make fundamental tradeoffs — No single algorithm is best for all workloads
•Queue data structures matter — O(1) operations are critical for scalability
•Metrics reveal algorithm behavior — Compare turnaround, waiting, response times
•MLFQ adapts to unknown workloads — The basis for most production schedulers
•Preemption adds complexity — But enables responsiveness and fairness
•Starvation must be prevented — Priority aging or periodic boosts are essential

Project Extension Ideas

Extend your scheduler with: multi-core support (load balancing), real-time scheduling (EDF, RMS), I/O wait simulation, varying workload generators, and visualization of queue states over time.

2 / 5

Loading learning content...

Operating SystemsOS Project Ideas

Operating System Project Ideas

LevelAdvanced

Duration120 mins

TopicOS Project Ideas

2 / 5

Custom Scheduler

Building Your Own Process Scheduler

This project simulates process scheduling in user-space, implementing multiple algorithms and comparing their behavior under different workloads.

What You Will Learn

Scheduler Architecture

A scheduler simulation consists of several core components:

Process Control Block (PCB) — Data structure representing each process
Ready Queue(s) — Data structures holding runnable processes
Scheduling Algorithm — The selection logic
Time Accounting — Tracking turnaround, waiting, response times
Simulation Engine — The main loop advancing time

The simulation can run in discrete time (event-driven) or continuous time (tick-based). We'll use tick-based for simplicity.

scheduler_types.h
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#ifndef SCHEDULER_TYPES_H
#define SCHEDULER_TYPES_H
 
#include <stdbool.h>
 
typedef enum {
    PROCESS_NEW,
    PROCESS_READY,
    PROCESS_RUNNING,
    PROCESS_WAITING,
    PROCESS_TERMINATED
} ProcessState;
 
typedef struct {
    int pid;                // Process ID
    char name[32];          // Process name
    int arrival_time;       // When process arrives
    int burst_time;         // Total CPU time needed
    int remaining_time;     // CPU time remaining
    int priority;           // Priority (lower = higher priority)
    ProcessState state;     // Current state
 
    // Timing metrics
    int start_time;         // First time process ran (-1 if never)
    int finish_time;        // When process completed
    int waiting_time;       // Total time in ready queue
    int turnaround_time;    // finish - arrival
    int response_time;      // start - arrival
} Process;
 
typedef struct {
    Process **processes;    // Array of process pointers
    int size;               // Current number of processes
    int capacity;           // Maximum capacity
} ProcessQueue;
 
typedef struct {
    int total_processes;
    int current_time;
    double avg_turnaround;
    double avg_waiting;
    double avg_response;
    double cpu_utilization;
    double throughput;
} SchedulerMetrics;
 
#endif

Key Scheduling Metrics
Metric	Definition	Importance
Turnaround Time	Completion time − Arrival time	Overall efficiency
Waiting Time	Time spent in ready queue	Queue efficiency
Response Time	First run − Arrival time	Interactive responsiveness
Throughput	Processes completed per unit time	System productivity
CPU Utilization	% of time CPU is busy	Resource efficiency

Ready Queue Data Structures

Different scheduling algorithms require different queue implementations:

FCFS: Simple FIFO queue (linked list or circular buffer)
SJF/SRTF: Priority queue ordered by burst/remaining time
Priority: Priority queue ordered by priority value
Round Robin: FIFO queue with time quantum tracking
MLFQ: Multiple queues at different priority levels

ready_queue.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <stdlib.h>
#include <string.h>
#include "scheduler_types.h"
 
/**
 * Create a new process queue with given capacity.
 */
ProcessQueue *queue_create(int capacity) {
    ProcessQueue *q = malloc(sizeof(ProcessQueue));
    q->processes = malloc(sizeof(Process *) * capacity);
    q->size = 0;
    q->capacity = capacity;
    return q;
}
 
/**
 * Add process to the queue (FIFO behavior).
 */
void queue_enqueue(ProcessQueue *q, Process *p) {
    if (q->size >= q->capacity) {
        q->capacity *= 2;
        q->processes = realloc(q->processes, 
                               sizeof(Process *) * q->capacity);
    }
    q->processes[q->size++] = p;
}
 
/**
 * Remove and return the first process (FIFO).
 */
Process *queue_dequeue(ProcessQueue *q) {
    if (q->size == 0) return NULL;
 
    Process *p = q->processes[0];
    // Shift remaining elements
    memmove(q->processes, q->processes + 1, 
            sizeof(Process *) * (q->size - 1));
    q->size--;
    return p;
}
 
/**
 * Remove and return process with shortest remaining time.
 * Used for SJF and SRTF.
 */
Process *queue_dequeue_shortest(ProcessQueue *q) {
    if (q->size == 0) return NULL;
 
    int min_idx = 0;
    for (int i = 1; i < q->size; i++) {
        if (q->processes[i]->remaining_time < 
            q->processes[min_idx]->remaining_time) {
            min_idx = i;
        }
    }
 
    Process *p = q->processes[min_idx];
    // Remove by shifting
    memmove(q->processes + min_idx, q->processes + min_idx + 1,
            sizeof(Process *) * (q->size - min_idx - 1));
    q->size--;
    return p;
}
 
/**
 * Remove and return highest priority process.
 * Lower priority number = higher priority.
 */
Process *queue_dequeue_priority(ProcessQueue *q) {
    if (q->size == 0) return NULL;
 
    int best_idx = 0;
    for (int i = 1; i < q->size; i++) {
        if (q->processes[i]->priority < 
            q->processes[best_idx]->priority) {
            best_idx = i;
        }
    }
 
    Process *p = q->processes[best_idx];
    memmove(q->processes + best_idx, q->processes + best_idx + 1,
            sizeof(Process *) * (q->size - best_idx - 1));
    q->size--;
    return p;
}

Implementing Scheduling Algorithms

Let's implement the core scheduling algorithms. Each has distinct characteristics and tradeoffs.

schedulers.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include <stdio.h>
#include <limits.h>
#include "scheduler_types.h"
#include "ready_queue.h"
 
/**
 * First-Come, First-Served (FCFS)
 * Non-preemptive, simple FIFO ordering.
 */
void scheduler_fcfs(Process *processes[], int n) {
    ProcessQueue *ready = queue_create(n);
    int time = 0;
    int completed = 0;
    int next_arrival = 0;
 
    while (completed < n) {
        // Add newly arrived processes
        while (next_arrival < n && 
               processes[next_arrival]->arrival_time <= time) {
            queue_enqueue(ready, processes[next_arrival]);
            processes[next_arrival]->state = PROCESS_READY;
            next_arrival++;
        }
 
        if (ready->size == 0) {
            time++;  // CPU idle
            continue;
        }
 
        // Select first process in queue
        Process *current = queue_dequeue(ready);
        current->state = PROCESS_RUNNING;
 
        if (current->start_time == -1) {
            current->start_time = time;
            current->response_time = time - current->arrival_time;
        }
 
        // Run to completion (non-preemptive)
        time += current->remaining_time;
        current->remaining_time = 0;
        current->finish_time = time;
        current->state = PROCESS_TERMINATED;
        current->turnaround_time = time - current->arrival_time;
        current->waiting_time = current->turnaround_time - 
                                current->burst_time;
        completed++;
    }
 
    queue_destroy(ready);
}
 
/**
 * Round Robin with configurable time quantum.
 * Preemptive, fair time sharing.
 */
void scheduler_round_robin(Process *processes[], int n, 
                           int time_quantum) {
    ProcessQueue *ready = queue_create(n);
    int time = 0;
    int completed = 0;
    int next_arrival = 0;
 
    while (completed < n) {
        // Add newly arrived processes
        while (next_arrival < n && 
               processes[next_arrival]->arrival_time <= time) {
            queue_enqueue(ready, processes[next_arrival]);
            processes[next_arrival]->state = PROCESS_READY;
            next_arrival++;
        }
 
        if (ready->size == 0) {
            time++;
            continue;
        }
 
        Process *current = queue_dequeue(ready);
        current->state = PROCESS_RUNNING;
 
        if (current->start_time == -1) {
            current->start_time = time;
            current->response_time = time - current->arrival_time;
        }
 
        // Execute for quantum or until completion
        int exec_time = (current->remaining_time < time_quantum) 
                        ? current->remaining_time 
                        : time_quantum;
        time += exec_time;
        current->remaining_time -= exec_time;
 
        // Check for newly arrived during execution
        while (next_arrival < n && 
               processes[next_arrival]->arrival_time <= time) {
            queue_enqueue(ready, processes[next_arrival]);
            processes[next_arrival]->state = PROCESS_READY;
            next_arrival++;
        }
 
        if (current->remaining_time == 0) {
            current->finish_time = time;
            current->state = PROCESS_TERMINATED;
            current->turnaround_time = time - current->arrival_time;
            current->waiting_time = current->turnaround_time - 
                                    current->burst_time;
            completed++;
        } else {
            // Preempted - return to ready queue
            current->state = PROCESS_READY;
            queue_enqueue(ready, current);
        }
    }
 
    queue_destroy(ready);
}

Algorithm Comparison
Algorithm	Preemptive	Best For	Weakness
FCFS	No	Simple batch systems	Convoy effect
SJF	No	Minimizing avg wait	Starvation of long jobs
SRTF	Yes	Optimal avg wait	High overhead, starvation
Round Robin	Yes	Interactive systems	High context switches
Priority	Both	Differentiated service	Priority inversion, starvation
MLFQ	Yes	General purpose	Complex tuning required

Multi-Level Feedback Queue (MLFQ)

MLFQ is the gold standard of general-purpose scheduling—it adapts to process behavior without prior knowledge. The key rules:

New processes start at the highest priority queue
If a process uses its entire time quantum, demote it
If a process yields (I/O), keep it at current level
Periodically boost all processes to prevent starvation

mlfq.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#define NUM_QUEUES 4
#define BOOST_INTERVAL 100  // Time units between priority boosts
 
typedef struct {
    ProcessQueue *queues[NUM_QUEUES];
    int time_quanta[NUM_QUEUES];  // Different quantum per level
    int boost_timer;
} MLFQ;
 
MLFQ *mlfq_create(void) {
    MLFQ *mlfq = malloc(sizeof(MLFQ));
    for (int i = 0; i < NUM_QUEUES; i++) {
        mlfq->queues[i] = queue_create(64);
        // Quantum increases with lower priority
        mlfq->time_quanta[i] = (1 << i) * 10;  // 10, 20, 40, 80
    }
    mlfq->boost_timer = 0;
    return mlfq;
}
 
void mlfq_boost(MLFQ *mlfq) {
    // Move all processes to highest priority queue
    for (int i = 1; i < NUM_QUEUES; i++) {
        while (mlfq->queues[i]->size > 0) {
            Process *p = queue_dequeue(mlfq->queues[i]);
            p->priority = 0;  // Reset to highest
            queue_enqueue(mlfq->queues[0], p);
        }
    }
}
 
Process *mlfq_select(MLFQ *mlfq, int *quantum_out) {
    // Select from highest priority non-empty queue
    for (int i = 0; i < NUM_QUEUES; i++) {
        if (mlfq->queues[i]->size > 0) {
            *quantum_out = mlfq->time_quanta[i];
            return queue_dequeue(mlfq->queues[i]);
        }
    }
    return NULL;
}
 
void mlfq_requeue(MLFQ *mlfq, Process *p, bool used_full_quantum) {
    int new_priority = p->priority;
 
    if (used_full_quantum && new_priority < NUM_QUEUES - 1) {
        new_priority++;  // Demote
    }
    // If yielded early (I/O), keep same priority
 
    p->priority = new_priority;
    queue_enqueue(mlfq->queues[new_priority], p);
}

MLFQ Gaming Prevention

Summary: Custom Scheduler Project

Key Takeaways

•Schedulers make fundamental tradeoffs — No single algorithm is best for all workloads
•Queue data structures matter — O(1) operations are critical for scalability
•Metrics reveal algorithm behavior — Compare turnaround, waiting, response times
•MLFQ adapts to unknown workloads — The basis for most production schedulers
•Preemption adds complexity — But enables responsiveness and fairness
•Starvation must be prevented — Priority aging or periodic boosts are essential

Project Extension Ideas

Extend your scheduler with: multi-core support (load balancing), real-time scheduling (EDF, RMS), I/O wait simulation, varying workload generators, and visualization of queue states over time.

2 / 5