rushilwiz/lab-06-Rushilwiz
1
0
Fork 0
mirror of https://github.com/Comp211-SP24/lab-06-Rushilwiz.git synced 2025-04-03 03:40:18 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
github-classroom[bot] 2024-04-15 17:24:16 +00:00 committed by GitHub
commit 05ecbee94d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
25 changed files with 1122 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.gitignore vendored Normal file
View File

@ -0,0 +1,10 @@
# Build files
*.o
*.out
main
# macOS
.DS_Store
# IDE
.idea

BIN
Heaps.pdf Normal file
View File

Binary file not shown.

22
Makefile Normal file
View File

@ -0,0 +1,22 @@
CC=gcc
CFLAGS=-c -Wall -Werror -g
all: main
main: task.o schedule.o main.o
$(CC) task.o schedule.o main.o -o main -lm
task.o: task.c
$(CC) $(CFLAGS) task.c
schedule.o: schedule.c
$(CC) $(CFLAGS) schedule.c
main.o: main.c
$(CC) $(CFLAGS) main.c
run: main
./main
clean:
/bin/rm -f main *.o

139
README.md Normal file
View File

@ -0,0 +1,139 @@
<!-- omit in toc -->
# Lab 6
In this lab, you will gain familiarity with many concepts pertinent to operating systems and C programming:
* Linked list data structure
* OS scheduling algorithms
* First come first served (FCFS)
* Priority queue
* Priority value is used by the scheduling algorithm to determine which tasks to focus on first.
* For example, an OS would likely give high priority to I/O operations because it's important that the CPU reacts as soon as you type a key.
* A long download may have low priority.
* Round robin
* C structs
* Pointers
* Memory allocation and deallocation
In particular, this lab's goals are
1. Become familiar with the `task_struct` that is used by the OS to manage a program running in memory. Here, we'll use only a subset of fields found in the real Linux `task_struct`, namely the *process id* (pid) and *priority*. If interested, you can view the Linux kernel's real `task_struct` in the [sched.h](https://github.com/torvalds/linux/blob/master/include/linux/sched.h) header file distributed in the newest [Linux kernel code](https://github.com/torvalds/linux). Typically, the pid and priority values are assigned by the OS, but in this lab, you'll simulate this OS operation by manually assigning values to the `task_struct` fields.
2. Gain experience with **singly linked list** in C (code provided), one of the fundamental data structures used in operating systems (and in general). Each element in the linked list is a `task_struct`. A linked list is a suitable data structure choice because of its efficient use of memory and $O(1)$ queue operations (enqueue and dequeue) and stack operations (push and pop). However, a linked list has some disadvantages that you'll soon recall or become familiar with.
3. Simulate **priority queue**, **first come first serve** (**FCFS**) and **round robin** scheduling algorithms.
<details open>
<summary>Contents</summary>
- [Pre-lab knowledge](#pre-lab-knowledge)
- [Background reading](#background-reading)
- [Structure](#structure)
- [Part 0: Understand starter code](#part-0-understand-starter-code)
- [Part 1. Min heapify](#part-1-min-heapify)
- [Testing](#testing)
- [Part 2. Scheduling algorithms](#part-2-scheduling-algorithms)
- [Testing](#testing-1)
- [Submit your assignment](#submit-your-assignment)
</details>
## Pre-lab knowledge
### Background reading
* For linked lists and list operations, [Linked List Basics](http://cslibrary.stanford.edu/103/LinkedListBasics.pdf)
* For a review of binary heaps and the heapify algorithm, [Heaps.pdf](Heaps.pdf) included in this repo
* For a few OS scheduling algorithms, [OSTEP Chapter 7](https://pages.cs.wisc.edu/~remzi/OSTEP/cpu-sched.pdf)
* C concepts:
* For how header files work in C, chapter 4.5 in *The C Programming Language*
* For pointers, memory allocation, and deallocation, chapter 5 in *The C Programming Language*
* For information about structs, chapter 6 in *The C Programming Language*
### Structure
Here is a description of each file and what you are expected to do (if anything) in each:
```text
.
├── Heaps.pdf - Background reading about heaps
├── Makefile
├── README.md
├── main.c - Do not modify. Contains main function
├── schedule.c - Contains functions that simulate running and scheduling tasks. Implement run_to_completion, run_with_quantum, fcfs, priority_queue, round_robin
├── schedule.h
├── task.c - Contains linked list functions (code given) and min_heapify function (TODO). Read through task.h to see function prototypes for given functions, then implement min_heapify
├── task.h - Contains definition of task_struct and function prototypes for task.c. Read the prototypes to understand given code, which is necessary to complete task.c and schedule.c
└── tests - Test data
├── part1
└── part2
```
In `task.h`, you will find the definition of `task_struct`, which contains data (`priority`, `pid`, `remaining_cycles`) and pointer `next`.
There are several comments and docstrings in the source files that will guide you through the assignment.
Lastly, in this lab, you **may not** add or remove additional global variables. **If this is done, points will be deducted.** Ask your cohort leader for clarification if you have any questions regarding this stipulation.
## Part 0: Understand starter code
You are provided code for all necessary linked list functions in `task.c`. You probably will not need to use all of the functions.
In `task.h`, read the definition of `task_struct` and the linked list function prototypes to see how to work with the singly linked list. There should be no need to carefully read the code for the linked list operations in `task.c`, but you may if you want.
## Part 1. Min heapify
In `task.c`, implement the `min_heapify` function to convert the linked list data structure to a priority queue for use in the priority-based scheduling algorithm. Read `Heaps.pdf` to learn or refamiliarize yourself with the min heapify algorithm. The pseudocode given is for a max heap, but the code for a min heap is very similar.
A docstring is provided in `task.h`.
### Testing
Run `make`, then run the program with `./main`.
The `main` function accepts input from `stdin` and outputs to `stdout` (no CLI args). An example run is as follows:
```text
Number of tasks: 4
pid priority cycles: 12 50 100
pid priority cycles: 13 1 80
pid priority cycles: 14 40 60
pid priority cycles: 15 0 40
---- Tasks ----
(num_tasks) [pid:priority:cycles:priority/cycles ...]
(4) [ 12:50:100:0.50 13:1:80:0.01 14:40:60:0.67 15:0:40:0.00 ]
Select scheduling algorithm (0: Display min heap, 1: FCFS, 2: Priority queue, 3: Round robin): 0
---- Min heap ----
(4) [ 15:0:40:0.00 13:1:80:0.01 14:40:60:0.67 12:50:100:0.50 ]
```
First, input the number of tasks and the data for each task. Then, select the scheduling algorithm. In this case, since the scheduling algorithms have not been implemented yet, select 0 to display your min heap to check whether it is correct.
Notice that the task with the minimum priority ratio (defined as `priority / cycles`) is at the front of the min heap, as expected. However, 0.67 is before 0.50 even though `0.50 < 0.67`. Recall from COMP 210 that this is intended behavior because a min heap guarantees only that all paths from a root to a leaf are in ascending order.
There are some other test inputs and outputs in `tests/part1`, and you can check for differences with `diff`. The commands to do so are similar to the ones in previous labs (e.g., `./main < input.txt > output.txt` and `diff expected.txt output.txt`).
## Part 2. Scheduling algorithms
In this part, you will simulate a few scheduling algorithms to see how an OS schedules and runs tasks on a CPU. We will implement first come first serve (FCFS), priority-based scheduling, and round robin. See [Background reading](#background-reading) and the docstrings in `schedule.h` for information about these algorithms.
For the scheduling algorithms, pseudocode is provided in `schedule.h`. Additionally, example runs for each scheduling algorithm are shown in the sample test outputs in [tests/part2](tests/part2).
In `schedule.c`, implement the following functions:
* `run_to_completion`
* `run_with_quantum`
* `fcfs`
* `priority_queue`
* `round_robin`
### Testing
This section can be tested similarly to the previous section. Sample inputs and outputs for the various scheduling algorithms are in `tests/part2`. The inputs are nearly identical to those in `tests/part1`, and the only difference is the very last number, which selects the scheduling algorithm (i.e., now 1, 2, and 3 for FCFS, priority queue, and round robin, respectively).
## Submit your assignment
1. Use git to push your finished code to this GitHub repository.
2. Go to the COMP 211 course in Gradescope and click on the assignment called **Lab 6**.
3. Click on the option to **Submit Assignment** and choose GitHub as the submission method.
4. You should see a list of your public repositories. Select the one named **lab-06-yourname** and submit it.
5. Your assignment should be autograded within a few seconds and you will receive feedback for the autograded portion.
6. If you receive all the points, then you have completed this lab! Otherwise, you are free to keep pushing commits to your GitHub repository and submit for regrading up until the deadline of the lab.

66
main.c Normal file
View File

@ -0,0 +1,66 @@
// Do not edit this file
// Usage (after running make): ./main
// This file takes input from stdin and outputs to stdout. No CLI args
#include <stdio.h>
#include <stdlib.h>
#include "schedule.h"
#include "task.h"
int main() {
int n;
printf("Number of tasks: ");
scanf("%d", &n);
if (n <= 0) {
fprintf(stderr, "Number of tasks must be greater than 0\n");
return EXIT_FAILURE;
}
unsigned int pid, priority, cycles;
for (int i = 0; i < n; i++) {
printf("pid priority cycles: ");
scanf("%d %d %d", &pid, &priority, &cycles);
if (!append_task(pid, priority, cycles)) {
fprintf(stderr, "Append failed, is %d a duplicate pid?\n", pid);
return EXIT_FAILURE;
}
}
printf("---- Tasks ----\n");
printf("(num_tasks) [pid:priority:cycles:priority/cycles ...]\n");
print_tasks();
printf(
"Select scheduling algorithm (0: Display min heap, 1: FCFS, "
"2: Priority queue, 3: "
"Round robin): ");
int scheduler = 0;
scanf("%d", &scheduler);
switch (scheduler) {
case 0:
printf("---- Min heap ----\n");
min_heapify();
print_tasks();
break;
case 1:
printf("---- FCFS ----\n");
fcfs();
break;
case 2:
printf("---- Priority queue ----\n");
priority_queue(QUANTUM);
break;
case 3:
printf("---- Round robin ----\n");
round_robin(QUANTUM);
break;
default:
fprintf(stderr, "Invalid scheduler\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}

26
schedule.c Normal file
View File

@ -0,0 +1,26 @@
// PID: 9DigitPidNoSpacesOrDashes
// I pledge the COMP 211 honor code.
#include "schedule.h"
#include <stdio.h>
#include <stdlib.h>
void run_to_completion(task_struct* task) {
// TODO:
}
void run_with_quantum(task_struct* task, unsigned int quantum) {
// TODO:
}
void fcfs() {
// TODO:
}
void priority_queue(unsigned int quantum) {
// TODO:
}
void round_robin(unsigned int quantum) {
// TODO:
}

77
schedule.h Normal file
View File

@ -0,0 +1,77 @@
// Do not edit this file
#include <math.h>
#include "task.h"
#ifndef _SCHEDULE_H_
#define _SCHEDULE_H_
// For preemptive scheduling algorithms, the maximum time slice that a task can
// be run for before a context switch to another task
#define QUANTUM 5
/**
* Run task on the CPU for its total number of remaining cycles.
*
* Print "Task {pid} ran for {remaining_cycles} cycle(s)."
* Set task's remaining_cycles to 0.
* Print "Task {pid} completed."
*
* @param task
* @return void
*/
void run_to_completion(task_struct* task);
/**
* Run task on the CPU for a maximum time quantum.
*
* If remaining_cycles <= quantum, then call run_to_completion.
*
* Else, decrement task's remaining_cycles by quantum
* and print "Task {pid} ran for {quantum} cycle(s)."
*
* @param task
* @param quantum
* @return void
*/
void run_with_quantum(task_struct* task, unsigned int quantum);
/**
* Implement the first come first serve (FCFS) scheduling algorithm.
*
* While the queue is not empty:
* - Get the task at the front of the queue.
* - Remove and run the task to completion.
*
* @return void
*/
void fcfs();
/**
* Implement the priority queue scheduling algorithm.
*
* While the queue is not empty:
* - Min heapify the linked list.
* - Get the highest priority task from the list (the one at the head).
* - Remove and run the highest priority task for the given quantum.
* - If the task is not complete, then append it to the linked list.
*
* @param quantum
* @return void
*/
void priority_queue(unsigned int quantum);
/**
* Implement the round robin scheduling algorithm.
*
* While the linked list is not empty:
* - Get the task in the list at ( index + 1 ) % list size.
* - Run the task for the given quantum.
* - If the task is complete, then remove it from the list.
*
* @param quantum
* @return void
*/
void round_robin(unsigned int quantum);
#endif

200
task.c Normal file
View File

@ -0,0 +1,200 @@
// PID: 9DigitPidNoSpacesOrDashes
// I pledge the COMP 211 honor code.
#include "task.h"
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
// Pointers to the head and tail of the linked list to be used in the functions
task_struct* head = NULL;
task_struct* tail = NULL;
void clear() {
// DO NOT MODIFY
while (head != NULL) {
task_struct* tmp = head->next;
free(head);
head = tmp;
}
head = NULL;
tail = NULL;
}
unsigned int size() {
// DO NOT MODIFY
if (head == NULL)
return 0;
task_struct* tmp = head;
unsigned int sz = 1;
while ((tmp = tmp->next) != NULL)
sz++;
return sz;
}
bool append_task(unsigned int pid, unsigned int priority, unsigned int cycles) {
// DO NOT MODIFY
if (exists(pid) != NULL)
return false;
task_struct* new = malloc(sizeof(task_struct));
new->pid = pid;
new->priority = priority;
new->remaining_cycles = cycles;
new->next = NULL;
if (head == NULL) {
head = new;
tail = new;
} else {
tail->next = new;
tail = new;
}
return true;
}
bool insert_task(unsigned int index,
unsigned int pid,
unsigned int priority,
unsigned int cycles) {
// DO NOT MODIFY
if (exists(pid) != NULL || index > size())
return false;
task_struct* new = malloc(sizeof(task_struct));
new->pid = pid;
new->priority = priority;
new->remaining_cycles = cycles;
if (index == 0) {
task_struct* tmp = head;
head = new;
new->next = tmp;
} else {
if (index == size())
tail = new;
task_struct* tmp = get_task(index - 1);
new->next = tmp->next;
tmp->next = new;
}
return true;
}
bool set_task(unsigned int index, unsigned int pid) {
// DO NOT MODIFY
if (exists(pid) == NULL || index >= size())
return false;
task_struct* tmp = exists(pid);
if (get_task(index)->pid == tmp->pid)
return false;
remove_task(pid);
insert_task(index, tmp->pid, tmp->priority, tmp->remaining_cycles);
return true;
}
task_struct* remove_task(unsigned int pid) {
// DO NOT MODIFY
if (size() == 0)
return NULL;
int sz = size();
task_struct* tmp = head;
if (pid == head->pid) {
head = head->next;
return tmp;
}
for (int i = 0; i < sz - 1; i++) {
if (tmp->next->pid == pid) {
if (tmp->next->pid == tail->pid)
tail = tmp;
task_struct* rem = tmp->next;
tmp->next = rem->next;
return rem;
}
tmp = tmp->next;
}
return NULL;
}
task_struct* exists(unsigned int pid) {
// DO NOT MODIFY
int sz = size();
task_struct* tmp = head;
for (int i = 0; i < sz; i++) {
if (tmp->pid == pid) {
return tmp;
}
tmp = tmp->next;
}
return NULL;
}
task_struct* get_task(unsigned int index) {
// DO NOT MODIFY
if (index >= size())
return NULL;
task_struct* tmp = head;
while (index > 0) {
tmp = tmp->next;
index--;
}
return tmp;
}
bool swap(unsigned int pid_1, unsigned int pid_2) {
// DO NOT MODIFY
task_struct* first = exists(pid_1);
task_struct* second = exists(pid_2);
if (first == NULL || second == NULL || pid_1 == pid_2 || size() == 1)
return false;
task_struct* tmp = malloc(sizeof(task_struct));
tmp->priority = first->priority;
tmp->pid = first->pid;
tmp->remaining_cycles = first->remaining_cycles;
first->priority = second->priority;
first->pid = second->pid;
first->remaining_cycles = second->remaining_cycles;
second->priority = tmp->priority;
second->pid = tmp->pid;
second->remaining_cycles = tmp->remaining_cycles;
free(tmp);
return true;
}
void min_heapify() {
// TODO:
}
void print_tasks() {
// DO NOT MODIFY
task_struct* p_task = head;
if (p_task == NULL) {
printf("[ empty ]\n");
} else {
printf("(%d) [", size());
while (p_task != NULL) {
printf(" %d:%d:%d:%.2f", p_task->pid, p_task->priority,
p_task->remaining_cycles,
(float)p_task->priority / (float)p_task->remaining_cycles);
p_task = p_task->next;
}
printf(" ]\n");
}
}
int compare_floats(float a, float b) {
// DO NOT MODIFY
return fabs(a - b) < EPSILON ? 0 : a < b ? 1 : -1;
}

196
task.h Normal file
View File

@ -0,0 +1,196 @@
// Do not edit this file
#include <math.h>
#include <stdbool.h>
#ifndef _TASK_H_
#define _TASK_H_
#define EPSILON 0.0001
typedef struct task_struct {
unsigned int priority; // lower value means higher priority
// priority ratio used in min heap is
// priority / remaining_cycles
unsigned int pid; // process id
unsigned int remaining_cycles; // remaining CPU cycles needed to complete
// this task. set this to 0 if there would
// be underflow when subtracting. do not set
// to a "negative" number!
struct task_struct* next;
} task_struct;
/**
* Removes all task_structs in the linked list
* (i.e., size = 0 after calling this function).
*
* Deallocates memory used by each task_struct
*
* @return void
*/
void clear();
/**
* @return number of task_structs in the linked list
*/
unsigned int size();
/**
* Create and initialize a new task_struct with the given pid, priority, and
* cycles arguments
*
* And append the task_struct to the end of the linked list
*
* @param pid
* @param priority
* @param cycles
* @return true (success) | false (failure, i.e., duplicate pid in the linked
* list)
*/
bool append_task(unsigned int pid, unsigned int priority, unsigned int cycles);
/**
* Create and initialize a new task_struct with the given pid, priority, and
* cycles arguments
*
* And insert the new task_struct at the given index position
*
* Shifts the task_struct currently at specified index position (if any) and any
* successors to the right, effectively adding 1 to their index positions.
*
* @param index index to insert new task_struct at (i.e., after insertion, the
* new task_struct will be at this index)
* @param pid
* @param priority
* @param cycles
* @return true (success) | false (failure, i.e., duplicate pid or index out of
* range (index > size())
*/
bool insert_task(unsigned int index,
unsigned int pid,
unsigned int priority,
unsigned int cycles);
/**
* Change the location of an existing task_struct (given pid) in the linked list
* to the specified index.
*
* Shifts the task_struct currently at specified index position (if any) and any
* successors to the right, effectively adding 1 to their index positions.
*
* This is accomplished via a call to remove_task and insert_task.
* See the docstring for insert_task to see how shifting of other task_structs
* is handled.
*
* @param index index to set new task_struct to (i.e., after set, the new
* task_struct will be at this index)
* @param pid
* @return true (success) | false (failure, i.e., pid is not in the linked list
* or index out of range (index >= size()))
*/
bool set_task(unsigned int index, unsigned int pid);
/**
* Removes a task_struct (given pid) in the linked list and returns it.
*
* Does not deallocate memory occupied by the task_struct.
*
* @param pid
* @return task_struct* (success) | NULL (failure, i.e., pid is not in the
* linked list)
*/
task_struct* remove_task(unsigned int pid);
/**
* If the task_struct with the given pid exists in the linked list, return it.
* Else, return NULL.
*
* Does not deallocate memory occupied by the task_struct.
*
* @param pid
* @return task_struct* (success) | NULL (failure, i.e., pid is not in the
* linked list)
*/
task_struct* exists(unsigned int pid);
/**
* Get the task_struct at the specified index and return it, if it exists. Else,
* return NULL
*
* Does not deallocate memory occupied by the task_struct.
*
* @param index
* @return task_struct* (success) | NULL (failure, i.e., index out of range
* (index >= size()))
*/
task_struct* get_task(unsigned int index);
/**
* Given two pids, swap the position of the task_structs with those pids.
*
* This can be accomplished simply by swapping the data fields (pid, priority,
* remaining_cycles) of the two task_structs.
*
* @param pid_1
* @param pid_2
* @return true (success) | false (failure, i.e., pid_1 and/or pid_2 are not in
* the linked list or pid_1 == pid_2)
*/
bool swap(unsigned int pid_1, unsigned int pid_2);
/**
* Perform the min heapify algorithm on the linked list (converting it to a
* priority queue), for use in priority-based scheduling
*
* See Heaps.pdf in this repo, which provides pseudocode. The pseudocode
* is for a max heap, but the code for a min heap is very similar.
*
* The position of a task in the priority queue depends on its priority and
* remaining_cycles. Specifically, use the float value priority /
* remaining_cycles.
*
* `priority` is an `unsigned int` and `remaining_cycles` is an
* `unsigned int`, so you have to cast both to `float` when dividing.
* See code for print_tasks()
*
* Use the compare_floats function we provide to compare floats.
* Do not use == with floats.
*
* For example, if Task 1 has priority 1 and remaining_cycles 5 (1/5 = 0.2)
* and Task 2 has priority 5 and remaining_cycles 100 (5/100 = 0.05),
* then Task 2 should be before Task 1 in the queue since 0.05 < 0.2.
*
* If this ratio is the same for two tasks, then the task with lower
* `priority` should come first.
*
* If the `priority` is also the same, then
* the relative ordering of the two tasks should remain the same. For example,
* if comparing two child nodes, the left one would go first, and if comparing
* a child and parent, then the parent would go first. This case will likely
* already be taken care of, depending on your implementation, because the min
* heapify algorithm is stable
* (https://www.geeksforgeeks.org/stable-and-unstable-sorting-algorithms/).
*
* @return void
*/
void min_heapify();
/**
* Print tasks
*
* @return void
*/
void print_tasks();
/**
* Compare two floats
*
* See https://www.geeksforgeeks.org/comparison-float-value-c/
*
* @param a
* @param b
* @return 0 (|a - b| < epsilon) | 1 (a < b) | -1 (a > b)
*/
int compare_floats(float a, float b);
#endif

6
tests/part1/in1.txt Normal file
View File

@ -0,0 +1,6 @@
4
12 50 100
13 1 80
14 40 60
15 0 40
0

9
tests/part1/in2.txt Normal file
View File

@ -0,0 +1,9 @@
7
1 5 10
2 16 17
3 8 24
4 1 36
5 99 100
6 1 62
0 26 80
0

5
tests/part1/out1.txt Normal file
View File

@ -0,0 +1,5 @@
Number of tasks: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: ---- Tasks ----
(num_tasks) [pid:priority:cycles:priority/cycles ...]
(4) [ 12:50:100:0.50 13:1:80:0.01 14:40:60:0.67 15:0:40:0.00 ]
Select scheduling algorithm (0: Display min heap, 1: FCFS, 2: Priority queue, 3: Round robin): ---- Min heap ----
(4) [ 15:0:40:0.00 13:1:80:0.01 14:40:60:0.67 12:50:100:0.50 ]

5
tests/part1/out2.txt Normal file
View File

@ -0,0 +1,5 @@
Number of tasks: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: ---- Tasks ----
(num_tasks) [pid:priority:cycles:priority/cycles ...]
(7) [ 1:5:10:0.50 2:16:17:0.94 3:8:24:0.33 4:1:36:0.03 5:99:100:0.99 6:1:62:0.02 0:26:80:0.32 ]
Select scheduling algorithm (0: Display min heap, 1: FCFS, 2: Priority queue, 3: Round robin): ---- Min heap ----
(7) [ 6:1:62:0.02 4:1:36:0.03 0:26:80:0.32 2:16:17:0.94 5:99:100:0.99 3:8:24:0.33 1:5:10:0.50 ]

6
tests/part2/fcfs_in1.txt Normal file
View File

@ -0,0 +1,6 @@
4
12 50 100
13 1 80
14 40 60
15 0 40
1

9
tests/part2/fcfs_in2.txt Normal file
View File

@ -0,0 +1,9 @@
7
1 5 10
2 16 17
3 8 24
4 1 36
5 99 100
6 1 62
0 26 80
1

12
tests/part2/fcfs_out1.txt Normal file
View File

@ -0,0 +1,12 @@
Number of tasks: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: ---- Tasks ----
(num_tasks) [pid:priority:cycles:priority/cycles ...]
(4) [ 12:50:100:0.50 13:1:80:0.01 14:40:60:0.67 15:0:40:0.00 ]
Select scheduling algorithm (0: Display min heap, 1: FCFS, 2: Priority queue, 3: Round robin): ---- FCFS ----
Task 12 ran for 100 cycles.
Task 12 completed.
Task 13 ran for 80 cycles.
Task 13 completed.
Task 14 ran for 60 cycles.
Task 14 completed.
Task 15 ran for 40 cycles.
Task 15 completed.

18
tests/part2/fcfs_out2.txt Normal file
View File

@ -0,0 +1,18 @@
Number of tasks: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: ---- Tasks ----
(num_tasks) [pid:priority:cycles:priority/cycles ...]
(7) [ 1:5:10:0.50 2:16:17:0.94 3:8:24:0.33 4:1:36:0.03 5:99:100:0.99 6:1:62:0.02 0:26:80:0.32 ]
Select scheduling algorithm (0: Display min heap, 1: FCFS, 2: Priority queue, 3: Round robin): ---- FCFS ----
Task 1 ran for 10 cycles.
Task 1 completed.
Task 2 ran for 17 cycles.
Task 2 completed.
Task 3 ran for 24 cycles.
Task 3 completed.
Task 4 ran for 36 cycles.
Task 4 completed.
Task 5 ran for 100 cycles.
Task 5 completed.
Task 6 ran for 62 cycles.
Task 6 completed.
Task 0 ran for 80 cycles.
Task 0 completed.

6
tests/part2/pr_in1.txt Normal file
View File

@ -0,0 +1,6 @@
4
12 50 100
13 1 80
14 40 60
15 0 40
2

9
tests/part2/pr_in2.txt Normal file
View File

@ -0,0 +1,9 @@
7
1 5 10
2 16 17
3 8 24
4 1 36
5 99 100
6 1 62
0 26 80
2

64
tests/part2/pr_out1.txt Normal file
View File

@ -0,0 +1,64 @@
Number of tasks: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: ---- Tasks ----
(num_tasks) [pid:priority:cycles:priority/cycles ...]
(4) [ 12:50:100:0.50 13:1:80:0.01 14:40:60:0.67 15:0:40:0.00 ]
Select scheduling algorithm (0: Display min heap, 1: FCFS, 2: Priority queue, 3: Round robin): ---- Priority queue ----
Task 15 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 15 completed.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 completed.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 14 completed.
Task 12 ran for 5 cycles.
Task 12 completed.

79
tests/part2/pr_out2.txt Normal file
View File

@ -0,0 +1,79 @@
Number of tasks: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: ---- Tasks ----
(num_tasks) [pid:priority:cycles:priority/cycles ...]
(7) [ 1:5:10:0.50 2:16:17:0.94 3:8:24:0.33 4:1:36:0.03 5:99:100:0.99 6:1:62:0.02 0:26:80:0.32 ]
Select scheduling algorithm (0: Display min heap, 1: FCFS, 2: Priority queue, 3: Round robin): ---- Priority queue ----
Task 6 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 3 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 3 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 6 ran for 2 cycles.
Task 6 completed.
Task 1 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 3 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 3 ran for 5 cycles.
Task 2 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 4 ran for 1 cycles.
Task 4 completed.
Task 1 ran for 5 cycles.
Task 1 completed.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 2 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 3 ran for 4 cycles.
Task 3 completed.
Task 5 ran for 5 cycles.
Task 2 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 0 completed.
Task 5 ran for 5 cycles.
Task 2 ran for 2 cycles.
Task 2 completed.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 completed.

6
tests/part2/rr_in1.txt Normal file
View File

@ -0,0 +1,6 @@
4
12 50 100
13 1 80
14 40 60
15 0 40
3

9
tests/part2/rr_in2.txt Normal file
View File

@ -0,0 +1,9 @@
7
1 5 10
2 16 17
3 8 24
4 1 36
5 99 100
6 1 62
0 26 80
3

64
tests/part2/rr_out1.txt Normal file
View File

@ -0,0 +1,64 @@
Number of tasks: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: ---- Tasks ----
(num_tasks) [pid:priority:cycles:priority/cycles ...]
(4) [ 12:50:100:0.50 13:1:80:0.01 14:40:60:0.67 15:0:40:0.00 ]
Select scheduling algorithm (0: Display min heap, 1: FCFS, 2: Priority queue, 3: Round robin): ---- Round robin ----
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 15 ran for 5 cycles.
Task 15 completed.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 14 ran for 5 cycles.
Task 14 completed.
Task 13 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 13 ran for 5 cycles.
Task 13 completed.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 ran for 5 cycles.
Task 12 completed.

79
tests/part2/rr_out2.txt Normal file
View File

@ -0,0 +1,79 @@
Number of tasks: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: pid priority cycles: ---- Tasks ----
(num_tasks) [pid:priority:cycles:priority/cycles ...]
(7) [ 1:5:10:0.50 2:16:17:0.94 3:8:24:0.33 4:1:36:0.03 5:99:100:0.99 6:1:62:0.02 0:26:80:0.32 ]
Select scheduling algorithm (0: Display min heap, 1: FCFS, 2: Priority queue, 3: Round robin): ---- Round robin ----
Task 1 ran for 5 cycles.
Task 2 ran for 5 cycles.
Task 3 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 1 ran for 5 cycles.
Task 1 completed.
Task 3 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 2 ran for 5 cycles.
Task 3 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 2 ran for 5 cycles.
Task 3 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 2 ran for 2 cycles.
Task 2 completed.
Task 4 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 3 ran for 4 cycles.
Task 3 completed.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 4 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 4 ran for 1 cycles.
Task 4 completed.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 6 ran for 2 cycles.
Task 6 completed.
Task 5 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 0 ran for 5 cycles.
Task 0 completed.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 ran for 5 cycles.
Task 5 completed.