Processes and Threads

1. CSCI 156 Processes and Threads

2. Project 2 Server • How would you write it? • Multiple connections on multiple ports • Communication between input handlers and output generators • Some Options • Multiple processes • Multiple threads • One monolithic program

3. Multiple Processes pid_t fork(); Child process has value of 0 for the returned pid Parent has process id of the child int pid = fork(); if(pid) { printf("I'm the parent! pid=%d\n", pid); } else { printf("I'm just a baby! pid=%d\n", pid); } This is frequently used to open a new program with exec: fork then have the child exec.

4. Multiple Processes (cont.) int execve(const char *filename, char *const argv [], char *const envp[]); execve() runs the program at path “filename”, with arguments argv and optional environment variables in envp. argv[0] must be the same as filename. pid_t wait(int *status); wait() blocks until a child process exits. It then returns the child pid, and fills the status variable with the exit return code of the child. pid_t waitpid(pid_t pid, int *status, int options); waitpid() lets you specify a child pid to wait for, and also allows options to be passed

5. Multiple Processes (cont.) int pid, status, error; char *name[2], *foo; foo = (char*) malloc(20 * sizeof(char)); printf("give us a string!\n"); scanf("%s", foo); pid = fork(); if(pid) { printf("I'm the parent! pid=%d\n", pid); if(waitpid(pid, &status, 0) == pid) { printf("my baby died!\n"); } } else { printf("I'm just a baby! pid=%d\n", pid); name[0] = "/bin/echo"; name[1] = foo; execve(name[0], name, NULL); } Any problems with this code?

6. Command Line Arguments int main (int argc, char* argv[]) { } argv - is an array of character pointers to the words that were on the command line argc - holds the number of words specified in the command (length of argv array) ./myPrg 5 results in argc=2 with argv[0]=“./myPrg” and argv[1]=“5” int x; x = atoi(argv[1]); /* Now x=5 */

7. Multiple Processes (cont.) int main (int argc, char* argv[]) { int pid, status, error; char *name[2]; pid = fork(); if(pid) { printf("I'm the parent! pid=%d\n", pid); if(waitpid(pid, &status, 0) == pid) { printf("my baby died!\n"); } } else { printf("I'm just a baby! pid=%d\n", pid); name[0] = "/bin/echo"; name[1] = argv[1]; execve(name[0], name, NULL); } }

8. Multiple Processes (cont.) forkbomb (n) – 'explodes' by recursively spawning copies of itself. eventually overloads the number of available processes, and stalls the machine. DO NOT try this on hobbes: Sheryl will destroy you. main() {for(;;)fork();} expanded: int main() { while(1) fork(); }

9. Multiple Processes (cont.) Back to the server: we fork once for each new connection and have the children handle the incoming messages: create sockets, bind to both ports loop forever if(incoming sender connection) fork if(child – sender process) loop waiting for messages on connected socket if a msg/file, send to all recver processes done if(incoming recver connection) fork if(child – recver process) loop waiting for messages from sender processes if a valid msg/file, send to connected socket done done

10. Multiple Processes (cont.) Problem with multiple processes is use of Unix IPC methods to communicate between processes: SIGNALS: sigaction() sets a function to be called when the program gets a signal. kill(pid, signal) sends the signal to a process. Can't send actual data, just two instructions: SIGUSR1 and SIGUSER2 SHARED MEMORY: shmget() is used to create/get a reference to shared memory, then shmat is used to get a normal pointer to it (shmdt to give it up). Use a mutex to control access. PIPES: pipe() creates two file descriptors that can be used with write/read (like send/recv on sockets). Should be used one-way, created before forking FIFO (named pipes): special file on disk, created with mkfifo. Uses write/read, but can be used between non-forked programs Lots more! http://www.ecst.csuchico.edu/~beej/guide/ipc/

11. One Monolithic Program Must keep an array of open sockets, and when a connection is accept()-ed, add to the list, then have one large loop that checks for incoming information on each open socket, then checks for new connections. Overall structure: create sockets, bind to both ports loop forever loop through open sender sockets check for messages on open “sender” connections if(incoming message) if a msg/file loop on all open “recver” connections send message to recver while(there are incoming sender connections) add to sender socket array while(there are incoming recver connections) add to recver socket array done Advantages/Disadvantages?

12. Threads Threads are similar to processes, but all run under a single process ID, and share more information than forked processes (exam T/F question?) Threads have some advantages: 1) less overhead (creating a process = expensive) 2) can take more advantage of SMP support 3) no need to use Unix IPC: can use mutex locks But also disadvantages: 1) debugging them can be a pain (better with gdb 6+, kernel 2.6+, but still no fun at all) 2) code is complicated: for simple programs, maybe easier to fork

13. Let’s create a thread… How? Need to include the library #include <pthread.h> And compile with the -lpthread flag: gcc -lpthread mySource.c Like any other type: need to declare and malloc pthread_t *ghostThread; ghostThread = (pthread_t*)malloc(sizeof(pthread_t));

14. Let’s create a thread (cont.) We can then set up the thread and actually start it running: void *our_function (void *parameter) { printf(“Hello World\n”); } int main () { void* parameter=NULL; pthread_t* pacmanThread; pacmanThread = (pthread_t*)malloc(sizeof(pthread_t)); pthread_create(pacmanThread, NULL, our_function, parameter); }

15. Let’s create a thread (cont.) int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);   The pthread_create() function is used to create a new thread, with attributes specified by attr, within a process. If attr is NULL, the default attributes are used. If the attributes specified by attr are modified later, the thread's attributes are not affected. Upon successful completion, pthread_create() stores the ID of the created thread in the location referenced by thread. The thread is created executing start_routine with arg as its sole argument. If the start_routine returns, the effect is as if there was an implicit call to pthread_exit() using the return value of start_routine as the exit status.

16. Thread Attribute Type Used to pass desired attributes to create Declaration: pthread_attr_t pthread_custom_attr; Functions used with: pthread_attr_init(&pthread_custom_attr); int pthread_attr_setschedpolicy (pthread_attr_t *attr, int policy); Use with policy constants: SCHED_FIFO, SCHED_RR and SCHED_OTHER int pthread_attr_setstacksize (pthread_attr_t *attr, size_t stacksize);

17. Lets create a thread continued We can then set up the thread using the attributes and actually start it running: pthread_create(ghostThread, pthread_custom_attr, our_thread_function, parameter);

18. Some useful pthread functions void pthread_exit(void *value_ptr); Called inside our threaded function. The pthread_exit function terminates the thread that calls it and makes the value value_ptr available to its parent (if the parent has joined on it) int pthread_join(pthread_t thread, void **value_ptr); The pthread_join() function suspends execution of the calling thread until the target thread terminates, unless the target thread has already terminated. On return from a successful pthread_join() call with a non-NULL value_ptr argument, the value passed to pthread_exit() by the terminating thread is made available in the location referenced by value_ptr.

19. Locks Declaration: /* Global Variables */int myInt;pthread_mutex_t myIntLock; Must be Initialized prior to use: pthread_mutex_init(&myIntLock, NULL); Locks also have an attribute field (much like threads): int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

20. Locking and Unlocking int pthread_mutex_lock(pthread_mutex_t *mutex); Blocks if someone else has the lock.. int pthread_mutex_trylock (pthread_mutex_t *mutex); Doesn’t block if someone else has lock. Call returns with failure. Lets you do other things… Finished with the lock- let it go: int pthread_mutex_unlock (pthread_mutex_t *mutex);

21. Locks Finale When all threads finished with the lock: int pthread_mutex_destroy (pthread_mutex_t *mutex); pthread_mutex_destroy(&myIntLock); Spin Waiting – Not preferred way to go. Why? while(!pthread_mutex_trylock(&myIntLock)) { /* Do nothing */ } /* critical section */