Breaking News: Grepper is joining You.com. Read the official announcement!

rust Round Robin

Claus answered on December 25, 2022 Popularity 1/10 Helpfulness 1/10

answer rust Round Robin

rust Round Robin

Comment

use rand::Rng;

#[derive(Clone)]
struct Process {
    pid: i32,
    burst: i32,
}

impl Process {
    fn init(size: i32, list: &mut Vec<Self>) {
        let mut rng = rand::thread_rng();
        println!("Random u32: {}", rng.gen::<i32>());
        for i in 0..size as usize {
            list.push(Process {pid: i as i32, burst:  rng.gen_range(1, 30)});
        }
    }
    fn print_process(list: &Vec<Self>) {
        let last = list.len()-1;
        print!("[ ");
        for i in 0..last {
            print!("(PID: {} BURST: {}), ", list[i].pid, list[i].burst);
        }
        print!("(PID: {} BURST: {}) ]\n", list[last].pid, list[last].burst);
    }
}

fn find_waiting_time(list: &mut Vec<Process>, size: usize, wt: &mut Vec<Process>, quantum: i32) {
    let mut local_burst_time: Vec<i32> = vec![0; size];
    for i in 0..size {
        local_burst_time[i] = list[i].burst;
    }

    let mut t = 0;
    println!("wt len {}", wt.len());

    loop {
        let mut done = false;
        for i in 0..size {
            if local_burst_time[i] > 0 {
                done = true;
                if local_burst_time[i] > quantum {
                    t += quantum;
                    local_burst_time[i] -= quantum;
                } else {
                    t+= local_burst_time[i];
                    wt[i].pid = list[i].pid;
                    wt[i].burst = t - list[i].burst;
                    local_burst_time[i] = 0;
                }
            }
        }
        if done == false {
            break;
        }
    }
}

fn find_turn_around_time(list: &mut Vec<Process>, size: usize, wt: &mut Vec<Process>, tat: &mut Vec<Process>) {
    for i in 0..size {
        tat[i].burst = list[i].burst + wt[i].burst;
    }
}

fn find_avg_time(list: &mut Vec<Process>, quantum: i32) {
    let size = list.len();
    let var = Process {pid: 0, burst: 0};
    let mut wt: Vec<Process> = vec![var.clone(); size];
    let mut tat: Vec<Process> = vec![var; size];
    
    find_waiting_time(list ,size, &mut wt, quantum);
    find_turn_around_time(list, size, &mut wt, &mut tat);

    let (mut total_wt, mut total_tat) = (0, 0);
    println!("PN\t\tB\t\tWT\t\tTAT");

    for i in 0..size {
        total_wt += wt[i].burst;
        total_tat += tat[i].burst;
        println!("{}\t\t{}\t\t{}\t\t{}", list[i].pid, list[i].burst, wt[i].burst, tat[i].burst);
    }
    println!("Averange waiting time = {}", (total_wt/size as i32));
    println!("Averange turn around time = {}", (total_tat/size as i32))
} 

fn main() {
    let mut process_list = Vec::<Process>::new();
    Process::init(5, &mut process_list);
    Process::print_process(&process_list);
    let quantum = 2;
    find_avg_time(&mut process_list, quantum);
    
}

Popularity 1/10 Helpfulness 1/10 Language rust

Source: www.geeksforgeeks.org

Tags: round-robin rust

Link to this answer
Share Copy Link

Contributed on Dec 25 2022

Claus

0 Answers Avg Quality 2/10

rust Round Robin

Contents

More Related Answers

rust Round Robin

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.