Scribd
Upload
13 views15 pages

Operating System Lab

The document contains multiple C programming exercises related to operating systems, including creating parent-child processes, reporting Linux kernel and CPU information, memory information, file details, file copying, and implementing the FCFS scheduling algorithm. Each exercise provides code snippets demonstrating the required functionality, such as using system calls and handling process management. The document serves as a practical guide for understanding operating system concepts through programming.

Uploaded by

tataelectronics54
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
13 views15 pages

Operating System Lab

The document contains multiple C programming exercises related to operating systems, including creating parent-child processes, reporting Linux kernel and CPU information, memory information, file details, file copying, and implementing the FCFS scheduling algorithm. Each exercise provides code snippets demonstrating the required functionality, such as using system calls and handling process management. The document serves as a practical guide for understanding operating system concepts through programming.

Uploaded by

tataelectronics54
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

Operating System Lab

1. WRITE A PROGRAM (USING FORK ( ) AND/OR EXEC ( ) COMMANDS ) WHERE PARENT AND CHILD EXECUTE:

A ) S AME PROGRAM , SAME CODE .

#INCLUDE <STDIO.H>
#INCLUDE <UNISTD.H>
#INCLUDE <SYS/TYPES.H>
INT MAIN () {
PID _ T PID = FORK(); // C REATE A CHILD PROCESS
IF (PID < 0) {
FPRINTF ( STDERR , "F ORK FAILED !\ N");
RETURN 1;
} ELSE IF (PID == 0) {
PRINTF ("C HILD PROCESS : PID = % D\ N", GETPID ());
} ELSE {
PRINTF ("P ARENT PROCESS : PID = % D, C HILD PID = % D\ N", GETPID (), PID );
}
PRINTF ("T HIS IS COMMON CODE EXECUTED BY BOTH PARENT AND CHILD .\N");
RETURN 0;
}
B ) S AME PROGRAM , DIFFERENT CODE .

#INCLUDE <STDIO.H>
#INCLUDE <UNISTD.H>
#INCLUDE <SYS/TYPES.H>
INT MAIN () {
PID _ T PID = FORK (); // C REATE A CHILD PROCESS

IF (PID < 0) {
FPRINTF ( STDERR, "FORK FAILED!\N");
RETURN 1;
} ELSE IF (PID == 0) {
// C HILD PROCESS
PRINTF ("C HILD PROCESS: PID = % D\N", GETPID ());
PRINTF ("C HILD IS EXECUTING DIFFERENT CODE.\N");
} ELSE {
// P ARENT PROCESS
PRINTF ("P ARENT PROCESS: PID = % D, CHILD PID = % D\N", GETPID (), PID);
PRINTF ("P ARENT IS EXECUTING DIFFERENT CODE.\N");
}
RETURN 0;
}
C) BEFORE TERMINATING , THE PARENT WAITS FOR THE CHILD TO FINISH ITS TASK .

#INCLUDE <STDIO.H>
#INCLUDE <UNISTD.H>
#INCLUDE <SYS/TYPES.H>
#INCLUDE <SYS/WAIT.H>
INT MAIN () {
PID _ T PID = FORK (); IF (PID < 0) {
FPRINTF ( STDERR, "FORK FAILED! \N");
RETURN 1;
} ELSE IF (PID == 0) {
PRINTF ("C HILD PROCESS: PID = % D\N", GETPID ());
SLEEP (2); // S IMULATE SOME WORK
PRINTF ("C HILD PROCESS FINISHED.\N");
} ELSE {
PRINTF ("P ARENT PROCESS: PID = % D, CHILD PID = % D\N", GETPID (), PID);
WAIT (NULL);
PRINTF ("P ARENT PROCESS FINISHED AFTER CHILD.\N");
}

RETURN 0;
}
2. WRITE A PROGRAM TO REPORT BEHAVIOR OF LINUX KERNEL INCLUDING KERNEL VERSION, CPU TYPE AND
MODEL . (CPU INFORMATION )

#INCLUDE <STDIO.H>
#INCLUDE <STDLIB.H>
#INCLUDE <SYS/UTSNAME .H> // F OR UNAME()
VOID PRINT _ KERNEL _ INFO () {
STRUCT UTSNAME SYS _ INFO ;
IF (UNAME (& SYS _ INFO ) == -1) {
PERROR (" UNAME ");
EXIT (EXIT_FAILURE);
}
PRINTF ("K ERNEL V ERSION : % S\ N", SYS _ INFO .RELEASE );
PRINTF ("S YSTEM N AME : % S\ N", SYS _ INFO .SYSNAME );
PRINTF ("N ODE N AME : % S\ N", SYS _ INFO .NODENAME );
PRINTF ("K ERNEL R ELEASE : % S\ N", SYS _ INFO .RELEASE );
PRINTF ("K ERNEL V ERSION : % S\ N", SYS _ INFO .VERSION );
PRINTF ("MACHINE H ARDWARE : % S\ N", SYS _ INFO .MACHINE );
}
VOID PRINT _ CPU _ INFO () {
FILE * CPUINFO = FOPEN("/PROC/CPUINFO", "R");
IF (CPUINFO == NULL) {
PERROR (" FOPEN ");
EXIT (EXIT_FAILURE);
}
CHAR LINE[256];
INT FOUND = 0;
WHILE (FGETS ( LINE, SIZE OF ( LINE), CPUINFO )) {
IF (STRNCMP ( LINE, " MODEL NAME ", 10) == 0) {
PRINTF ("CPU M ODEL: %S", LINE + 13); // S KIP "MODEL NAME :"
FOUND = 1;
} ELSE IF (STRNCMP(LINE, "VENDOR_ID", 9) == 0) {
PRINTF ("CPU V ENDOR : % S", LINE + 11); // S KIP " VENDOR _ ID :"
FOUND = 1;
}
IF (FOUND ) BREAK ; // S TOP AFTER FINDING THE REQUIRED INFO
}
FCLOSE ( CPUINFO );
}
INT MAIN () {
PRINTF ("=== L INUX K ERNEL INFORMATION ===\ N");
PRINT _ KERNEL _ INFO ();
PRINTF ("\ N=== CPU I NFORMATION ===\ N");
PRINT _ CPU _ INFO ();
RETURN 0;
}
OP
=== LINUX KERNEL INFORMATION ===
KERNEL VERSION: 5.15.0-83- GENERIC
SYSTEM NAME: LINUX
NODE NAME: MY-MACHINE
KERNEL RELEASE: 5.15.0-83- GENERIC
KERNEL VERSION: #92-U BUNTU SMP T UE OCT 3 [Link] UTC 2023
MACHINE HARDWARE: X86_64

=== CPU I NFORMATION ===


CPU VENDOR: GENUINEINTEL
CPU MODEL: INTEL(R) CORE(TM) I7-9750H CPU @ 2.60GH Z
3. WRITE A PROGRAM TO REPORT BEHAVIOR OF LINUX KERNEL INCLUDING INFORMATION ON CONFIGURED
MEMORY , AMOUNT OF FREE AND USED MEMORY . ( MEMORY INFORMATION )

#INCLUDE <STDIO.H>
#INCLUDE <STDLIB.H>
#INCLUDE <STRING.H>
VOID PRINT _ MEMORY _ INFO () {
FILE * MEMINFO = FOPEN("/PROC/MEMINFO", "R");
IF (MEMINFO == NULL) {
PERROR (" FOPEN ");
EXIT (EXIT_FAILURE);
}
CHAR LINE[256];
INT FOUND _ TOTAL = 0, FOUND _ FREE = 0, FOUND _ AVAILABLE = 0;
WHILE (FGETS ( LINE, SIZEOF ( LINE), MEMINFO )) {
IF (STRNCMP ( LINE, "M EM TOTAL :", 9) == 0) {
PRINTF ("T OTAL M EMORY : % S", LINE + 10); // S KIP "M EM TOTAL :"
FOUND _ TOTAL = 1;
} ELSE IF (STRNCMP(LINE, "MEMFREE:", 8) == 0) {
PRINTF ("F REE M EMORY : % S", LINE + 9); // S KIP "M EM FREE :"
FOUND _ FREE = 1;
} ELSE IF (STRNCMP(LINE, "MEMAVAILABLE :", 13) == 0) {
PRINTF ("A VAILABLE M EMORY : % S", LINE + 14); // S KIP "M EM AVAILABLE :"
FOUND _ AVAILABLE = 1;
}

// S TOP AFTER FINDING ALL REQUIRED INFORMATION


IF (FOUND _ TOTAL && FOUND _ FREE && FOUND _ AVAILABLE ) {
BREAK ;
}
}

FCLOSE ( MEMINFO );
}
INT MAIN () {
PRINTF ("=== M EMORY INFORMATION ===\ N");
PRINT _ MEMORY _ INFO ();
RETURN 0;
}
OP
=== M EMORY INFORMATION ===
TOTAL MEMORY: 16384000 KB
FREE MEMORY: 4200000 KB
AVAILABLE MEMORY: 8000000 KB
4. WRITE A PROGRAM TO PRINT FILE DETAILS INCLUDING OWNER ACCESS PERMISSIONS , FILE ACCESS TIME, WHERE
FILE NAME IS GIVEN AS ARGUMENT .

#INCLUDE <STDIO.H>
#INCLUDE <STDLIB.H>
#INCLUDE <SYS/STAT.H>
#INCLUDE <UNISTD.H>
#INCLUDE <TIME.H>
#INCLUDE <PWD.H>
VOID PRINT _ FILE _ DETAILS ( CONST CHAR *FILENAME ) {
STRUCT STAT FILE _ STAT ;
IF (STAT ( FILENAME , & FILE _ STAT ) == -1) {
PERROR (" STAT ");
EXIT (EXIT_FAILURE);
}
PRINTF ("F ILE P ERMISSIONS : ");
PRINTF ((S_ISDIR( FILE _ STAT .ST_ MODE )) ? " D" : "-");
PRINTF (( FILE _ STAT .ST_ MODE & S_IRUSR) ? " R" : "-");
PRINTF (( FILE _ STAT .ST_ MODE & S_IWUSR) ? " W " : "-");
PRINTF (( FILE _ STAT .ST_ MODE & S_IXUSR) ? " X" : "-");
PRINTF (( FILE _ STAT .ST_ MODE & S_IRGRP) ? " R" : "-");
PRINTF (( FILE _ STAT .ST_ MODE & S_IWGRP) ? " W " : "-");
PRINTF (( FILE _ STAT .ST_ MODE & S_IXGRP) ? " X" : "-");
PRINTF (( FILE _ STAT .ST_ MODE & S_IROTH) ? " R" : "-");
PRINTF (( FILE _ STAT .ST_ MODE & S_IWOTH) ? " W" : "-");
PRINTF (( FILE _ STAT .ST_ MODE & S_IXOTH) ? " X" : "-");
PRINTF ("\ N");
STRUCT PASSWD *PW = GETPWUID ( FILE _ STAT .ST_ UID );
IF (PW != NULL) {
PRINTF ("F ILE O WNER : % S\ N", PW-> PW_ NAME );
} ELSE {
PERROR (" GETPWUID ");
}
CHAR ACCESS _ TIME [100];
STRFTIME ( ACCESS _ TIME , SIZEOF ( ACCESS _ TIME ), "%Y-% M-% D %H:%M:%S",
LOCALTIME (& FILE _ STAT .ST_ ATIME ));
PRINTF ("L AST A CCESS T IME : % S\ N", ACCESS _ TIME );
CHAR MOD _ TIME [100];
STRFTIME ( MOD _ TIME , SIZEOF ( MOD _ TIME ), "%Y-% M-% D %H:%M:%S", LOCALTIME (& FILE _ STAT .ST_ MTIME ));
PRINTF ("L AST M ODIFICATION T IME : % S\ N", MOD _ TIME );
PRINTF ("F ILE S IZE : % LD BYTES \ N", FILE _ STAT .ST_ SIZE );
}INT MAIN(INT ARGC, CHAR *ARGV[]) {
IF (ARGC != 2) {
FPRINTF ( STDERR , "U SAGE : % S <FILENAME >\ N", ARGV [0]);
EXIT (EXIT_FAILURE);
}
CONST CHAR *FILENAME = ARGV [1];
PRINTF ("=== F ILE DETAILS FOR '%S' ===\ N", FILENAME );
PRINT _ FILE _ DETAILS ( FILENAME );
RETURN 0;
}
=== FILE DETAILS FOR '[Link]' ===
FILE PERMISSIONS: -RW-R--R--
FILE OWNER: USER1
LAST ACCESS TIME: 2023-10-10 [Link]
LAST MODIFICATION TIME: 2023-10-10 [Link]
FILE SIZE: 1024 BYTES
5. WRITE A PROGRAM TO COPY FILES USING SYSTEM CALLS.

#INCLUDE <STDIO.H>
#INCLUDE <STDLIB.H>
#INCLUDE <FCNTL.H> // F OR OPEN()
#INCLUDE <UNISTD.H> // F OR READ(), WRITE(), CLOSE()
#INCLUDE <SYS/STAT.H> // F OR FILE PERMISSIONS
#DEFINE BUFFER_SIZE 1024
VOID COPY_ FILE ( CONST CHAR *SRC _ FILENAME , CONST CHAR *DEST _ FILENAME ) {
INT SRC _ FD , DEST _ FD ;
SSIZE _ T BYTES _ READ , BYTES _ WRITTEN ;
CHAR BUFFER [BUFFER_SIZE];
SRC _ FD = OPEN ( SRC _ FILENAME , O_RDONLY);
IF (SRC _ FD == -1) {
PERROR (" OPEN (SOURCE )");
EXIT (EXIT_FAILURE);
}
DEST _ FD = OPEN ( DEST _ FILENAME , O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR |
S_IRGRP | S_IROTH);
IF (DEST _ FD == -1) {
PERROR (" OPEN (DESTINATION )");
CLOSE ( SRC _ FD ); // C LOSE THE SOURCE FILE DESCRIPTOR
EXIT (EXIT_FAILURE);
}
WHILE (( BYTES _ READ = READ ( SRC _ FD , BUFFER , BUFFER_SIZE)) > 0) {
BYTES _ WRITTEN = WRITE ( DEST _ FD , BUFFER , BYTES _ READ );
IF (BYTES _ WRITTEN != BYTES _ READ ) {
PERROR (" WRITE ");
CLOSE ( SRC _ FD );
CLOSE ( DEST _ FD );
EXIT (EXIT_FAILURE);
}
}
IF (BYTES _ READ == -1) {
PERROR (" READ ");
}
CLOSE ( SRC _ FD );
CLOSE ( DEST _ FD );
PRINTF ("F ILE COPIED SUCCESSFULLY FROM '%S' TO '%S'.\ N", SRC _ FILENAME , DEST _ FILENAME );
}

INT MAIN ( INT ARGC , CHAR *ARGV []) {


IF (ARGC != 3) {
FPRINTF ( STDERR , "U SAGE : % S <SOURCE _ FILE > < DESTINATION _ FILE >\ N", ARGV [0]);
EXIT (EXIT_FAILURE);
}
CONST CHAR *SRC _ FILENAME = ARGV[1];
CONST CHAR *DEST _ FILENAME = ARGV [2];
COPY_ FILE ( SRC _ FILENAME , DEST _ FILENAME );
RETURN 0;
}
OP
FILE COPIED SUCCESSFULLY FROM '[Link]' TO 'DESTINATION .TXT'.
6. WRITE A PROGRAM USING C TO IMPLEMENT FCFS SCHEDULING ALGORITHM .

#INCLUDE <STDIO.H>
STRUCT P ROCESS {
INT ID ;
INT ARRIVAL _ TIME ;
INT BURST _ TIME ;
INT WAITING _ TIME ;
INT TURNAROUND _ TIME ;
};
VOID FCFS ( STRUCT PROCESS PROCESSES[], INT N) {
INT TOTAL _ WAITING _ TIME = 0, TOTAL _ TURNAROUND _ TIME = 0;
PROCESSES [0].WAITING _ TIME = 0;
PROCESSES [0].TURNAROUND _ TIME = PROCESSES [0].BURST _ TIME ;
FOR (INT I = 1; I < N; I++) {
PROCESSES [ I].WAITING _ TIME = PROCESSES [ I - 1]. WAITING _ TIME + PROCESSES [ I - 1]. BURST _ TIME ;
PROCESSES [ I].TURNAROUND _ TIME = PROCESSES [ I].WAITING _ TIME + PROCESSES [ I].BURST _ TIME ;
}
PRINTF ("P ROCESS \ TARRIVAL T IME \ TBURST T IME \ TWAITING T IME \ TTURNAROUND T IME \ N");
FOR (INT I = 0; I < N; I++) {
PRINTF ("%D\ T%D\ T\ T%D\ T\ T%D\ T\ T%D\ N", PROCESSES [ I].ID , PROCESSES [ I].ARRIVAL _ TIME ,
PROCESSES [ I].BURST _ TIME , PROCESSES [ I].WAITING _ TIME , PROCESSES [ I].TURNAROUND _ TIME );
TOTAL _ WAITING _ TIME += PROCESSES [ I].WAITING _ TIME ;
TOTAL _ TURNAROUND _ TIME += PROCESSES [ I].TURNAROUND _ TIME ;
}
PRINTF ("\ NAVERAGE W AITING T IME : %.2 F \ N", ( FLOAT ) TOTAL _ WAITING _ TIME / N);
PRINTF ("A VERAGE T URNAROUND T IME : %.2 F \ N", ( FLOAT ) TOTAL _ TURNAROUND _ TIME / N);
}
INT MAIN () {
INT N;
PRINTF ("E NTER THE NUMBER OF PROCESSES : ");
SCANF ("%D", &N);
STRUCT PROCESS PROCESSES[N];
FOR (INT I = 0; I < N; I++) {
PROCESSES [ I].ID = I + 1;
PRINTF ("E NTER ARRIVAL TIME AND BURST TIME FOR PROCESS % D: ", I + 1);
SCANF ("%D % D", & PROCESSES [ I].ARRIVAL _ TIME , & PROCESSES [ I].BURST _ TIME );
}
FCFS ( PROCESSES , N);
RETURN 0;
}
7. WRITE A PROGRAM USING C TO IMPLEMENT ROUND ROBIN SCHEDULING ALGORITHM .

#INCLUDE <STDIO.H>
#INCLUDE <STDBOOL.H>
STRUCT P ROCESS {
INT ID ;
INT ARRIVAL _ TIME ;
INT BURST _ TIME ;
INT REMAINING _ TIME ;
INT WAITING _ TIME ;
INT TURNAROUND _ TIME ;
};

VOID ROUND _ ROBIN ( STRUCT PROCESS PROCESSES[], INT N, INT QUANTUM) {


INT TIME= 0, COMPLETED = 0;
BOOL DONE ;
WHILE (COMPLETED < N) {
DONE = TRUE;
FOR (INT I = 0; I < N; I++) {
IF (PROCESSES [ I].REMAINING _ TIME > 0 && PROCESSES [ I].ARRIVAL _ TIME <= TIME ) {
DONE = FALSE ;
IF (PROCESSES [ I].REMAINING _ TIME > QUANTUM ) {
TIME += QUANTUM ;
PROCESSES [ I].REMAINING _ TIME -= QUANTUM ;
} ELSE {
TIME += PROCESSES [ I].REMAINING _ TIME ;
PROCESSES [ I].WAITING _ TIME = TIME - PROCESSES [ I].ARRIVAL _ TIME - PROCESSES [ I].BURST _ TIME ;
PROCESSES [ I].REMAINING _ TIME = 0;
PROCESSES [ I].TURNAROUND _ TIME = TIME - PROCESSES [ I].ARRIVAL _ TIME ;
COMPLETED ++;
}
}
}
IF (DONE ) TIME ++;
}
PRINTF ("P ROCESS \ TARRIVAL T IME \ TBURST T IME \ TWAITING T IME \ TTURNAROUND T IME \ N");
FOR (INT I = 0; I < N; I++) {
PRINTF ("%D\ T%D\ T\ T%D\ T\ T%D\ T\ T%D\ N", PROCESSES [ I].ID , PROCESSES [ I].ARRIVAL _ TIME ,
PROCESSES [ I].BURST _ TIME , PROCESSES [ I].WAITING _ TIME , PROCESSES [ I].TURNAROUND _ TIME );
}
}
INT MAIN () {
INT N, QUANTUM ;
PRINTF ("E NTER THE NUMBER OF PROCESSES : ");
SCANF ("%D", &N);
PRINTF ("E NTER TIME QUANTUM : ");
SCANF ("%D", &QUANTUM);
STRUCT PROCESS PROCESSES[N];
FOR (INT I = 0; I < N; I++) {
PROCESSES [ I].ID = I + 1;
PRINTF ("E NTER ARRIVAL TIME AND BURST TIME FOR PROCESS % D: ", I + 1);
SCANF ("%D % D", & PROCESSES [ I].ARRIVAL _ TIME , & PROCESSES [ I].BURST _ TIME );
PROCESSES [ I].REMAINING _ TIME = PROCESSES [ I].BURST _ TIME ;
}
ROUND _ ROBIN ( PROCESSES , N, QUANTUM );
RETURN 0;
}
8. WRITE A PROGRAM USING C TO IMPLEMENT SJF SCHEDULING ALGORITHM .

#INCLUDE <STDIO.H>
STRUCT P ROCESS {
INT ID ;
INT ARRIVAL _ TIME ;
INT BURST _ TIME ;
INT WAITING _ TIME ;
INT TURNAROUND _ TIME ;
};
VOID SJF( STRUCT PROCESS PROCESSES[], INT N) {
INT TOTAL _ WAITING _ TIME = 0, TOTAL_TURNAROUND_TIME = 0;
FOR (INT I = 0; I < N - 1; I++) {
FOR (INT J = I + 1; J < N; J++) {
IF (PROCESSES [ I].BURST _ TIME > PROCESSES [ J].BURST _ TIME ) {
STRUCT P ROCESS TEMP = PROCESSES [ I];
PROCESSES [ I] = PROCESSES [ J];
PROCESSES [ J] = TEMP ;
}
}
}
PROCESSES [0].WAITING _ TIME = 0;
PROCESSES [0].TURNAROUND _ TIME = PROCESSES [0].BURST _ TIME ;
FOR (INT I = 1; I < N; I++) {
PROCESSES [ I].WAITING _ TIME = PROCESSES [ I - 1]. WAITING _ TIME + PROCESSES [ I - 1]. BURST _ TIME ;
PROCESSES [ I].TURNAROUND _ TIME = PROCESSES [ I].WAITING _ TIME + PROCESSES [ I].BURST _ TIME ;
}
PRINTF ("P ROCESS \ TARRIVAL T IME \ TBURST T IME \ TWAITING T IME \ TTURNAROUND T IME \ N");
FOR (INT I = 0; I < N; I++) {
PRINTF ("%D\ T%D\ T\ T%D\ T\ T%D\ T\ T%D\ N", PROCESSES [ I].ID , PROCESSES [ I].ARRIVAL _ TIME ,
PROCESSES [ I].BURST _ TIME , PROCESSES [ I].WAITING _ TIME , PROCESSES [ I].TURNAROUND _ TIME );
TOTAL _ WAITING _ TIME += PROCESSES [ I].WAITING _ TIME ;
TOTAL _ TURNAROUND _ TIME += PROCESSES [ I].TURNAROUND _ TIME ;
}
PRINTF ("\ NAVERAGE W AITING T IME : %.2 F \ N", ( FLOAT ) TOTAL _ WAITING _ TIME / N);
PRINTF ("A VERAGE T URNAROUND T IME : %.2 F \ N", ( FLOAT ) TOTAL _ TURNAROUND _ TIME / N);
}
INT MAIN () {
INT N;
PRINTF ("E NTER THE NUMBER OF PROCESSES : ");
SCANF ("%D", &N);
STRUCT PROCESS PROCESSES[N];
FOR (INT I = 0; I < N; I++) {
PROCESSES [ I].ID = I + 1;
PRINTF ("E NTER ARRIVAL TIME AND BURST TIME FOR PROCESS % D: ", I + 1);
SCANF ("%D % D", & PROCESSES [ I].ARRIVAL _ TIME , & PROCESSES [ I].BURST _ TIME );
}
SJF( PROCESSES , N);
RETURN 0;
}
9. WRITE A PROGRAM USING C TO IMPLEMENT NON-PREEMPTIVE PRIORITY BASED SCHEDULING ALGORITHM .

#INCLUDE <STDIO.H>

STRUCT PROCESS {
INT ID ;
INT ARRIVAL _ TIME ;
INT BURST _ TIME ;
INT PRIORITY ;
INT WAITING _ TIME ;
INT TURNAROUND _ TIME ;
};

VOID PRIORITY _ SCHEDULING ( STRUCT PROCESS PROCESSES[], INT N) {


INT TOTAL _ WAITING _ TIME = 0, TOTAL_TURNAROUND_TIME = 0;

// S ORT PROCESSES BY PRIORITY (NON-PREEMPTIVE )


FOR (INT I = 0; I < N - 1; I++) {
FOR (INT J = I + 1; J < N; J++) {
IF (PROCESSES [ I].PRIORITY > PROCESSES [ J].PRIORITY ) {
STRUCT P ROCESS TEMP = PROCESSES [ I];
PROCESSES [ I] = PROCESSES [ J];
PROCESSES [ J] = TEMP ;
}
}
} PROCESSES[0].WAITING _TIME = 0;
PROCESSES [0].TURNAROUND _ TIME = PROCESSES [0].BURST _ TIME ;
FOR (INT I = 1; I < N; I++) {
PROCESSES [ I].WAITING _ TIME = PROCESSES [ I - 1]. WAITING _ TIME + PROCESSES [ I - 1]. BURST _ TIME ;
PROCESSES [ I].TURNAROUND _ TIME = PROCESSES [ I].WAITING _ TIME + PROCESSES [ I].BURST _ TIME ;
}
PRINTF ("P ROCESS \ TARRIVAL T IME \ TBURST T IME \ TPRIORITY \ TWAITING T IME \ TTURNAROUND T IME \ N");
FOR (INT I = 0; I < N; I++) {
PRINTF ("%D\ T%D\ T\ T%D\ T\ T%D\ T\ T%D\ T\ T%D\ N", PROCESSES [ I].ID , PROCESSES [ I].ARRIVAL _ TIME ,
PROCESSES [ I].BURST _ TIME , PROCESSES [ I].PRIORITY , PROCESSES [ I].WAITING _ TIME ,
PROCESSES [ I].TURNAROUND _ TIME );
TOTAL _ WAITING _ TIME += PROCESSES [ I].WAITING _ TIME ;
TOTAL _ TURNAROUND _ TIME += PROCESSES [ I].TURNAROUND _ TIME ;
}
PRINTF ("\ NAVERAGE W AITING T IME : %.2 F \ N", ( FLOAT ) TOTAL _ WAITING _ TIME / N);
PRINTF ("A VERAGE T URNAROUND T IME : %.2 F \ N", ( FLOAT ) TOTAL _ TURNAROUND _ TIME / N);
}
INT MAIN () {
INT N;
PRINTF ("E NTER THE NUMBER OF PROCESSES : ");
SCANF ("%D", & N);
STRUCT P ROCESS PROCESSES [ N];
FOR (INT I = 0; I < N; I++) {
PROCESSES [ I].ID = I + 1;
PRINTF ("E NTER ARRIVAL TIME , BURST TIME , AND PRIORITY FOR PROCESS % D: ", I + 1);
SCANF ("%D % D % D", & PROCESSES [ I].ARRIVAL _ TIME , & PROCESSES [ I].BURST _ TIME ,
&PROCESSES[I].PRIORITY );
}
PRIORITY _ SCHEDULING ( PROCESSES , N);
RETURN 0;
}
10. WRITE A PROGRAM USING C TO IMPLEMENT PREEMPTIVE PRIORITY BASED SCHEDULING ALGORITHM .

#INCLUDE <STDIO.H>
#INCLUDE <STDBOOL.H>
STRUCT P ROCESS {
INT ID ;
INT ARRIVAL _ TIME ;
INT BURST _ TIME ;
INT PRIORITY ;
INT REMAINING _ TIME ;
INT WAITING _ TIME ;
INT TURNAROUND _ TIME ;
};
VOID PREEMPTIVE _ PRIORITY ( STRUCT P ROCESS PROCESSES [], INT N) {
INT TIME = 0, COMPLETED = 0;
BOOL DONE ;
WHILE (COMPLETED < N) {
DONE = TRUE ;
INT HIGHEST _ PRIORITY = -1, INDEX = -1;
FOR (INT I = 0; I < N; I++) {
IF (PROCESSES [ I].ARRIVAL _ TIME <= TIME && PROCESSES [ I].REMAINING _ TIME > 0) {
IF (HIGHEST _ PRIORITY == -1 || PROCESSES [ I].PRIORITY < HIGHEST _ PRIORITY ) {
HIGHEST _ PRIORITY = PROCESSES [ I].PRIORITY ;
INDEX = I;
}
DONE = FALSE ;
}
}
IF (DONE ) {
TIME ++;
CONTINUE ;
}
PROCESSES [ INDEX ].REMAINING _ TIME --;
TIME ++;
IF (PROCESSES [ INDEX ].REMAINING _ TIME == 0) {
COMPLETED ++;
PROCESSES [ INDEX ].TURNAROUND _ TIME = TIME - PROCESSES [ INDEX ].ARRIVAL _ TIME ;
PROCESSES [ INDEX ].WAITING _ TIME = PROCESSES [ INDEX ].TURNAROUND _ TIME -
PROCESSES [ INDEX ].BURST _ TIME ;
}
}

// P RINT RESULTS
PRINTF ("P ROCESS \ TARRIVAL T IME \ TBURST T IME \ TPRIORITY \ TWAITING T IME \ TTURNAROUND T IME \ N");
FOR (INT I = 0; I < N; I++) {
PRINTF ("%D\ T%D\ T\ T%D\ T\ T%D\ T\ T%D\ T\ T%D\ N", PROCESSES [ I].ID , PROCESSES [ I].ARRIVAL _ TIME ,
PROCESSES [ I].BURST _ TIME , PROCESSES [ I].PRIORITY , PROCESSES [ I].WAITING _ TIME ,
PROCESSES [ I].TURNAROUND _ TIME );
}
}
INT MAIN () {
INT N;
PRINTF ("E NTER THE NUMBER OF PROCESSES : ");
SCANF ("%D",&N);
PROCESS PROCESSES[N];
STRUCT
FOR (INT I = 0; I < N; I++) {
PROCESSES [ I].ID = I + 1;
PRINTF ("E NTER ARRIVAL TIME , BURST TIME , AND PRIORITY FOR PROCESS % D: ", I + 1);
SCANF ("%D % D % D", & PROCESSES [ I].ARRIVAL _ TIME , & PROCESSES [ I].BURST _ TIME ,
&PROCESSES[I].PRIORITY );
PROCESSES [ I].REMAINING _ TIME = PROCESSES [ I].BURST _ TIME ;
}
PREEMPTIVE _ PRIORITY ( PROCESSES , N);
RETURN 0;
}
11. WRITE A PROGRAM USING C TO IMPLEMENT SRTF SCHEDULING ALGORITHM .

#INCLUDE <STDIO.H>
#INCLUDE <STDBOOL.H>
STRUCT P ROCESS {
INT ID ;
INT ARRIVAL _ TIME ;
INT BURST _ TIME ;
INT REMAINING _ TIME ;
INT WAITING _ TIME ;
INT TURNAROUND _ TIME ;
};
VOID SRTF ( STRUCT P ROCESS PROCESSES [], INT N) {
INT TIME = 0, COMPLETED = 0;
BOOL DONE ;
WHILE (COMPLETED < N) {
DONE = TRUE ;
INT SHORTEST _ REMAINING _ TIME = -1, INDEX = -1;
FOR (INT I = 0; I < N; I++) {
IF (PROCESSES [ I].ARRIVAL _ TIME <= TIME && PROCESSES [ I].REMAINING _ TIME > 0) {
IF (SHORTEST _ REMAINING _ TIME == -1 || PROCESSES [ I].REMAINING _ TIME <
SHORTEST _ REMAINING _ TIME ) {
SHORTEST _ REMAINING _ TIME = PROCESSES [ I].REMAINING _ TIME ;
INDEX = I;
}
DONE = FALSE ;
}
}
IF (DONE ) {
TIME ++;
CONTINUE ;
}
PROCESSES [ INDEX ].REMAINING _ TIME --;
TIME ++;
IF (PROCESSES [ INDEX ].REMAINING _ TIME == 0) {
COMPLETED ++;
PROCESSES [ INDEX ].TURNAROUND _ TIME = TIME - PROCESSES[INDEX].ARRIVAL_TIME;
PROCESSES [ INDEX ].WAITING _ TIME = PROCESSES[INDEX].TURNAROUND_TIME -
PROCESSES [ INDEX ].BURST _ TIME ;
}
}
PRINTF ("P ROCESS \ TARRIVAL T IME \ TBURST T IME \ TWAITING T IME \ TTURNAROUND T IME \ N");
FOR (INT I = 0; I < N; I++) {
PRINTF ("%D\ T%D\ T\ T%D\ T\ T%D\ T\ T%D\ N", PROCESSES [ I].ID , PROCESSES [ I].ARRIVAL _ TIME ,
PROCESSES [ I].BURST _ TIME , PROCESSES [ I].WAITING _ TIME , PROCESSES [ I].TURNAROUND _ TIME );
}
}
INT MAIN () {
INT N;
PRINTF ("E NTER THE NUMBER OF PROCESSES : ");
SCANF ("%D", &N);
STRUCT PROCESS PROCESSES[N];
FOR (INT I = 0; I < N; I++) {
PROCESSES [ I].ID = I + 1;
PRINTF ("E NTER ARRIVAL TIME AND BURST TIME FOR PROCESS % D: ", I + 1);
SCANF ("%D % D", & PROCESSES [ I].ARRIVAL _ TIME , & PROCESSES [ I].BURST _ TIME );
PROCESSES [ I].REMAINING _ TIME = PROCESSES [ I].BURST _ TIME ;
}
SRTF ( PROCESSES , N);
RETURN 0;
}
12. WRITE A PROGRAM USING C TO IMPLEMENT FIRST-FIT, BEST-FIT AND WORST-FIT ALLOCATION STRATEGIES.

#INCLUDE <STDIO.H>
VOID FIRST _ FIT ( INT BLOCK _ SIZES [], INT M, INT PROCESS _ SIZES [], INT N) {
INT ALLOCATION [ N];
FOR (INT I = 0; I < N; I++) {
ALLOCATION [ I] = -1; // I NITIALIZE ALLOCATION ARRAY
FOR (INT J = 0; J < M; J++) {
IF (BLOCK _ SIZES [ J] >= PROCESS _ SIZES [ I]) {
ALLOCATION [ I] = J;
BLOCK _ SIZES [ J] -= PROCESS _ SIZES [ I];
BREAK ;
}
}
}
PRINTF ("F IRST -FIT A LLOCATION :\ N");
FOR (INT I = 0; I < N; I++) {
IF (ALLOCATION [ I] != -1)
PRINTF ("P ROCESS % D ALLOCATED TO B LOCK % D\ N", I + 1, ALLOCATION [ I] + 1);
ELSE
PRINTF ("P ROCESS %D NOT ALLOCATED \N", I + 1);
}
}
VOID BEST _ FIT ( INT BLOCK _ SIZES [], INT M, INT PROCESS _ SIZES [], INT N) {
INT ALLOCATION [ N];
FOR (INT I = 0; I < N; I++) {
ALLOCATION [ I] = -1; // I NITIALIZE ALLOCATION ARRAY
INT BEST _ INDEX = -1;
FOR (INT J = 0; J < M; J++) {
IF (BLOCK _ SIZES [ J] >= PROCESS _ SIZES [ I]) {
IF (BEST _ INDEX == -1 || BLOCK _ SIZES [ J] < BLOCK _ SIZES [ BEST _ INDEX ]) {
BEST _ INDEX = J;
}
}
}
IF (BEST _ INDEX != -1) {
ALLOCATION [ I] = BEST _ INDEX ;
BLOCK _ SIZES [ BEST _ INDEX ] -= PROCESS _ SIZES [ I];
}
}

PRINTF ("B EST-FIT ALLOCATION:\N");


FOR (INT I = 0; I < N; I++) {
IF (ALLOCATION [ I] != -1)
PRINTF ("P ROCESS % D ALLOCATED TO B LOCK % D\ N", I + 1, ALLOCATION [ I] + 1);
ELSE
PRINTF ("P ROCESS %D NOT ALLOCATED \N", I + 1);
}
}
VOID WORST _ FIT ( INT BLOCK _ SIZES [], INT M, INT PROCESS _ SIZES [], INT N) {
INT ALLOCATION [ N];
FOR (INT I = 0; I < N; I++) {
ALLOCATION [ I] = -1; // I NITIALIZE ALLOCATION ARRAY
INT WORST _ INDEX = -1;
FOR (INT J = 0; J < M; J++) {
IF (BLOCK _ SIZES [ J] >= PROCESS _ SIZES [ I]) {
IF (WORST _ INDEX == -1 || BLOCK _ SIZES [ J] > BLOCK _ SIZES [ WORST _ INDEX ]) {
WORST _ INDEX = J;
}
}
}
IF (WORST _ INDEX != -1) {
ALLOCATION [ I] = WORST _ INDEX ;
BLOCK _ SIZES [ WORST _ INDEX ] -= PROCESS _ SIZES [ I];
}
}
PRINTF ("WORST -FIT ALLOCATION:\N");
FOR (INT I = 0; I < N; I++) {
IF (ALLOCATION [ I] != -1)
PRINTF ("P ROCESS % D ALLOCATED TO B LOCK % D\ N", I + 1, ALLOCATION [ I] + 1);
ELSE
PRINTF ("P ROCESS %D NOT ALLOCATED \N", I + 1);
}
}
INT MAIN () {
INT BLOCK _ SIZES [] = {100, 500, 200, 300, 600};
INT PROCESS _ SIZES [] = {212, 417, 112, 426};
INT M = SIZEOF ( BLOCK _ SIZES ) / SIZEOF ( BLOCK _ SIZES [0]);
INT N = SIZEOF ( PROCESS _ SIZES ) / SIZEOF ( PROCESS _ SIZES [0]);
INT BLOCK _ SIZES _ FIRST _ FIT [ M];
INT BLOCK _ SIZES _ BEST _ FIT [ M];
INT BLOCK _ SIZES _ WORST _ FIT [ M];
FOR (INT I = 0; I < M; I++) {
BLOCK _ SIZES _ FIRST _ FIT [ I] = BLOCK _ SIZES [ I];
BLOCK _ SIZES _ BEST _ FIT [ I] = BLOCK _ SIZES [ I];
BLOCK _ SIZES _ WORST _ FIT [ I] = BLOCK _ SIZES [ I];
}
FIRST _ FIT ( BLOCK _ SIZES _ FIRST _ FIT , M, PROCESS _ SIZES , N);
PRINTF ("\ N");
BEST _ FIT ( BLOCK _ SIZES _ BEST _ FIT , M, PROCESS _ SIZES , N);
PRINTF ("\ N");
WORST _ FIT ( BLOCK _ SIZES _ WORST _ FIT , M, PROCESS _ SIZES , N);
RETURN 0;
}

You might also like