From c318712180287d57774e1212acb0d4a04a3da51f Mon Sep 17 00:00:00 2001 From: sherlock Date: Fri, 21 Mar 2025 08:25:59 +0530 Subject: [PATCH] Added test programs --- OS/C/practice/test | Bin 0 -> 34024 bytes OS/C/practice/test.c | 179 ++++++++++++++++++++++++++++++++++++++++++ OS/C/practice/test.sh | 8 ++ 3 files changed, 187 insertions(+) create mode 100755 OS/C/practice/test create mode 100644 OS/C/practice/test.c create mode 100755 OS/C/practice/test.sh diff --git a/OS/C/practice/test b/OS/C/practice/test new file mode 100755 index 0000000000000000000000000000000000000000..8b09699a70a3e25556755d60f844dfb5eba32502 GIT binary patch literal 34024 zcmeI5Yiv}<6~||NZP>MW7|Q$Q+q9&+BtX;9l44vImWQDgSb$XXye!_ez443eBY}dG zEt{x`;6s*Br7ZzWTBUbwBB4UWT7}r{N(EX(fT|EhO zy1!xQd&z`GWqYverg}|_wZ0H)4QQd(`Zih4*QYNs^wpY5s9dPSY?2AB!w(QOZRz6m zi#6Yx)$5Ga@EUpqQW*+T1(g(O+U1Cv*3f2KhKK62=0$p`zZHfduZR{kdR1>vlz=!In8o=3ri-?NUfQj)e5rf)A~a$1D>s3eyp(y(WQuWK5E(IWPex zzyz286JP>NfC(@GCcp%k025#WOn?b60Vco%m;e)C0!)AjFaajO1egF5U;<2l2`~XB zzyz286JP>NfC(@GCcp%k025#W{{?|TrRd7Q?%}C{j3e2RsK_4kRit~AiZuSK{y1IH z(kY*o_LPX{oDNr0-|3@M`kZ1uwe@6X7&4iyQl=BK9!F_Yp6oC~R!?ZzROU#!REb~p zw3i-&u6@oDZ+Dlh-%9$&plz*Z_N+r5)XTBX9i38L{P6z5(OcD_9A4;jdHZ!`M%EgG z^t+&+bnBR#)70&RZt9~t;#Jhg?GpW+HW?SjcX>RAI+TwWl8mlw&5{h+Dp{Dibl9C4 z9GqzJA^kddy@$G<%(V1irRb)%zDjR5vCDBAZrYOBoK9ifo0akIGVoZ{UUmrF_T}sb z<7&r!yKg|QkeiNij5!&)ZkaMou-)S*%ju$VsLiT(j}+a+iFD@HVI<~RAm?$(H7F~r zcaM3nzYDTDY=WI-*1X7e;?f5e?}H1re5wy~a@*}j-#oj~SK946lC#?*^_l08u$XO0lPzu$U#r75S{EzouuJlR zo#((u&!9~68IF19`Wt724sIt&2CP#U)ABhwOWZUr&OqX>lkMd5khf%WzGT@8{kp}) zc5YB#oK=W8Gcisl#u@4iu-bC#ZTcO}E4MGOR}1A#zile4C%-2qyJ4T)!`=nS(KcTk zfqak8+zY;fyeLQ`wxQvGBgQwFv!EiD`K6O@|G( zwWBk^d{qtz_;u}z63Z9P`vu0ru-@_i%l?_>v zrLi{J#_C9H$RF?X`QvSZY$~xi+hxv;bdcSaKUsMv-n)f=6Of-+taNbgg3sWS+k+j- zboi}#e&8M5XPzH&KYX|_iEk$lsyKsYBhAU-9H=(mHQ@40#)S-I4;I2;Z=?{9W3 ziG?Fk*SGzlD7v}U$HJ}ta9gZ3P%35yT(*CuLXJ}t4hCCxL_^O9)pe_u4>@9uKOAh0 z77V$pH5v@7(Z-onQ739*AGY96G^L|izN50Jk{p2^m)3E6% z*i-tpm%efLBBe;*r&I9C=lutLKRg0j%B3b*PoFlMp*)WLh)^CUeUy?srG`*>oW8-Q zGJUsA>2Nc}K9yzTbNljmsVs}Qk?@lVFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@G zCcp%k025#WOn?b60Vco%m;e)C0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@G zCcp%k025#WOn?b60Vco%m;e*_tOQgD)*!|a>9@{}y8w_uuw4=$e@on`HGWrIcySwm z*Qzo4IdFl1e(BfgHm~4xGjt{9BPf$3oTOT zZ$`LHS1o<+lsUse&@y6G3-E z(0vee7XvbDqSs-95FhjakutY*I!)_niyNZ~m_C(uzMGT=$P9zd!J7uL +#include +#include +#include + +// Define the Process structure to hold scheduling details. +typedef struct { + int pid; // Process ID for display. + int arrival; // Arrival time. + int burst; // Burst time (total execution time). + int waiting; // Waiting time (calculated). + int turnaround; // Turnaround time (calculated). + int completion; // Completion time (calculated). + int remaining; // Remaining burst time (for preemptive SJF). +} Process; + +// Function: fcfs_scheduling +// Implements the First-Come, First-Served scheduling algorithm. +void fcfs_scheduling(Process proc[], int n) { + // Sort processes by arrival time using bubble sort. + for (int i = 0; i < n - 1; i++) { + for (int j = 0; j < n - i - 1; j++) { + if (proc[j].arrival > proc[j + 1].arrival) { + Process temp = proc[j]; + proc[j] = proc[j + 1]; + proc[j + 1] = temp; + } + } + } + + int current_time = 0; // Simulated current time. + for (int i = 0; i < n; i++) { + // If the CPU is idle, fast-forward current time to the arrival of the next process. + if (current_time < proc[i].arrival) { + current_time = proc[i].arrival; + } + // Waiting time is the time process has to wait from its arrival. + proc[i].waiting = current_time - proc[i].arrival; + // Turnaround time is waiting time plus burst time. + proc[i].turnaround = proc[i].waiting + proc[i].burst; + // Completion time is when the process finishes execution. + proc[i].completion = current_time + proc[i].burst; + // Update current time to include the burst time of this process. + current_time += proc[i].burst; + } + + // Print the FCFS scheduling results. + printf("\n=== FCFS Scheduling Results (Child Process) ===\n"); + printf("PID\tArrival\tBurst\tCompletion\tWaiting\tTurnaround\n"); + for (int i = 0; i < n; i++) { + printf("%d\t%d\t%d\t%d\t\t%d\t%d\n", + proc[i].pid, + proc[i].arrival, + proc[i].burst, + proc[i].completion, + proc[i].waiting, + proc[i].turnaround); + } +} + +// Function: preemptive_sjf +// Implements the Preemptive SJF (Shortest Job First) scheduling algorithm. +void preemptive_sjf(Process proc[], int n) { + // Initialize remaining time for each process. + for (int i = 0; i < n; i++) { + proc[i].remaining = proc[i].burst; + } + + int complete = 0; // Number of completed processes. + int current_time = 0; // Simulated current time. + int smallest; // Index of process with smallest remaining time. + int finish_time; // Time when a process completes. + int found; // Flag indicating if a process is found at current time. + + // Process scheduling until all processes complete. + while (complete != n) { + found = 0; + smallest = -1; + // Find process with minimum remaining time that has arrived. + for (int i = 0; i < n; i++) { + if (proc[i].arrival <= current_time && proc[i].remaining > 0) { + if (smallest == -1 || proc[i].remaining < proc[smallest].remaining) { + smallest = i; + found = 1; + } + } + } + + // If no process is available at current_time, increment time. + if (!found) { + current_time++; + continue; + } + + // Execute the selected process for one time unit. + proc[smallest].remaining--; + current_time++; + + // When a process completes execution, update its times. + if (proc[smallest].remaining == 0) { + complete++; + finish_time = current_time; + // Completion time is the finish time. + proc[smallest].completion = finish_time; + // Turnaround time is finish time minus arrival time. + proc[smallest].turnaround = finish_time - proc[smallest].arrival; + // Waiting time is turnaround time minus burst time. + proc[smallest].waiting = proc[smallest].turnaround - proc[smallest].burst; + } + } + + // Print the Preemptive SJF scheduling results. + printf("\n=== Preemptive SJF Scheduling Results (Parent Process) ===\n"); + printf("PID\tArrival\tBurst\tCompletion\tWaiting\tTurnaround\n"); + for (int i = 0; i < n; i++) { + printf("%d\t%d\t%d\t%d\t\t%d\t%d\n", + proc[i].pid, + proc[i].arrival, + proc[i].burst, + proc[i].completion, + proc[i].waiting, + proc[i].turnaround); + } +} + +int main() { + int n; + + // Prompt user to input the number of processes. + printf("Enter the number of processes: "); + fflush(stdout); // Ensure the prompt is displayed. + scanf("%d", &n); + + // Declare two arrays for process data: + // - One for the child (FCFS) and one for the parent (Preemptive SJF). + Process processes[n]; + Process processes_copy[n]; // Copy for parent's use. + + // Loop to gather process details. + for (int i = 0; i < n; i++) { + processes[i].pid = i + 1; // Process IDs start at 1. + + // Input arrival time. + printf("Enter arrival time for process %d: ", i + 1); + fflush(stdout); + scanf("%d", &processes[i].arrival); + + // Input burst time. + printf("Enter burst time for process %d: ", i + 1); + fflush(stdout); + scanf("%d", &processes[i].burst); + + // Copy process data for the parent process scheduling. + processes_copy[i] = processes[i]; + } + + // Fork the process to split execution into two scheduling algorithms. + pid_t pid = fork(); + + if (pid < 0) { + // Error handling for fork failure. + perror("Fork failed"); + exit(EXIT_FAILURE); + } + else if (pid == 0) { + // Child process: Execute FCFS scheduling. + printf("\nChild process executing FCFS scheduling...\n"); + fcfs_scheduling(processes, n); + exit(0); // End child process. + } + else { + // Parent process: Wait for child to finish and then execute Preemptive SJF. + wait(NULL); + printf("\nParent process executing Preemptive SJF scheduling...\n"); + preemptive_sjf(processes_copy, n); + } + + return 0; +} diff --git a/OS/C/practice/test.sh b/OS/C/practice/test.sh new file mode 100755 index 0000000..57fa256 --- /dev/null +++ b/OS/C/practice/test.sh @@ -0,0 +1,8 @@ +read -p "Enter a number: " num +if [[ $num -gt 10 ]]; then + echo "Number is greater than 10" +elif [[ $num -eq 10 ]]; then + echo "Number is exactly 10" +else + echo "Number is less than 10" +fi