ECE 598 Advanced Operating Systems Lecture 23

Transcription

1 ECE 598 Advanced Operating Systems Lecture 23 Vince Weaver 21 April 2016

2 Don t forget HW#9 Midterm next Thursday Announcements 1

3 Process States Running on CPU Ready ready but no CPU available Blocked waiting on I/O or resource Terminated 2

4 The Linux Scheduler People often propose modifying the scheduler. That is tricky. Scheduler picks which jobs to run when. Optimal scheduler hard. What makes sense for a longrunning HPC job doesn t necessarily make sense for an interactive GUI session. Also things like I/O (disk) get involved. You don t want it to have high latency 3

5 Linux originally had a simple circular scheduler. for 2.4 through 2.6 had an O(N) scheduler Then Then in 2.6 until had an O(1) scheduler (constant time, no many how many processes). Currently the Completely Fair Scheduler (with lots of drama). Is O(log N). Implementation of weighted fair queuing How do you schedule? Power? Per-task (5 jobs, each get 20%). Per user? (5 users, each get 20%). 4

6 Per-process? Per-thread? Multi-processors? Hyperthreading? Heterogeneous cores? Thermal issues? 5

7 Threads Each process has one address space and single thread of control. It might be useful to have multiple threads share one address space GUI: interface thread and worker thread? Game: music thread, AI thread, display thread? Webserver: can handle incoming connections then pass serving to worker threads Why not just have one process that periodically switches? 6

8 Lightweight Process, multithreading Implementation: Each has its own PC Each has its own stack Why do it? shared variables, faster communication multiprocessors? mostly if does I/O that blocks, rest of threads can keep going allows overlapping compute and I/O 7

9 Problems: What if both wait on same resource (both do a scanf from the keyboard?) On fork, do all threads get copied? What if thread closes file while another reading it? 8

10 Common Thread Routines pthreads thread init() thread create() specify function thread exit() thread yield() if cooperative 9

11 Thread Implementations Cause of many flamewars over the years 10

12 User-Level Threads (N:1 one process many Benefits threads) Kernel knows nothing about them. Can be implemented even if kernel has no support. Each process has a thread table When it sees it will block, it switches threads/pc in user space Different from processes? When thread yield() called it can switch without calling into the kernel (no slow 11

13 kernel context switch) Can have own custom scheduling algorithm Scale better, do not cause kernel structures to grow Downsides How to handle blocking? Can wrap things, but not easy. Also can t wrap a pagefault. Co-operative, threads won t stop unless voluntarily give up. Can request periodic signal, but too high a rate is inefficient. 12

14 Can t take advantage of multiple CPUs 13

15 Kernel-Level Threads (1:1 process to Benefits thread) Kernel tracks all threads in system Handle blocking better Downsides Thread control functions are syscalls When yielding, might yield to another process rather than a thread 14

16 Might be slower 15

17 Hybrid (M:N) Can have kernel threads with user on top of it. Fast context switching, but can have odd problems like priority inversion. 16

18 Green Threads Managed by virtual machine Java 17

19 Misc Pop-up threads? Thread created for incoming message? adding multithreading to code? How to handle global variables (errno?) Thread-safe functions. Is strtok thread-safe? malloc? any routine that might not be re-entrant How are multiple stacks handled? One option each thread gets own copy of global variables. This can t be expressed by default in C, you need special routines, thread-local variables. 18

20 # include < pthread.h> # include <stdio.h> # include <stdlib.h> # include <assert.h> # define NUM_THREADS 10 POSIX Threads (pthreads) void * perform_work ( void * argument ) { int value ; value = *(( int *) argument ); printf (" Thread with argument %d!\n", value ); } return NULL ; int main ( int argc, char ** argv ) { pthread_t threads [ NUM_THREADS ]; int thread_args [ NUM_THREADS ]; 19

21 int result, i; /* create threads one by one */ for ( i = 0; i < NUM_THREADS ; i ++) { thread_args [i]=i; printf (" Main : creating thread %d\n", i); result = pthread_create (& threads [ i], NULL, perform_work, ( void *) & thread_args [i ]); if ( result!=0) { fprintf ( stderr," ERROR!\n"); return -1; } } /* wait for each thread to complete */ for ( i = 0; i < NUM_THREADS ; i ++) { /* block until each thread completes */ result = pthread_join ( threads [ i], NULL ); printf (" MAIN : thread %d has completed \n", i); if ( result!=0) { fprintf ( stderr," ERROR!\n"); return -1; } } 20

22 printf (" MAIN : All threads completed successfully \n"); } return 0; 21

23 POSIX Threads (pthreads) programming Pass -pthread to gcc Thread management pthread create (thread,attr,start routine,arg) pthread exit (status) pthread cancel (thread) pthread attr init (attr) pthread attr destroy (attr) pthread join (threadid,status) blocks thread 22

24 until specified thread finishes pthread detach (threadid) pthread attr setdetachstate (attr,detachstate) pthread attr getdetachstate (attr,detachstate) pthread attr getstacksize (attr, stacksize) pthread attr setstacksize (attr, stacksize) pthread attr getstackaddr (attr, stackaddr) pthread attr setstackaddr (attr, stackaddr) Mutexes (synchronization) pthread mutex init (mutex,attr) 23

25 pthread mutex destroy (mutex) pthread mutexattr init (attr) pthread mutexattr destroy (attr) pthread mutex lock (mutex) pthread mutex trylock (mutex) pthread mutex unlock (mutex) Condition Variables another way to synchronize Synchronization 24

26 Linux Posix Threads Originally used only userspace implementations. portable threads. GNU LinuxThreads use clone syscall, SIGUSR1 SIGUSR2 for communicating. Could not implement full POSIX threads, especially with signals. Replaced by NPTL Hard thread-local storage 25

27 Needed extra helper thread to handle signals Problems, what happens if helper thread killed? Signals broken? 8192 thread limit? proc/top clutter up with processed, not clear they are subthreads NPTL New POSIX Thread Library Kernel threads Clone. Add new futex system calls. Drepper and Molnar at RedHat Why kernel? Linux has very fast context switch compared to some OSes. Need new C library/abi to handle location of thread- 26

28 local storage On x86 the fs/gs segment used. Others need spare register. Signal handling in kernel Clone handles setting TID (thread ID) exit group() syscall added that ends all threads in process, exit() just ends thread. exec() kills all threads before execing Only main thread gets entry in proc 27

29 Misc adding multithreading to code? How to handle global variables (errno?) Thread-safe functions. Is strtok thread-safe? malloc? any routine that might not be re-entrant How are multiple stacks handled? One option each thread gets own copy of global variables. This can t be expressed by default in C, you need special routines, thread-local variables. 28

30 IPC Inter-Process Communication Processes want to communicate with each other. Examples? Two issues: getting the message across synchronizing signals network, message passing (send, receive) 29

31 shared memory (mmap) 30

32 Linux Signals and Signal handlers Very much like interrupts Concurrency issues much like threading Pipes stdout of one program to stdin of another one-way (half duplex) ls sort pipe system call / dup 31

33 C library has popen() FIFOs (named pipes) exist as file on filesystem SystemV IPC shared memory, semaphores ipcs Just use mmap Unix domain sockets Can send file descriptors across 32

34 Splice move data from fd to pipe w/o a copy? VM magic? Sendfile. zero copy? 33