Lecture 019

Concurrency Issue

races: outcome depends on arbitrary scheduling decisions deadlock: waiting on each other livelock: going around but with no actual progress starvation/fairness: overall system makes progress but some individuals wait indefinitely

• connect, rio_writen returns while rio_readlineb blocks

Approaches for Concurrent Servers

Process-based

process-based: kernel interleaves multiple logical flows, with private address space

• idea: spawn children to do the work

• pros:

  • simple
  • clear sharing model: share file tables. need to manage fd correctly, reap children.

• cons:

  • overhead for process control
  • nontrivial to share data between processes (children)

Event-based

event-based: programmer manually interleave logical flows, same address space, I/O multiplexing

• idea: keep a set of active connections and use select function to select pending file descriptors connfd or listenfd to generate events.

• pros:

  • one control flow and one address space
  • single-step, sequential debug flow
  • no process or thread control overhead

• cons:

  • more complex than process, thread based design
  • hard to provide fine grained concurrency (have to hold-on incomplete request)
  • cannot take advantage of multi-core (process one connection at a time like scheduling)

Thread-based

thread-based: kernel interleaves multiple logical flows, share address space. Hybrid of process-based and event-based.

• idea:

  • each thread has own logical control flow, stack, local variables (unprotected), registers, thread id (TID)
  • share same code, data, kernel context between threads

• pros:

  • own logical control flow with context switch
  • can run concurrently, support multi-core
  • can share data and code
  • less expensive than processes

• cons:

  • need to avoid unintended sharing (race condition), hard to reproduce error
  • must use thread-safe functions

• different from signal: signal handlers share everything beside stack, interrupts normal program execution, never parallel, Limited forms of synchronization (block, unblock, wait for signal)

Pthreads Library

Pthreads: Standard interface for ~60 functions that manipulate threads from C programs

• 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

Joinable thread: must be reaped with pthread_join() and killed by other threads

• default behavior

Detached thread: cannot be reaped or killed

• resource automatically reaped on termination

• use pthread_detach(pthread_self()) to make detached

• must not call join before thread switch to detached

Producer-Consumer Model: a model for pass in argument for sub thread

• allocate memory in main thread

• free memory in sub thread