Make (unsafe) producer-consumer shared memory example with bounded buffer and two variables. An example can be found in the OS book, and the code should end up in the 04-IPC folder.

We want examples demonstrating/do the following:

• That the process mask changes temporarily in signal handlers
  • And that "using sigprocmask inside the handler only affects what signals can arrive during the execution of the handler itself" (one of the last paras of https://www.gnu.org/software/libc/manual/html_node/Signals-in-Handler.html).
• Check the pending signals for a process in a signal handler via sigpending
• Show the coalescence of pending signals of the same type (this can be done by letting signals accumulate either in a slow handler (that lets the sigs accumulate) or by explicitly blocking signals of a certain type (letting sigs accumulate), and then unblocking the signals and showing how many times the handler is run (prob 1).
• sigprocmask vs pthread_sigmask
  • Demonstrate how setting a thread's signal mask doesn't change the containing process's signal mask, thus allowing threads to selectively choose which signals they can and cannot handle.

• Mutex
• Condition variable
• Message queue / pipe
• More?

We need an example, explanation, and analysis on the vfork system call in this repository. The analysis can consist of creating a ton of processes in the

• Traditional manner (fork)
• Efficient manner (vfork)

...and loading a new process into their address space via exec. Doing this a lot and then providing the differences in time-of-execution for each version will demonstrate the benefits of using vfork when you can, and the general description of vfork should explain when you should/can use it (since the two processes share the same address space it isn't wise when one is modifying a lot of global data the other needs etc).