Lecture 4: Concurrency and Threads

Lecture 4: Concurrency and Threads CS 170 T Yang, 2015 Chapter 4 of AD textbook

Chapter 4: Threads • Overview • thread — a fundamental unit of CPU utilization that forms the basis of multithreaded computer systems • Thread Libraries • Pthreads • Nachos threads

Logical View of Threads • Threads associated with a process A process Process hierarchy T2 T4 T1 P1 shared code, data and kernel context sh sh sh T3 T5 foo

Benefits of multi-threading • Responsiveness • Resource Sharing • Shared memory • Economy • Scalability • Explore multi-core CPUs

Motivation for multi-threaded servers

Thread Abstraction • Infinite number of processors • Threads execute with variable speed • Programs must be designed to work with any schedule

Concurrent Thread Execution • Two threads run concurrently (are concurrent) if their logical flows overlap in time • Otherwise, they are sequential (we’ll see that processes have a similar rule) • Examples: • Concurrent: A & B, A&C • Sequential: B & C Thread A Thread B Thread C Time

Execution Flow Concurrent execution on a single core system Parallel execution on a multi-core system

Programmer vs. Processor View

Difference between Single and Multithreaded Processes Shared memory access for code/data Separate control flow -> separate stack/registers

Threads vs. Processes • How threads and processes are similar • Each has its own logical control flow • Each can run concurrently • Each is context switched • How threads and processes are different • Threads share code and data, processes (typically) do not • Threads are somewhat cheaper than processes with less overhead

Thread Libraries • Thread library provides programmer with API for creating and managing threads • Pthreads • Java threads • OS-specific threads • Nachos for class proj.

Pthreads • provided either as user-level or kernel-level • A POSIX standard (IEEE 1003.1c) API for thread creation and synchronization • Common in UNIX OS (Linux, Mac OS X). • In CSIL, compile a c program with gcc -lpthread

Posix Threads (Pthreads) Interface • Creating and reaping threads • pthread_create, pthread_join • Determining your thread ID • pthread_self • Terminating threads • pthread_cancel, pthread_exit • exit [terminates all threads] , return [terminates current thread] • Synchronizing access to shared variables • pthread_mutex_init, pthread_mutex_[un]lock • pthread_cond_init, pthread_cond_[timed]wait

Example of Pthreads • #include <pthread.h> • #include <stdio.h> • void *PrintHello(void * id){ • printf(“Thread%d: Hello World!\n", id); • } • void main (){ • pthread_t thread0, thread1; • pthread_create(&thread0, NULL, PrintHello, (void *) 0); • pthread_create(&thread1, NULL, PrintHello, (void *) 1); • }

Example of Pthreads with join • #include <pthread.h> • #include <stdio.h> • void *PrintHello(void * id){ • printf(“Thread%d: Hello World!\n", id); • } • void main (){ • pthread_t thread0, thread1; • pthread_create(&thread0, NULL, PrintHello, (void *) 0); • pthread_create(&thread1, NULL, PrintHello, (void *) 1); • pthread_join(thread0, NULL); • pthread_join(thread1, NULL); • }

Execution of Threaded “hello, world” main thread call Pthread_create() peer thread call Pthread_join() printf() main thread waits for peer thread to terminate (peer thread terminates) Pthread_join() returns exit() terminates main thread and any peer threads

Java Threads • Java threads are managed by the JVM • Java threads may be created by extending Thread class • Thread class • run, start methods • yield, join • sleep • Synchronization • synchronized methods & objects • wait/notify/notifyAll • conditions

Java Threads: Example class MyThread extends Thread { private String name; public MyThread(String name) { this.name = name; } public void run() { for (;;) { System.out.println(name + ": hello world"); } } } public class Main2 { public static void main(String [] args) { MyThread t1 = new MyThread("thread1"); MyThread t2 = new MyThread("thread2"); t1.start(); t2.start(); } }

Java Threads: example outpout thread2: hello world thread2: hello world thread2: hello world thread2: hello world thread2: hello world thread2: hello world thread2: hello world thread2: hello world thread1: hello world thread2: hello world thread1: hello world thread2: hello world thread2: hello world thread1: hello world thread2: hello world thread2: hello world

Nachos Threads • class Thread{ public: Thread (char *name); ~Thread(); void Fork( void (*Func)( int), int arg); void Yield(); void Finish(); }

Nachos Threads for 170 OS Project C++ methods supported: • Thread(char *Name). Create a thread. • Fork(VoidFunctionPtr func, int arg). A thread starts to execute a function. • Yield(). Suspend the calling thread and the system selects a new one for execution. • Sleep(). Suspend the current thread, change its state to BLOCKED, and remove it from the ready list • Finish()

Example of Nacho Threads Create 2 new thread data structure main () { Thread *t1 =new Thread("thread1"); Thread *t2= new Thread("thread2"); t1->Fork(SimpleFunc, 1); t2->Fork(SimpleFunc, 2); SimpleFunc(3); } SimpleFunc(int i) { printf(“Hello %d\n”, i); currentThread->Yield(); } Start to fork and execute a function in each child thread. Parent executes the same function Function executed by threads

Thread Lifecycle

Implementing threads • Thread_fork(func, args) • Allocate thread control block • Allocate stack • Build stack frame for base of stack (stub) • Put func, args on stack • Put thread on ready list • Will run sometime later (maybe right away!) • stub(func, args): • Call (*func)(args) • Call thread_exit() • Thread switching during scheduling • Save registers on old stack • Switch to new stack, new thread • Restore registers from new stack

Shared vs. Per-Thread State

Types of Threads: Kernel vs user-level Kernel Threads • Recognized and supported by the OS Kernel • OS explicitly performs scheduling and context switching of kernel threads • Linux, MacOS, Windows

User-level Threads • Thread management done by user-level threads library • OS kernel does not know/recognize there are multiple threads running in a user program. • The user program (library) is responsible for scheduling and context switching of its threads. • Examples: • Java threads

Summary: Process vs Thread • Processes have two parts • Threads (Concurrency) • Address Spaces (Protection) • Concurrency accomplished by multiplexing CPU Time: • Unloading current thread (PC, registers) • Loading new thread (PC, registers) • Such context switching may be voluntary (yield(), I/O operations) or involuntary (timer, other interrupts) • Protection accomplished restricting access: • Memory mapping isolates processes from each other • Dual-mode for isolating I/O, other resources • Various Textbooks talk about processes • When this concerns concurrency, really talking about thread portion of a process • When this concerns protection, talking about address space portion of a process John Kubiatowicz (http://cs162.eecs.Berkeley.edu)

Lecture 4: Concurrency and Threads