CSC209H Lecture 11. Dan Zingaro. March 25, 2015

Transcription

1 CSC209H Lecture 11 Dan Zingaro March 25, 2015

2 Level- and Edge-Triggering (Kerrisk ) When is an FD ready? Two answers: Level-triggered: when an operation will not block (e.g. read will not block), or Edge-triggered: when there is new action on the FD since the last time you asked select is level-triggered If you don t read everything, select will keep telling you that the FD is ready

3 Level- and Edge-Triggering... Edge-triggered You are notified only once when there is new action i.e. if you read only some of the input, the remainder will stay unread and you won t be notified again until new input arrives When working in this mode, you typically want to read all available input This is problematic with blocking reads: if you keep calling read, it will eventually block when there is nothing left to read We therefore typically use nonblocking reads with edge-triggering

4 Signal-Driven I/O (Kerrisk 63.3) Signal-driven I/O is an example of edge-triggered notification To use it, set up a signal handler for SIGIO Then, set the FD to nonblocking (O_NONBLOCK) and asynchronous (O_ASYNC) The kernel will then send SIGIO whenever new data arrives on the FD

5 Example: Signal-Driven I/O (sd.c) #define BUFSIZE 50 volatile sig_atomic_t got_sig; void handler(int sig) { got_sig = 1; int main(void) { char buf[bufsize]; int flags, ret; struct sigaction act; act.sa_handler = handler; sigemptyset(&act.sa_mask); act.sa_flags = 0; if (sigaction(sigio, &act, NULL) == -1) { perror("sigaction"); exit(1);

6 Example: Signal-Driven I/O... if (fcntl(stdin_fileno, F_SETOWN, getpid()) == -1) { perror("fcntl"); exit(1); flags = fcntl(stdin_fileno, F_GETFL); if (fcntl(stdin_fileno, F_SETFL, flags O_ASYNC O_NONBLOCK) == -1) { perror("fcntl"); exit(1); for (; ;) { if (got_sig) { got_sig = 0; while ((ret = read(stdin_fileno, buf, BUFSIZE - 1)) > 0) { buf[ret] = \0 ; printf("got %s\n", buf); return 0;

7 Comparing I/O Models Compared to select, signal-driven I/O scales well when monitoring many FDs However, signal-driven I/O is complicated by signal semantics (e.g. no queueing of signals) Linux-specific features can be used to send and queue signals when FDs are ready If we re going to use Linux features, then epoll is probably best Good performance, supports both edge- and level-triggering

8 Threads vs. Processes Both processes and threads allow an application to perform multiple concurrent tasks Processes don t share memory. Threads do Process creation with fork is slow. Thread creation is much faster Pthreads is the API we use for managing threads

9 Threads Threads belong to a process and share the same PID and parent PID Threads of a process also share the heap and global variables Each thread also has unique attributes Its own thread ID Its own errno variable Its own stack for local variables and function calls

10 Pthread Return Values Many function calls we have seen so far return 0 for success, -1 for failure Pthreads functions are different They return 0 for success, and a positive integer for failure If a function fails, we can store the positive integer into errno and then call perror

11 Creating New Threads int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start)(void *), void *arg); thread is where the ID of the new thread gets stored attr specifies attributes for the thread; use NULL for defaults start is a pointer to a function The new thread runs start with argument arg arg typically points to a heap or global variable

12 Thread Termination A thread terminates when one of the following happens Its start function returns It calls pthread_exit It gets canceled by another thread using pthread_cancel Any thread in the process calls exit So don t call exit unless you want the entire process to terminate!

13 Thread Joining int pthread_join(pthread_t thread, void **retval); This is similar to using waitpid to wait for a process to terminate pthread_join waits for a thread to terminate, or returns immediately if the thread has already terminated

14 Creating and Joining (threads.c) Compile Pthreads programs with gcc -pthread. errno = pthread_create(&t1, NULL, thread_func, "Hello\n"); if (errno!= 0) { perror("pthread_create"); exit(1); printf("main() before joining...\n"); errno = pthread_join(t1, &res); if (errno!= 0) { perror("pthread_join"); exit(1);

15 Thread Joining... Differences between pthread_join and waitpid: No thread hierarchy. Any thread can use pthread_join to wait for any other thread There is no way to join with any thread There is no equivalent to WNOHANG

16 Detaching a Thread int pthread_detach(pthread_t thread); We can detach a thread if we don t want to obtain its exit status If we detach a thread, it is cleaned-up automatically We must detach or join every thread

17 Disadvantages of Threads When using threads: Only thread-safe functions can be used A bug in one thread can damage other threads Its difficult to use signals with threads All threads in a process must run the same program