Scribd
Upload
8 views6 pages

OS Assignment 1 Solution

The document outlines an OS assignment requiring the development of two C programs. The first program involves two processes where one appends integers to a shared array and the other sorts it in descending order. The second program implements a message queue where a sender sends a message to a receiver, which reverses it and sends it back until 'exit' is sent.

Uploaded by

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

OS Assignment 1 Solution

The document outlines an OS assignment requiring the development of two C programs. The first program involves two processes where one appends integers to a shared array and the other sorts it in descending order. The second program implements a message queue where a sender sends a message to a receiver, which reverses it and sends it back until 'exit' is sent.

Uploaded by

matrix29v
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

OS Assignment-1

Sangeeth Suresh
January 27, 2025

Student Details
• Class: S4 B2

• Roll Number: 68

Instructions
Develop a program in C to address the following scenario.

Questions
Question 1
There are 2 processes P1 and P2, both share an array of integers (shared memory). P1
accepts the array of integer and appends it to the shared array. Once P1 has appended
all the numbers into the array, P2 sorts the array in descending order. Once P2 finishes
sorting, P1 displays the sorted array in the terminal.
Answer:
1 # include < stdio .h >
2 # include < stdlib .h >
3 # include < unistd .h >
4 # include < sys / types .h >
5 # include < sys / wait .h >
6

7 # define MAX_SIZE 100


8

9 void sort_descending ( int * array , int size ) {


10 for ( int i = 0; i < size - 1; i ++) {
11 for ( int j = 0; j < size - i - 1; j ++) {
12 if ( array [ j ] < array [ j + 1]) {
13 int temp = array [ j ];
14 array [ j ] = array [ j + 1];
15 array [ j + 1] = temp ;
16 }
17 }
18 }

1
19 }
20

21 int main () {
22 int array [ MAX_SIZE ];
23 int size ;
24

25 printf ( " Enter the number of elements : " ) ;


26 scanf ( " % d " , & size ) ;
27

28 if ( size > MAX_SIZE ) {


29 printf ( " Maximum size exceeded . Limit is % d .\ n " , MAX_SIZE )
;
30 exit (1) ;
31 }
32

33 printf ( " Enter the elements : " ) ;


34 for ( int i = 0; i < size ; i ++) {
35 scanf ( " % d " , & array [ i ]) ;
36 }
37 printf ( " Elements appended ...\ n " ) ;
38 pid_t pid = fork () ;
39

40 if ( pid < 0) {
41 perror ( " fork " ) ;
42 exit (1) ;
43 } else if ( pid == 0) {
44 // Child process : Sort the array
45 printf ( " Child process sorting ...\ n " ) ;
46 sort_descending ( array , size ) ;
47 printf ( " Sorting complete \ n " ) ;
48

49 // Write the sorted array to a temporary file


50 FILE * temp_file = fopen ( " temp . txt " , " w " ) ;
51 if (! temp_file ) {
52 perror ( " fopen " ) ;
53 exit (1) ;
54 }
55 for ( int i = 0; i < size ; i ++) {
56 fprintf ( temp_file , " % d " , array [ i ]) ;
57 }
58 fclose ( temp_file ) ;
59 exit (0) ;
60 } else {
61 // Parent process waits for child to finish
62 wait ( NULL ) ;
63

64 // Read the sorted array from the temporary file


65 FILE * temp_file = fopen ( " temp . txt " , " r " ) ;
66 if (! temp_file ) {
67 perror ( " fopen " ) ;
68 exit (1) ;

2
69 }
70

71 printf ( " Sorted array in descending order : " ) ;


72 for ( int i = 0; i < size ; i ++) {
73 fscanf ( temp_file , " % d " , & array [ i ]) ;
74 printf ( " % d " , array [ i ]) ;
75 }
76 printf ( " \ n " ) ;
77 fclose ( temp_file ) ;
78

79 // Remove the temporary file


80 remove ( " temp . txt " ) ;
81 }
82

83 return 0;
84 }

Question 2
Implement a message queue where the sender sends a message to receiver receives the
message ,reverses it and retransmit to the sender. Sender has to print the reversed
message. This process is continued till “exit” is send as the message.
Answer:
1 # include < stdio .h >
2 # include < stdlib .h >
3 # include < string .h >
4 # include < sys / types .h >
5 # include < sys / wait .h >
6 # include < unistd .h >
7 # include < fcntl .h >
8 # include < sys / stat .h >
9

10 # define MAX_TEXT 100


11 # define TEMP_FILE " message_temp . txt "
12 # define FLAG_FILE " sync_flag . txt " // File for synchronization
13

14 void reverse_string ( char * str ) {


15 int len = strlen ( str ) ;
16 for ( int i = 0; i < len / 2; i ++) {
17 char temp = str [ i ];
18 str [ i ] = str [ len - i - 1];
19 str [ len - i - 1] = temp ;
20 }
21 }
22

23 void write_flag ( const char * flag ) {


24 FILE * flag_file = fopen ( FLAG_FILE , " w " ) ;
25 if (! flag_file ) {
26 perror ( " fopen " ) ;
27 exit (1) ;

3
28 }
29 fprintf ( flag_file , " % s " , flag ) ;
30 fclose ( flag_file ) ;
31 }
32

33 void wait_for_flag ( const char * expected_flag ) {


34 char flag [ MAX_TEXT ];
35 do {
36 FILE * flag_file = fopen ( FLAG_FILE , " r " ) ;
37 if (! flag_file ) {
38 perror ( " fopen " ) ;
39 exit (1) ;
40 }
41 fgets ( flag , MAX_TEXT , flag_file ) ;
42 fclose ( flag_file ) ;
43 flag [ strcspn ( flag , " \ n " ) ] = ’ \0 ’; // Remove newline
44 } while ( strcmp ( flag , expected_flag ) != 0) ;
45 }
46

47 int main () {
48 pid_t pid = fork () ;
49

50 if ( pid < 0) {
51 perror ( " fork " ) ;
52 exit (1) ;
53 } else if ( pid == 0) {
54 // Child process ( Receiver )
55 char message [ MAX_TEXT ];
56

57 while (1) {
58 // Wait for the parent to signal the message is ready
59 wait_for_flag ( " parent_done " ) ;
60

61 // Open the temporary file to read the message


62 FILE * file = fopen ( TEMP_FILE , " r " ) ;
63 if (! file ) {
64 perror ( " fopen " ) ;
65 exit (1) ;
66 }
67 fgets ( message , MAX_TEXT , file ) ;
68 fclose ( file ) ;
69

70 if ( strcmp ( message , " exit " ) == 0) {


71 break ;
72 }
73

74 // Reverse the message


75 reverse_string ( message ) ;
76

77 // Write the reversed message back to the temporary


file

4
78 file = fopen ( TEMP_FILE , " w " ) ;
79 if (! file ) {
80 perror ( " fopen " ) ;
81 exit (1) ;
82 }
83 fprintf ( file , " % s " , message ) ;
84 fclose ( file ) ;
85

86 // Signal the parent that the child is done


87 write_flag ( " child_done " ) ;
88 }
89

90 exit (0) ;
91 } else {
92 // Parent process ( Sender )
93 char message [ MAX_TEXT ];
94

95 // Initialize the flag file


96 write_flag ( " child_done " ) ;
97

98 while (1) {
99 printf ( " Enter a message ( or ’ exit ’ to quit ) : " ) ;
100 fgets ( message , MAX_TEXT , stdin ) ;
101 message [ strcspn ( message , " \ n " ) ] = ’ \0 ’; // Remove
newline character
102

103 // Write the message to the temporary file


104 FILE * file = fopen ( TEMP_FILE , " w " ) ;
105 if (! file ) {
106 perror ( " fopen " ) ;
107 exit (1) ;
108 }
109 fprintf ( file , " % s " , message ) ;
110 fclose ( file ) ;
111

112 // Signal the child that the message is ready


113 write_flag ( " parent_done " ) ;
114

115 if ( strcmp ( message , " exit " ) == 0) {


116 break ;
117 }
118

119 // Wait for the child to signal it ’s done processing


120 wait_for_flag ( " child_done " ) ;
121

122 // Read the reversed message from the temporary file


123 file = fopen ( TEMP_FILE , " r " ) ;
124 if (! file ) {
125 perror ( " fopen " ) ;
126 exit (1) ;
127 }

5
128 fgets ( message , MAX_TEXT , file ) ;
129 fclose ( file ) ;
130

131 printf ( " Reversed message : % s \ n " , message ) ;


132 }
133

134 wait ( NULL ) ; // Wait for child process to finish


135

136 // Remove the temporary files


137 remove ( TEMP_FILE ) ;
138 remove ( FLAG_FILE ) ;
139 }
140

141 return 0;
142 }

You might also like