Exam Prep — OS · Linux · Shell · FCFS

Functions

# Rule 1: parentheses
my_function() {
    echo "Hello"
}

# Rule 2: function keyword
function my_function {
    echo "Hello"
}

# Passing arguments: $1, $2, $3 ...
print_args() {
    echo $1 $2
}
print_args "Hello" "World"      # -> Hello World

Result table

Gantt chart

ALGORITHM FCFS_Scheduling
BEGIN
    Input n (number of processes)
    Input Process details (id, AT, BT)

    Sort Process array P in ascending order of P[i].AT

    current_time = 0
    total_TAT = 0
    total_WT = 0

    FOR i = 0 TO n-1 DO
        IF current_time < P[i].AT THEN
            current_time = P[i].AT     // CPU was idle
        END IF

        P[i].CT = current_time + P[i].BT
        current_time = P[i].CT

        P[i].TAT = P[i].CT - P[i].AT
        P[i].WT  = P[i].TAT - P[i].BT

        total_TAT = total_TAT + P[i].TAT
        total_WT  = total_WT + P[i].WT
    END FOR

    Print Process details (id, AT, BT, CT, TAT, WT)
    Print "Average TAT" = total_TAT / n
    Print "Average WT"  = total_WT / n
END

Version A — struct + std::sort (from lecture note)

#include <iostream>
#include <algorithm>
#include <iomanip>
using namespace std;

struct Process { int id, at, bt, ct, tat, wt; };

bool compareArrival(Process p1, Process p2) { return p1.at < p2.at; }
bool compareID(Process p1, Process p2) { return p1.id < p2.id; }

int main() {
    int n;
    cout << "Enter number of processes: ";
    cin >> n;

    Process p[n];
    float total_tat = 0, total_wt = 0;

    for (int i = 0; i < n; i++) {
        p[i].id = i + 1;
        cout << "Enter AT and BT for P" << p[i].id << ": ";
        cin >> p[i].at >> p[i].bt;
    }

    sort(p, p + n, compareArrival);

    int current_time = 0;
    for (int i = 0; i < n; i++) {
        if (current_time < p[i].at) current_time = p[i].at;
        p[i].ct = current_time + p[i].bt;
        current_time = p[i].ct;

        p[i].tat = p[i].ct - p[i].at;
        p[i].wt  = p[i].tat - p[i].bt;

        total_tat += p[i].tat;
        total_wt  += p[i].wt;
    }

    sort(p, p + n, compareID);

    cout << "\nProcess\tAT\tBT\tCT\tTAT\tWT\n";
    for (int i = 0; i < n; i++) {
        cout << "P" << p[i].id << "\t" << p[i].at << "\t" << p[i].bt << "\t"
             << p[i].ct << "\t" << p[i].tat << "\t" << p[i].wt << "\n";
    }

    cout << fixed << setprecision(2);
    cout << "\nAverage TAT: " << total_tat / n << "\n";
    cout << "Average WT: "  << total_wt / n  << "\n";
    return 0;
}

Version B — parallel arrays + bubble sort (from your own notes)

#include<bits/stdc++.h>
using namespace std;

int main() {
    int n;
    string s[100];
    int at[100], bt[100];
    cin >> n;
    for (int i = 0; i < n; i++) cin >> s[i] >> at[i] >> bt[i];

    // bubble sort by arrival time
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (at[j] > at[j + 1]) {
                swap(at[j], at[j + 1]);
                swap(bt[j], bt[j + 1]);
                swap(s[j], s[j + 1]);
            }
        }
    }

    int ct = 0, tat = 0, wt = 0;
    cout << "process\tAt\tBt\tCt\tTAT\tWT\n";
    for (int i = 0; i < n; i++) {
        ct += bt[i];
        tat = ct - at[i];
        wt  = tat - bt[i];
        cout << s[i] << "\t\t" << at[i] << "\t" << bt[i] << "\t" << ct << "\t" << tat << "\t" << wt << endl;
    }
    return 0;
}

Note: Version B assumes zero idle CPU time (it just accumulates ct += bt[i]) — it works only when processes queue back-to-back with no gaps. Version A correctly handles idle-CPU gaps. Know both, but understand why A is more general — that's a likely viva question.