IPC

Question 1

What’s MultiProcessing?

Answer 1

Using several CPU cores (= processors) for running a single job to
solve a single “problem”

Question 2

What threads don’t share?

Answer 2

Registers and stack.

Question 3

What is the clone syscall?

Answer 3

Creates a new “child” process, similar to fork but gives more precise control over the creation.

Question 4

What’s a pipe?

Answer 4

A pipe is a pair of two file descriptors (fd for short)
– int pipe_fd[2]
• Such that each integer is a handle to a kernel communication object
– pipe_fd[0] = read side of the communication channel
– pipe_fd[1] = write side of the communication channel
– Everything written via pipe_fd[1] can be read via pipe_fd[0]

Question 5

What happens when a running process attempts to read through pipe_fd[0] but
nothing has been written yet via pipe_fd[1]?

Answer 5

the process will block

Question 6

What happens upon writing to a pipe whose read end is close()d?

Answer 6

SIGPIPE (“broken pipe”)

Question 7

What is the macro that provides safe system calling?

Answer 7

#define DO_SYS( syscall ) do { \
/* safely invoke a system call */ \
if( (syscall) == -1 ) { \
perror( #syscall ); \
exit(1); \
} \
} while( 0 )

Question 8

Why do we need a sfae syscall invocation macro (with the do-while trick)?
why not just use an If?

Answer 8

Because then, code like this won’t compile
*/
if( condition )
DO_SYS( read(fd,buf,bufsiz) );
else
printf(“can’t read()”)

Where DO_SYS is used as a statement

Question 9

Why should read/write often be wrapped in a loop?

Answer 9

both syscalls return the

number of bytes they read/written

Question 10

How communication is done in threads and how in processes?

Answer 10

Threads = communication is done via shared memory (more efficient and complicated)
Processes = communication is done via explicit message passing (less efficient and complicated).

Question 11

What’s Multitasking?

Answer 11

– Having multiple processes time slice on the same core

Question 12

What’s Multiprogramming?

Answer 12

– Having multiple jobs in the system (either on the same core or on
different cores)