Implementing round robin scheduling algorithm in Java

Question

After hours of braining I've finally crashed and have come to result that I have no clue how to implement round robin into java. I've tried different approaches and the closest I've got.. well i explain with an example..

AT = Arrival Time
BT = Burst Time (Execution Time)

At first i have this row of numbers (0,5;6,9;6,5;15,10) where elements in position 0-2-4 represent arrival times and elements in position 1-3-5 represent burst times. My code is so far that this input is turned into a class, called Process which comes with a constructor: Process(String name, int AT, int BT). I've separated processes with in the ArrayList. So now i have an ArrayList alst = [P0,P1,P2,P3] where P0 has AT 0 and BT 5 and so on`..

I created a method which will return me a list of processes which have been cut with a quantum of time - For example in case of (0,5;6,9;6,5;15,10) i will get a result: [P0,P0,P1,P1,P1,P2,P2,P3,P3,P3,P3]

So round robin method is a method where every process gets quantum time for execution which I've chosen 3.

P0 with AT 0 & BT 3 comes in - added to the final list (time passed = 3)
P0 with AT 0 & BT 2 comes in - added to the final list (time passed = 5)
P0 finished
P1 with AT 6 & BT 3 comes in - added to the final list (time passed = 9)
next P1 is added to the queue
P2 with AT 6 & BT 3 comes in - added to the final list (time passed = 12)
next P2 is added to the queue
P1 with AT 6 & BT 3 comes in from queue - added to the final list (time passed = 15)
next P1 goes to the queue
P3 arrives, added to the final list (time passed = 18)
P1 comes from the queue - added to the final list

And that's the point where I feel like my mind has crashed and i have no idea how to queue them.

The result should look like: [P0,P0,P1,P2,P1,P3,P2,P1,P3,P3,P3]

What I coded based on the first answer given. Still doesn't work..

public ArrayList roundRobinJarjestus(ArrayList pstlst) {
    ArrayList queue = new ArrayList();// järjekord, alguses tühi
    ArrayList uuspst = new ArrayList();
    queue.add(pstlst.get(0));
    int i = 0;
    double time = 0;
    double pworkTime = 0;
    int kvant = 3;

    while (i < pstlst.size()) {
        Protsess p = (Protsess) queue.get(i); //first process is taken
        pworkTime = p.getTooaeg(); //execute time
        time = time + pworkTime;

        // if next arrival time is lower than time passed
        if (((Protsess) pstlst.get(i + 1)).getSaabumisaeg() < time) {
            queue.add(pstlst.get(i + 1));
        }

        // if worktime - quantum is higher than zero
        // and still left something to execute
        if (pworkTime - kvant > 0) {
            p.setTooaeg(pworkTime - kvant);
            queue.add(p);
        }
        uuspst.add(queue.get(i));
        i = i + 1;
    }
    return uuspst;
}

It would be helpful, if you describe the algorythm and what 'arrive time' and 'burst time' means — AdamSkywalker, Oct 25 '14 at 14:40
i think AT=the first time at which the processes made a request for a resource. BT=amount of time a resource required to complete it's task. — Karunakar, Oct 25 '14 at 14:44

score 3 · Answer 1 · answered Oct 25 '14 at 15:36

3

You can maintain a queue of waiting processes and use the following algorithm:

Pick the first process in the queue(if it is not empty). Add it to the output list.
Execute it for a given quantum of time(or less if its remaining time is less then one quantum) and subtract this quantum from the remaining time of this process.
If new processes have arrived, add them to the end of the queue.
If the last executed process is not finished(that is, its remaining time is not 0), add it to the end of the waiting queue.
Go to step 1 if there are any processes left.

answered Oct 25 '14 at 15:36

kraskevich

18,368
4
33
45

How are the items selected in the queue? – charen Oct 25 '14 at 15:44
@charen The head of the queue is always selected and removed. – kraskevich Oct 25 '14 at 15:47
Should i keep with the idea where i separated processes with quantum time or should start from where i have them according to full arrival + execute time? – charen Oct 25 '14 at 16:08
@charen I would not separate them(because it is not required by this algorithm and it does not make the problem or implementation easier). – kraskevich Oct 25 '14 at 16:10
@charen Yes. 3 can also require a loop. – kraskevich Oct 25 '14 at 16:15
What happens if queue is empty at the start? or should i start with by adding first process into queue ? – charen Oct 25 '14 at 16:16
@charen You can deal with it this way: while the queue is empty, wait for the first process to arrive. – kraskevich Oct 25 '14 at 16:18
@charen You code does not implement the algorithm described in my answer. The processes should be stored in a `Queue` and the first one should be obtained using `poll` method. – kraskevich Oct 25 '14 at 17:48

score 0 · Answer 2 · answered Dec 21 '14 at 19:51

package cpuSch;

import java.io.*;

class fcfs
    {
    public static void main(String args[]) throws Exception
    {
        int n,AT[],BT[],WT[],TAT[];
        float AWT=0;

        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br=new BufferedReader(isr);

            System.out.println("Enter no of process");

        n=Integer.parseInt(br.readLine());
        BT=new int[n];
        WT=new int[n];
        TAT=new int[n];
        AT=new int[n];
            System.out.println("Enter Burst time for each                                                                                                                    process\n______________________________");
            for(int i=0;i<n;i++)
        {
            System.out.println("Enter BT for process "+(i+1));
        BT[i]=Integer.parseInt(br.readLine());
        }
        System.out.println("______________________________");
    for(int i=0;i<n;i++)
    {
        System.out.println("Enter AT for process"+i);
    AT[i]=Integer.parseInt(br.readLine());
    }
        System.out.println("______________________________");
    WT[0]=0;

    for(int i=1;i<n;i++)
    {
        WT[i]=WT[i-1]+BT[i-1];
        WT[i]=WT[i]-AT[i];
    }

    for(int i=0;i<n;i++)
    {
        TAT[i]=WT[i]+BT[i];
        AWT=AWT+WT[i];
    }
        System.out.println("  PROCESS   BT      WT      TAT     ");

    for(int i=0;i<n;i++)
    {
        System.out.println("    "+ i + "       "+BT[i]+"       "+WT[i]+"       "+TAT[i]);}
        AWT=AWT/n;
        System.out.println("___________________________________________");
        System.out.println("Average WT="+AWT+"\n___________________________________________");
    }
 }

score -3 · Answer 3 · answered Dec 19 '14 at 22:21

Example Code

import java.io.*;
class fcfs
{
public static void main(String args[]) throws Exception
{
int n,AT[],BT[],WT[],TAT[];
float AWT=0;
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.println("Enter no of process");
n=Integer.parseInt(br.readLine());
BT=new int[n];
WT=new int[n];
TAT=new int[n];
AT=new int[n];
System.out.println("Enter Burst time for each process\n******************************");
for(int i=0;i<n;i++)
{
System.out.println("Enter BT for process "+(i+1));
BT[i]=Integer.parseInt(br.readLine());
}
System.out.println("***********************************************");
for(int i=0;i<n;i++)
{
System.out.println("Enter AT for process"+i);
AT[i]=Integer.parseInt(br.readLine());
}
System.out.println("***********************************************");
WT[0]=0;
for(int i=1;i<n;i++)
{
WT[i]=WT[i-1]+BT[i-1];
WT[i]=WT[i]-AT[i];
}  
for(int i=0;i<n;i++)
{
TAT[i]=WT[i]+BT[i];
AWT=AWT+WT[i];
}
System.out.println("  PROCESS   BT      WT      TAT     ");
for(int i=0;i<n;i++)
{System.out.println("    "+ i + "       "+BT[i]+"       "+WT[i]+"       "+TAT[i]);}
AWT=AWT/n;
System.out.println("***********************************************");
System.out.println("Avg waiting time="+AWT+"\n***********************************************");

}
}

Implementing round robin scheduling algorithm in Java

3 Answers3

Linked