Stimulated scheduling assignment help provided by expert programmers

#include
// Function to find the waiting time for all
// processes
void findWaitingTime(int processes[], int n,
             int bt[], int wt[], int quantum)
{
    // Make a copy of burst times bt[] to store remaining
    // burst times.
    int rem_bt[n];
    for (int i = 0 ; i < n ; i++)
        rem_bt[i] =  bt[i];
    int t = 0; // Current time
    // Keep traversing processes in round robin manner
    // until all of them are not done.
    while (1)
    {
        int done = 1;
        // Traverse all processes one by one repeatedly
        for (int i = 0 ; i < n; i++)
        {
            // If burst time of a process is greater than 0
            // then only need to process further
            if (rem_bt[i] > 0)
            {
                done = 0; // There is a pending process
                if (rem_bt[i] > quantum)
                {
                    // Increase the value of t i.e. shows
                    // how much time a process has been processed
                    t += quantum;
                    // Decrease the burst_time of current process
                    // by quantum
                    rem_bt[i] -= quantum;
                }
                // If burst time is smaller than or equal to
                // quantum. Last cycle for this process
                else
                {
                    // Increase the value of t i.e. shows
                    // how much time a process has been processed
                    t = t + rem_bt[i];
                    // Waiting time is current time minus time
                    // used by this process
                    wt[i] = t - bt[i];
                    // As the process gets fully executed
                    // make its remaining burst time = 0
                    rem_bt[i] = 0;
                }
            }
        }
        // If all processes are done
        if (done == 1)
          break;
    }
}
// Function to calculate turn around time
void findTurnAroundTime(int processes[], int n,
                        int bt[], int wt[], int tat[])
{
    // calculating turnaround time by adding
    // bt[i] + wt[i]
    for (int i = 0; i < n ; i++)
        tat[i] = bt[i] + wt[i];
}
// Function to calculate average time
void findavgTime(int processes[], int n, int bt[],
                                     int quantum)
{
    int wt[n], tat[n], total_wt = 0, total_tat = 0;
    // Function to find waiting time of all processes
    findWaitingTime(processes, n, bt, wt, quantum);
    // Function to find turn around time for all processes
    findTurnAroundTime(processes, n, bt, wt, tat);
    // Display processes along with all details
    printf("Processes  Burst time  Waiting time  Turn around time\n");
    // Calculate total waiting time and total turn
    // around time
    for (int i=0; i<n; i++)
    {
        total_wt = total_wt + wt[i];
        total_tat = total_tat + tat[i];
        printf(" %c\t\t%d\t %d\t\t%d\n",(char)(processes[i]+64),bt[i],wt[i],tat[i]);
    }
    printf("Average waiting time = %f",(float)total_wt/(float)n);
    printf("\nAverage turn around time = %f",(float)total_tat / (float)n);
}
// Driver code
int main()
{
    // process id's
    int processes[10];
    int n = 10;
    // Burst time of all processes
    int burst_time[10] = {16,2,11,6,1,9,4,14,1,8};
    int i,j,pos,temp;
    for(i=0;i<n;i++)
    {
        processes[i]=i+1;           //contains process number
    }
    //sorting burst time in ascending order using selection sort
    for(i=0;i<n;i++)
    {
        pos=i;
        for(j=i+1;j<n;j++)
        {
            if(burst_time[j]<burst_time[pos])
                pos=j;
        }
        temp=burst_time[i];
        burst_time[i]=burst_time[pos];
        burst_time[pos]=temp;
        temp=processes[i];
        processes[i]=processes[pos];
        processes[pos]=temp;
    }
    printf("\nThe order of execution is:");
    for(i=0;i<n;i++)
    {
        printf("\n%c",(char)(processes[i]+64));
    }
    // Time quantum
    int quantum = 2;
    findavgTime(processes, n, burst_time, quantum);
    return 0;
}

#include
//I have used burst time which stands for no. of Cpu cycles in the assignment
int main(void)
{
    int p[20],wt[20],tat[20],i,j,n,total=0,pos,temp;
    float avg_wt,avg_tat;
    n=10;
    int bt[10]={16,2,11,6,1,9,4,14,1,8};
    /*printf("Enter number of process:");
    scanf("%d",&n);
    printf("\nEnter Burst Time:\n");
    for(i=0;i
    {
        printf("%c:",char(i+65));
        scanf("%d",&bt[i]);
        p[i]=i+1;           //contains process number
    }*/
    // the above commented code can be used for any kind of input
    for(i=0;i<n;i++)
    {
        p[i]=i+1;           //contains process number
    }
    //sorting burst time in ascending order using selection sort
    for(i=0;i<n;i++)
    {
        pos=i;
        for(j=i+1;j<n;j++)
        {
            if(bt[j]<bt[pos])
                pos=j;
        }
        temp=bt[i];
        bt[i]=bt[pos];
        bt[pos]=temp;
        temp=p[i];
        p[i]=p[pos];
        p[pos]=temp;
    }
    wt[0]=0;            //waiting time for first process will be zero
    //calculate waiting time
    for(i=1;i<n;i++)
    {
        wt[i]=0;
        for(j=0;j<i;j++)
            wt[i]+=bt[j];
        total+=wt[i];
    }
    avg_wt=(float)total/n;      //average waiting time
    total=0;
    printf("\nThe order of execution is:");
    for(i=0;i<n;i++)
    {
        printf("\n%c",(char)(p[i]+64));
    }
    printf("\n\nProcess\t    Burst Time    \tWaiting Time\tTurnaround Time");
    for(i=0;i<n;i++)
    {
        tat[i]=bt[i]+wt[i];     //calculate turnaround time
        total+=tat[i];
        printf("\n%c\t\t  %d\t\t    %d\t\t\t%d",(char)(p[i]+64),bt[i],wt[i],tat[i]);
    }
    avg_tat=(float)total/n;     //average turnaround time
    printf("\n\nAverage Waiting Time=%f",avg_wt);
    printf("\nAverage Turnaround Time=%f\n",avg_tat);
}

#include
struct Proces
{
    int pid; // Process ID
    int bt; // Burst Time
    int art; // Arrival Time
};
typedef struct Proces Process;
// Function to find the waiting time for all
// processes
void findWaitingTime(Process proc[], int n,
                                int wt[])
{
    int rt[n];
    // Copy the burst time into rt[]
    for (int i = 0; i < n; i++)
        rt[i] = proc[i].bt;
    int complete = 0, t = 0, minm = 9999999;
    int shortest = 0, finish_time;
    int check = 0;
    // Process until all processes gets
    // completed
    while (complete != n) {
        // Find process with minimum
        // remaining time among the
        // processes that arrives till the
        // current time`
        for (int j = 0; j < n; j++) {
            if ((proc[j].art <= t) &&
            (rt[j] < minm) && rt[j] > 0) {
                minm = rt[j];
                shortest = j;
                check = 1;
            }
        }
        if (check == 0) {
            t++;
            continue;
        }
        // Reduce remaining time by one
        rt[shortest]--;
        // Update minimum
        minm = rt[shortest];
        if (minm == 0)
            minm = 9999999;
        // If a process gets completely
        // executed
        if (rt[shortest] == 0) {
            // Increment complete
            complete++;
            // Find finish time of current
            // process
            finish_time = t + 1;
            // Calculate waiting time
            wt[shortest] = finish_time -
                        proc[shortest].bt -
                        proc[shortest].art;
            if (wt[shortest] < 0)
                wt[shortest] = 0;
        }
        // Increment time
        t++;
    }
}
// Function to calculate turn around time
void findTurnAroundTime(Process proc[], int n,
                        int wt[], int tat[])
{
    // calculating turnaround time by adding
    // bt[i] + wt[i]
    for (int i = 0; i < n; i++)
        tat[i] = proc[i].bt + wt[i];
}
// Function to calculate average time
void findavgTime(Process proc[], int n)
{
    int wt[n], tat[n], total_wt = 0,
                    total_tat = 0;
    // Function to find waiting time of all
    // processes
    findWaitingTime(proc, n, wt);
    // Function to find turn around time for
    // all processes
    findTurnAroundTime(proc, n, wt, tat);
    int i,p[10],pos,j,temp;
    for(i=0;i<n;i++)
    {
        p[i]=i+1;           //contains process number
    }
    //sorting burst time in ascending order using selection sort
    for(i=0;i<n;i++)
    {
        pos=i;
        for(j=i+1;j<n;j++)
        {
            if(wt[j]<wt[pos])
                pos=j;
        }
        temp=wt[i];
        wt[i]=wt[pos];
        wt[pos]=temp;
        temp=p[i];
        p[i]=p[pos];
        p[pos]=temp;
    }
    printf("\nThe order of execution is:");
    for(i=0;i<n;i++)
    {
        printf("\n%c",(char)(p[i]+64));
    }
    printf("\n");
    // Display processes along with all
    // details
    printf("Processes  Burst time  Waiting time  Turn around time\n");
    // Calculate total waiting time and
    // total turnaround time
    for (int i = 0; i < n; i++) {
        total_wt = total_wt + wt[i];
        total_tat = total_tat + tat[i];
        printf(" %c\t\t%d\t %d\t\t%d\n",(char)(proc[i].pid+64),proc[i].bt,wt[i],tat[i]);
    }
    printf("Average waiting time = %f",(float)total_wt/(float)n);
    printf("\nAverage turn around time = %f",(float)total_tat / (float)n);
}
// Driver code
int main()
{
    Process proc[] = { { 1, 16, 0 }, { 2, 2, 3 },
                    { 3, 11, 5 }, { 4, 6, 9 } ,
                    { 5, 1, 10 }, { 6, 9, 12 } ,
                    { 7, 4, 14 }, { 8, 14, 16 } ,
                    { 9, 1, 17 }, { 10, 8, 19 } };
    int n = sizeof(proc) / sizeof(proc[0]);
    findavgTime(proc, n);
    return 0;
}