Compare commits
1 Commits
rusting-ti
...
main
| Author | SHA1 | Date | |
|---|---|---|---|
| c4d3d94042 |
307
src/main.rs
307
src/main.rs
@@ -1,86 +1,86 @@
|
||||
use std::io;
|
||||
pub mod rr;
|
||||
fn main() {
|
||||
// Take user input
|
||||
let proc_num: i32;
|
||||
let mut processes: Vec<Process> = vec![];
|
||||
// Take user input
|
||||
let proc_num: i32;
|
||||
let mut processes: Vec<Process> = vec![];
|
||||
|
||||
let mut input: String = String::from("");
|
||||
println!("Enter process number!");
|
||||
_ = io::stdin().read_line(&mut input);
|
||||
proc_num = input.trim().parse().expect("NOT NUMBER");
|
||||
let mut input: String = String::from("");
|
||||
println!("Enter process number!");
|
||||
_ = io::stdin().read_line(&mut input);
|
||||
proc_num = input.trim().parse().expect("NOT NUMBER");
|
||||
|
||||
let mut num: i32 = 0;
|
||||
while num < proc_num {
|
||||
println!("Enter arrival for process");
|
||||
let mut temp_arrival = String::new();
|
||||
_ = io::stdin().read_line(&mut temp_arrival);
|
||||
let temp_arrival: i32 = temp_arrival.trim().parse().expect("AAAAAA");
|
||||
let mut num: i32 = 0;
|
||||
while num < proc_num {
|
||||
println!("Enter arrival for process");
|
||||
let mut temp_arrival = String::new();
|
||||
_ = io::stdin().read_line(&mut temp_arrival);
|
||||
let temp_arrival: i32 = temp_arrival.trim().parse().expect("AAAAAA");
|
||||
|
||||
println!("Enter burst for process");
|
||||
let mut temp_burst = String::new();
|
||||
_ = io::stdin().read_line(&mut temp_burst);
|
||||
let temp_burst: i32 = temp_burst.trim().parse().expect("AAAAAA");
|
||||
println!("Enter burst for process");
|
||||
let mut temp_burst = String::new();
|
||||
_ = io::stdin().read_line(&mut temp_burst);
|
||||
let temp_burst: i32 = temp_burst.trim().parse().expect("AAAAAA");
|
||||
|
||||
let temp_proc = Process {
|
||||
arrival: temp_arrival,
|
||||
burst: temp_burst,
|
||||
turnaround: 0,
|
||||
waiting: 0,
|
||||
remaining: temp_burst,
|
||||
completion_time: 0,
|
||||
};
|
||||
processes.push(temp_proc);
|
||||
num += 1;
|
||||
}
|
||||
println!("sorting!");
|
||||
let sorted = rr::round_robin(processes, 1);
|
||||
// let sorted = round_robin(processes, vec![], 0, 2);
|
||||
println!("You've entered: ");
|
||||
for proc in sorted {
|
||||
println!("{:#?}", proc)
|
||||
}
|
||||
let temp_proc = Process {
|
||||
arrival: temp_arrival,
|
||||
burst: temp_burst,
|
||||
turnaround: 0,
|
||||
waiting: 0,
|
||||
remaining: temp_burst,
|
||||
completion_time: 0,
|
||||
};
|
||||
processes.push(temp_proc);
|
||||
num += 1;
|
||||
}
|
||||
println!("sorting!");
|
||||
let completed: Vec<Process> = vec![];
|
||||
let sorted = sjf(processes, completed, 100);
|
||||
// let sorted = round_robin(processes, vec![], 0, 2);
|
||||
println!("You've entered: ");
|
||||
for proc in sorted {
|
||||
println!("{:#?}", proc)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct Process {
|
||||
arrival: i32,
|
||||
burst: i32,
|
||||
turnaround: i32,
|
||||
waiting: i32,
|
||||
remaining: i32,
|
||||
completion_time: i32,
|
||||
arrival: i32,
|
||||
burst: i32,
|
||||
turnaround: i32,
|
||||
waiting: i32,
|
||||
remaining: i32,
|
||||
completion_time: i32,
|
||||
}
|
||||
impl Process {
|
||||
pub fn quan_zap(self, q: i32, current: i32) -> (i32, i32) {
|
||||
if q < 0 {
|
||||
println!("Why would you ever do this?");
|
||||
return (0, 0);
|
||||
}
|
||||
if self.remaining >= q {
|
||||
(self.remaining - q, current + q)
|
||||
} else {
|
||||
(0, current + self.remaining)
|
||||
}
|
||||
}
|
||||
pub fn calc_turn(self) -> i32 {
|
||||
self.completion_time - self.arrival
|
||||
}
|
||||
pub fn calc_wait(self) -> i32 {
|
||||
self.turnaround - self.burst
|
||||
}
|
||||
pub fn one_shot(mut self, current: i32) -> (Process, i32) {
|
||||
self.completion_time = current + self.remaining;
|
||||
self.remaining = 0;
|
||||
(self, self.completion_time)
|
||||
}
|
||||
pub fn robin_zap(self, q: i32) -> i32 {
|
||||
if self.remaining >= q {
|
||||
self.remaining - q
|
||||
} else {
|
||||
0
|
||||
}
|
||||
}
|
||||
pub fn quan_zap(self, q: i32, current: i32) -> (i32, i32) {
|
||||
if q < 0 {
|
||||
println!("Why would you ever do this?");
|
||||
return (0, 0);
|
||||
}
|
||||
if self.remaining >= q {
|
||||
(self.remaining - q, current + q)
|
||||
} else {
|
||||
(0, current + self.remaining)
|
||||
}
|
||||
}
|
||||
pub fn calc_turn(self) -> i32 {
|
||||
self.completion_time - self.arrival
|
||||
}
|
||||
pub fn calc_wait(self) -> i32 {
|
||||
self.turnaround - self.burst
|
||||
}
|
||||
pub fn one_shot(mut self, current: i32) -> (Process, i32) {
|
||||
self.completion_time = current + self.remaining;
|
||||
self.remaining = 0;
|
||||
(self, self.completion_time)
|
||||
}
|
||||
pub fn robin_zap(self, q: i32) -> i32 {
|
||||
if self.remaining >= q {
|
||||
self.remaining - q
|
||||
} else {
|
||||
0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// pub fn srt(procs: Vec<Process>, q: i32) -> Vec<Process> {
|
||||
@@ -92,105 +92,84 @@ impl Process {
|
||||
// }
|
||||
|
||||
pub fn fifo(mut procs: Vec<Process>) -> Vec<Process> {
|
||||
procs.sort_by(|a, b| a.arrival.cmp(&b.arrival));
|
||||
let mut clock = procs[0].arrival;
|
||||
let mut completed: Vec<Process> = vec![];
|
||||
for proc in procs {
|
||||
if proc.arrival <= clock {
|
||||
let mut done_proc: Process;
|
||||
(done_proc, clock) = proc.one_shot(clock);
|
||||
done_proc.turnaround = done_proc.calc_turn();
|
||||
done_proc.waiting = done_proc.calc_wait();
|
||||
completed.push(done_proc);
|
||||
}
|
||||
}
|
||||
completed
|
||||
procs.sort_by(|a, b| a.arrival.cmp(&b.arrival));
|
||||
let mut clock = procs[0].arrival;
|
||||
let mut completed: Vec<Process> = vec![];
|
||||
for proc in procs {
|
||||
if proc.arrival <= clock {
|
||||
let mut done_proc: Process;
|
||||
(done_proc, clock) = proc.one_shot(clock);
|
||||
done_proc.turnaround = done_proc.calc_turn();
|
||||
done_proc.waiting = done_proc.calc_wait();
|
||||
completed.push(done_proc);
|
||||
}
|
||||
}
|
||||
completed
|
||||
}
|
||||
|
||||
pub fn sjf(mut procs: Vec<Process>, mut completed: Vec<Process>, mut clock: i32) -> Vec<Process> {
|
||||
procs.sort_unstable_by_key(|proc| (proc.burst, proc.arrival));
|
||||
// procs.sort_unstable_by_key(|proc| (proc.arrival, proc.burst));
|
||||
|
||||
if procs.is_empty() {
|
||||
completed
|
||||
} else {
|
||||
let mut i = 0;
|
||||
while i < procs.len() {
|
||||
if procs[i].arrival <= clock {
|
||||
let mut done_proc: Process;
|
||||
(done_proc, clock) = procs[i].one_shot(clock);
|
||||
done_proc.turnaround = done_proc.calc_turn();
|
||||
done_proc.waiting = done_proc.calc_wait();
|
||||
completed.push(done_proc);
|
||||
procs.remove(i);
|
||||
return sjf(procs, completed, clock);
|
||||
} else {
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
sjf(procs, completed, clock + 1)
|
||||
}
|
||||
if procs.is_empty() {
|
||||
completed
|
||||
} else {
|
||||
let mut i = 0;
|
||||
while i < procs.len() {
|
||||
if procs[i].arrival <= clock {
|
||||
let mut done_proc: Process;
|
||||
(done_proc, clock) = procs[i].one_shot(clock);
|
||||
done_proc.turnaround = done_proc.calc_turn();
|
||||
done_proc.waiting = done_proc.calc_wait();
|
||||
completed.push(done_proc);
|
||||
procs.remove(i);
|
||||
return sjf(procs, completed, clock);
|
||||
} else {
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
sjf(procs, completed, clock + 1)
|
||||
}
|
||||
}
|
||||
pub fn round_robin(procs: Vec<Process>, q: i32) -> Vec<Process> {
|
||||
let mut buffer = procs.to_owned();
|
||||
buffer.sort_by(|a, b| a.arrival.cmp(&b.arrival));
|
||||
let mut current_time = 0;
|
||||
let mut in_cpu: Vec<Process> = vec![];
|
||||
let mut done: Vec<Process> = vec![];
|
||||
let mut last: Process = Process {
|
||||
arrival: 0,
|
||||
burst: 0,
|
||||
completion_time: 0,
|
||||
remaining: 0,
|
||||
turnaround: 0,
|
||||
waiting: 0,
|
||||
};
|
||||
loop {
|
||||
let (ready, not_ready) = check_arrival(buffer, current_time);
|
||||
buffer = not_ready;
|
||||
in_cpu = into_cpu(ready.to_owned(), in_cpu);
|
||||
if last.remaining > 0 {
|
||||
in_cpu.push(last)
|
||||
}
|
||||
if !in_cpu.is_empty() {
|
||||
last = in_cpu.remove(0);
|
||||
(last.remaining, current_time) = last.quan_zap(q, current_time);
|
||||
done = check_done(last, current_time, done);
|
||||
}
|
||||
println!("{}", done.len());
|
||||
println!("{}, {}", buffer.len(), ready.len());
|
||||
if done.len() == procs.len() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
done
|
||||
}
|
||||
pub fn check_arrival(buffer: Vec<Process>, current_time: i32) -> (Vec<Process>, Vec<Process>) {
|
||||
let mut ready: Vec<Process> = vec![];
|
||||
let mut not_ready: Vec<Process> = vec![];
|
||||
for proc in buffer {
|
||||
if proc.remaining <= current_time {
|
||||
ready.push(proc);
|
||||
} else {
|
||||
not_ready.push(proc);
|
||||
}
|
||||
}
|
||||
|
||||
(ready, not_ready)
|
||||
}
|
||||
pub fn into_cpu(ready: Vec<Process>, mut cpu: Vec<Process>) -> Vec<Process> {
|
||||
for proc in ready {
|
||||
cpu.push(proc);
|
||||
}
|
||||
cpu
|
||||
}
|
||||
pub fn check_done(mut proc: Process, current_time: i32, mut done: Vec<Process>) -> Vec<Process> {
|
||||
if proc.remaining == 0 {
|
||||
proc.completion_time = current_time;
|
||||
proc.turnaround = proc.calc_turn();
|
||||
proc.waiting = proc.calc_wait();
|
||||
done.push(proc);
|
||||
}
|
||||
done
|
||||
let mut buffer = procs;
|
||||
let mut current_time = 0;
|
||||
let mut in_cpu: Vec<Process> = vec![];
|
||||
let mut done: Vec<Process> = vec![];
|
||||
while !buffer.is_empty() || !in_cpu.is_empty() {
|
||||
let mut counter = 0;
|
||||
if !buffer.is_empty() {
|
||||
for proc in buffer.to_owned() {
|
||||
if buffer.is_empty() {
|
||||
continue;
|
||||
}
|
||||
if proc.arrival <= current_time {
|
||||
in_cpu.push(proc);
|
||||
buffer.remove(counter);
|
||||
}
|
||||
counter += 1;
|
||||
}
|
||||
}
|
||||
if !in_cpu.is_empty() {
|
||||
let mut current_proc = in_cpu.remove(0);
|
||||
if current_proc.remaining < q {
|
||||
current_time += current_proc.remaining;
|
||||
} else {
|
||||
current_time += q;
|
||||
}
|
||||
current_proc.remaining = current_proc.robin_zap(q);
|
||||
if current_proc.remaining == 0 {
|
||||
current_proc.completion_time = current_time;
|
||||
current_proc.turnaround = current_proc.calc_turn();
|
||||
current_proc.waiting = current_proc.calc_wait();
|
||||
done.push(current_proc);
|
||||
} else {
|
||||
in_cpu.push(current_proc);
|
||||
}
|
||||
} else {
|
||||
current_time += 1;
|
||||
}
|
||||
}
|
||||
done
|
||||
}
|
||||
|
||||
// This code sucks!
|
||||
|
||||
80
src/rr.rs
80
src/rr.rs
@@ -1,80 +0,0 @@
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::Process;
|
||||
pub fn round_robin(procs: Vec<Process>, q: i32) -> VecDeque<Process> {
|
||||
let mut buffer = procs.to_owned();
|
||||
buffer.sort_by(|a, b| a.arrival.cmp(&b.arrival));
|
||||
let mut current_time = 0;
|
||||
let mut in_cpu: VecDeque<Process> = VecDeque::new();
|
||||
let mut done: VecDeque<Process> = VecDeque::new();
|
||||
let mut last: Process = Process {
|
||||
arrival: 0,
|
||||
burst: 0,
|
||||
completion_time: 0,
|
||||
remaining: 0,
|
||||
turnaround: 0,
|
||||
waiting: 0,
|
||||
};
|
||||
loop {
|
||||
if done.len() == procs.len() {
|
||||
break;
|
||||
}
|
||||
|
||||
let (ready, not_ready) = check_arrival(buffer.to_owned(), current_time);
|
||||
in_cpu = into_cpu(ready.to_owned(), in_cpu);
|
||||
|
||||
if last.remaining > 0 {
|
||||
in_cpu.push_back(last)
|
||||
}
|
||||
|
||||
match in_cpu.pop_front() {
|
||||
Some(mut proc) => {
|
||||
(proc.remaining, current_time) = proc.quan_zap(q, current_time);
|
||||
done = check_done(proc, current_time, done);
|
||||
if proc.remaining != 0 {
|
||||
last = proc;
|
||||
}
|
||||
}
|
||||
None => current_time += 1,
|
||||
};
|
||||
println!("current time: {}", current_time);
|
||||
println!("in_cpu: {}", in_cpu.len());
|
||||
// println!("last remaining time: {}", last.remaining);
|
||||
// println!("currently done: {}", done.len());
|
||||
println!("buffer: {}, ready: {}", buffer.len(), ready.len());
|
||||
}
|
||||
done
|
||||
}
|
||||
pub fn check_arrival(buffer: Vec<Process>, current_time: i32) -> (VecDeque<Process>, Vec<Process>) {
|
||||
let mut ready: VecDeque<Process> = VecDeque::new();
|
||||
let mut not_ready: Vec<Process> = vec![];
|
||||
for proc in buffer {
|
||||
if proc.arrival <= current_time {
|
||||
ready.push_back(proc)
|
||||
} else {
|
||||
not_ready.push(proc)
|
||||
}
|
||||
}
|
||||
(ready, not_ready)
|
||||
}
|
||||
pub fn into_cpu(ready: VecDeque<Process>, mut cpu: VecDeque<Process>) -> VecDeque<Process> {
|
||||
for proc in ready {
|
||||
cpu.push_back(proc);
|
||||
}
|
||||
cpu
|
||||
}
|
||||
pub fn check_done(
|
||||
mut proc: Process,
|
||||
current_time: i32,
|
||||
mut done: VecDeque<Process>,
|
||||
) -> VecDeque<Process> {
|
||||
if proc.remaining == 0 {
|
||||
proc.completion_time = current_time;
|
||||
proc.turnaround = proc.calc_turn();
|
||||
proc.waiting = proc.calc_wait();
|
||||
done.push_back(proc);
|
||||
}
|
||||
done
|
||||
}
|
||||
|
||||
// This code sucks!
|
||||
Reference in New Issue
Block a user