Just an attempt to understand core OS concepts.

• IO with system calls
• Pthread and mutex
• Synchronisation: Condition Variables
• Compile

Write a program using only system calls that does the following:

• When run initially, creates a file with fixed sized records of contacts
• Each record will be fixed size of 40 characters
• Character 0-19 will hold the name of the person
• Characters 20-39 will hold the phone number
• In the initial run, create 10 random entries with name (alphabetical) and number (digits 0-9)
• Run the program second time and only read names and list them, one on a line
• Run the program third time and only read numbers and list them, one on a line
• Run the program fourth time and list every name and number (on a line each)
• Run the program fifth time with a command line argument of name 3 "Blue Sky" "5551212"
• This should replace the 3rd entry with the name and number from command line
• You cannot read anything in this operation
• You are allowed to only write 40 characters (no more)
• Run the program fourth time and list every name and number (on a line each) and verify that previous update worked
• You will need to learn about lseek(2) system call.

Write a program to create 5 (child) threads and make the parent wait until they exit.

• In each thread, write a message to screen with thread ID, then pthread_yield(), then write another message, then sleep for a few random seconds (1 to 20), then write a third message and exit.
• What can you tell about the effects of pthread_yield() vs sleep()?
• Run the program a few times to see if the output varies.

Write the code using the Pthreds library.

• Each producer and consumer should using condition variable(s).
• Each should acquire the lock at the start and release it at the end.
• Use wait(), signal() and broadcast() as appropriate.

Write a program with 20 threads,

• 10 of which are producers and 10 are consumers.
• Declare a shared variable count = 0 and
• in the producer thread, increment it by one and
• in the consumer thread decrement by 1.
• thread_id is an integer that is 1 to 10 for producers and 11 to 20 for consumers.
• Synchronize this code so that the count goes from 1 to 10 and then goes from 10 to 1.

The code for each thread is given below.

producer() {
count++; print thread_id, count;
}

consumer () {
print thread_id, count; count--;
}

Modify the above code (version A) such that

• the count goes from 1 to 5. After that the consumers can start consuming it.
• Every time count goes below 5, producers can add to it.
• But if count is at 5, producer should not add to it.

$ gcc -o file-io-syscall  file-io-syscall.c
$ g++ -o pthread-example pthread-example.c -lpthread