Multithreaded Programming

Transcription

1 Multithreaded Programming

2 The slides do not contain all the information and cannot be treated as a study material for Operating System. Please refer the text book for exams. September 4, 2014

3 Topics Overview Multithreaded Models Thread Libraries Threading Issues Linux threads Thread Scheduling

4 Issues with processes The fork() system call is expensive Context switch between process is expensive IPC is required to pass information between parent and child process

5 Thread Concept A thread is a lightweight process which executes within the address space of a process A thread can be scheduled to run on a CPU as an independent unit and terminate Multiple threads can run simultaneously

6 Thread Concept Threads have their own Thread ID CPU context(pc,sp, register) Stack Priority Errno

7 Thread Concept Threads share Code and data Open files Current working directory User ids and group ids PCB

8 Single and Multithreaded Processes

9 Thread are similar to processes A thread can be in a state similar to a process(new, ready, running, blocked) A thread can create another thread

10 Thread are different from processes Multiple threads can operate within the same address space No automatic protection mechanism is in place for threads they are meant to help each other

11 Multithreaded Server Architecture

12 Benefits Responsiveness continue running even if part of it is blocked multithreaded web browser could allow user interaction in 1 thread and load an image in another Resource Sharing threads share memory and resources of the process whereas process can share memory through IPC and shared memory Economy More economical to create, schedule, context switch and terminate threads Solaris creating process is 30 times slower and context switch is 5 times slower Scalability Benefit in multiprocessor architecture multiple threads can run simultaneously

13 Concurrent Execution on a Single-core System Parallel Execution on a Multicore System

14 Multicore Programming Multicore systems putting pressure on programmers, challenges include: Dividing activities Divide to separate concurrent tasks that can run in parallel on individual cores Balance - tasks should perform equal work of value. Use separate execution core to run that task may not be worth the cost Data splitting Like application are divided into separate task, data accessed and manipulated by the tasks must be divided to run on separate cores.

15 Multicore Programming Data dependency - The data accessed by the tasks must be examined for dependency between two or more tasks Testing and debugging - There are many different execution paths. Testing and debugging is more difficult

16 User Threads Thread management done by user-level threads library Kernel is not aware of threads CPU is not interrupted during thread switching A system call by a thread blocks the whole process P1 has 1 thread and p2 has 100 threads. Both have same priority Three primary thread libraries: POSIX Pthreads Win32 threads Java threads

17 Kernel Threads Supported by the Kernel Kernel is aware of threads CPU switched during context switching A system call does not block the whole process No fair scheduling. High priority to lot of kernel threads Examples Windows XP/2000 Solaris Linux Tru64 UNIX Mac OS X

18 Multithreading Models Many-to-One One-to-One Many-to-Many

19 Many-to-One Many user-level threads mapped to single kernel thread One blocks all the threads are blocked Examples: Solaris Green Threads GNU Portable Threads

20 One-to-One Each user-level thread maps to kernel thread Examples Windows NT/XP/2000 Linux Solaris 9 and later

21 Many-to-Many Model Multiplexes many user level threads to small or equal kernel threads No of kernel threads is specific to particular application or machine( multiprocessor vs uniprocessor) When a thread performs a blocking call, kernel can schedule another thread for execution. Solaris prior to version 9 Windows NT/2000

22 Two-level Model Similar to M:M, except that it also allows a user thread to be bound to kernel thread Examples IRIX HP-UX Tru64 UNIX Solaris 8 and earlier

23 Thread Libraries Thread library provides programmer with API for creating and managing threads Two primary ways of implementing Library entirely in user space Kernel-level library supported by the OS

24 Pthreads A POSIX standard (IEEE c) API for thread creation, termination and synchronization API specifies behavior of the thread library, implementation is up to development of the library Common in UNIX operating systems (Solaris, Linux, Mac OS X)

25 Creating a thread int pthread_create(pthread_t *threadp, threadp -> thread id const pthread_attr_t *attr, void* (*routine)(void*), arg *arg); attr -> assign specific attributes ( stack size, stack addresses, joinable, priority) to the thread created and it s a constant. Joinable thread - > can another thread wait for this to terminate so that second would make progress Void* -> name of the function whose code is made as a thread Arg -> pass any arguments to the function

26 Join a thread Waiting for a thread int pthread_join( pthread_t athread, void **statusp); Statusp get return value of pthread_exit Can only join with the thread s in the same process address space Multiple thread can join with one thread but only one returns successfully ; others return with an error that no thread could be found with the given TID

27 Terminating a thread Main thread terminates Thread returns void pthread_exit(void *valuep) Returns value pointed by valuep to a joining thread

28 Pthreads Example

29 Pthreads Example

30 Java Threads Java threads are managed by the JVM Typically implemented using the threads model provided by underlying OS (pthreads or Win32 threads) Java threads may be created by: 1) Create a class derived from Thread class and override its run() method 2) Implementing the Runnable interface Does creating a thread object, create a new thread? No, it start() method that creates a new thread

31 Java Multithreaded Program

32 Java Multithreaded Program (Cont.)

33 Java Threads What does start method do? It allocates memory and initializes a new thread in the JVM It calls the run method making the thread eligible to run by the JVM Why cant you use Integer object to store the data? Integer class is immutable( once its value is set, it cannot be changed)

34 Threading Issues 1. The fork() and exec() system calls If one thread in the program calls a fork(), does the new process duplicate all the threads, or single threaded? Some unix systems have 2 versions One that duplicates all threads One that duplicates only the thread that invoked fork() Exec() the program specified in the parameter to exec() will replace the entire process including all threads If exec is called immediately after forking then duplicating all threads is unnecessary If separate process does not call exec() after forking, the separate process should duplicate all threads

35 Threading Issues (Cont.) 2. Cancellation - Terminate a thread before it has completed Thread to be cancelled target thread Asynchronous cancellation One thread immediately terminates the target thread Deferred cancellation The target thread periodically checks if it should terminate. Issues Situations where resources have been allocated to a cancelled thread, or cancelled while updating data Cancellation point Target thread has checked a flag to determine whether or not it should be cancelled (check point)

36 Threading Issues (Cont.) 3. Signal handling Signals are used in UNIX systems to notify a process that a particular event has occurred. A signal handler is used to process signals. All signals follow this pattern 1. Signal is generated by particular event 2. Signal is delivered to a process 3. Signal is handled Synchronous signal illegal memory access Synchronous signals are delivered to same process that performed the operation that caused the signal

37 Threading Issues (Cont.) When a signal is generated by an event external to the running process, that process receives signal asynchronously Signal has a default handler or user defined signal handler When, where should a signal be delivered in multithreaded? Options: Deliver the signal to the thread to which the signal applies (synch) Deliver the signal to every thread in the process(asynch) Deliver the signal to certain threads in the process Assign a specific thread to receive all signals for the process

38 Threading Issues (Cont.) 4. Thread Pools Unlimited threads could exhaust the resources CPU time and memory Create a number of threads in a pool where they await work. Advantages: Usually slightly faster to service a request with an existing thread than create a new thread Allows the number of threads in the application(s) to be bound to the size of the pool No of threads can be set heuristically based on factors like no of CPU, amount of physical memory and expected no of concurrent request

39 Threading Issues (Cont.) 5. Thread Specific Data Allows each thread to have its own copy of data Libraries provide a form of help for threads to maintain its own copy of data

40 Threading Issues (Cont.) 6. Scheduler Activations Both M:M and Two-level models require communication to maintain the appropriate number of kernel threads allocated to the application They place an intermediate DS called LWP(virtual processor on which application can schedule a user thread to run) LWP attached to kernel threads OS schedule kernel threads If a kernel thread block, LWP Blocks and user thread block Single processor one LWP is Sufficient LWP is required for each blocking System call

41 Scheduler Activation

42 Scheduler Activation Scheduler activations works as follows The kernel provides application with certain set of LWP and it can schedule onto LWP Kernel provide upcalls - a communication mechanism from the kernel to the thread library Thread library handles all Upcalls with the help of Upcall handler run on LWP Even that triggers upcall are whhen a thread is about to block The kernel then allocates a new LWP to the application The application runs an upcall handler on this new processor that saves the state of the blocking thread and schedules another thread

43 Linux Threads Linux refers to them as tasks rather than threads Thread creation is done through clone() system call clone() allows a child task to share the address space of the parent task (process) CLONE_FS file system CLONE_VM memory space CLONE_SIGHAND signal handlers CLONE_FILES the set of open files struct task_struct points to task data structures (shared or unique)

44 Linux Threads This data structure, instead of storing data for the task has pointers to other data structures where these data are stored Eg: Data structure that represent the list of open files, signal handling information, and virtual memory When a clone() is called the new task points to the data structures of the parent task, depending on the set of flags passed to clone

45 Thread Scheduling Diff between user and kernel threads is how they are scheduled When threads are supported, threads scheduled, not processes Many-to-one and many-to-many models, thread library schedules user-level threads to run on LWP Known as process-contention scope (PCS) since scheduling competition among threads within the process Typically done via priority set by programmer Kernel thread scheduled onto available CPU is systemcontention scope (SCS) competition among all threads in system

46 Thread Scheduling One distinction between user level threads and kernel level threads lies in how they are scheduled Schedule user threads on available LWP process contention scope(pcs) Deciding which kernel thread to schedule System contention scope (SCS) API allows specifying either PCS or SCS during thread creation PTHREAD_SCOPE_PROCESS schedules threads using PCS scheduling PTHREAD_SCOPE_SYSTEM schedules threads using SCS scheduling Can be limited by OS Linux and Mac OS X only allow PTHREAD_SCOPE_SYSTEM

47 Pthread Scheduling API #include <pthread.h> #include <stdio.h> #define NUM THREADS 5 int main(int argc, char *argv[]) { int i; pthread t tid[num THREADS]; pthread attr t attr; /* get the default attributes */ pthread attr init(&attr); /* set the scheduling algorithm to PROCESS or SYSTEM */ pthread attr setscope(&attr, PTHREAD SCOPE SYSTEM);

48 Pthread Scheduling API /* create the threads */ for (i = 0; i < NUM THREADS; i++) pthread create(&tid[i],&attr,runner,null); /* now join on each thread */ for (i = 0; i < NUM THREADS; i++) pthread join(tid[i], NULL); } /* Each thread will begin control in this function */ void *runner(void *param) { printf("i am a thread\n"); pthread exit(0); }

49 References Youtube Operating System lecture series CS604