Lecture Notes for Client-Server Interfaces

25 February 2003 - Process-Based Concurrency

Processed-Based Concurrency

• Create a new process for every new request.

• Processes are expensive.

  • They take up a lot of hardware (memory).

  • They take up a lot of software (operating systems).

  • They are expensive to operate (protection boundries).

• Processes are useful.

  • The program is a familiar design unit.

  • Protection boundries provide good fault isolation.

  • Operating systems work hard to do well by them.

Iterative Stream Server Architecture

void 
its(inet_addr ina, port_no pno)

  skt l = tcp_listener(ina, pno)

  while (true)
    skt c = accept(l)

    msg m
    while read_msg(c, m)
      write_msg(c, reply(m))

    close(c)

Process-Concurrent Stream Server Architecture

void pts(inet_addr ina, port_no pno)
  
  skt s = tcp_listener(ina, pno)

  while true
    skt c = accept(s)

    switch fork()

      case 0
	close(s)

	msg m
	while read_msg(c, m)
	  write_msg(c, reply(m))

	close(c)
	break

      case -1
	perror("fork() failed")
	exit(EXIT_FAILURE)

      default
	close(c)

Parent-Child Synchronization

• A child's termination must be acknowledged by its parent.

  • Until it is, the child is a zombie.

  • Zombies hold system resources until acknowledged.

• Upon child termination, the parent receives a CHLD signal.

  • The parent must handle the signal to acknowledge the termination.

  • Ignoring the signal (the default action) won't do.

• This behavior varies among Unixen, though.

  • Some systems avoid making zombies altogether.

  ---

  Handling CHILD Signals

  • Define a signal handler, and associate it with the CHLD signal.

  void reaper(int sig)
    while (waitpid(-1, NULL, WNOHANG) > 0) { }
  
  
  void pts(inet_addr ina, port_no pno)
    
    skt s = tcp_listener(ina, pno)
  
    signal(SIGCHLD, reaper)
  
    while (true)
      skt c = accept(s)
  
      // as before
  

A Little More Synchronization

• The parent's most likely sitting in an accept().

• What happens when a CHLD signal arrives?

  • It depends; signal behavior varies widely among Unixen.

  • Sometimes you get an interrupted system call.

  • Sometimes the OS restarts the system call for you.

  skt accept(skt s)
  
    skt a
  
    while (true)
      a.s = accept(s.s, NULL, NULL)
      if (a.s > -1) break
      if (errno == EINTR) continue
  
      perror("accept() failed")
      exit(EXIT_FAILURE)
  
    return a
  

• This will be necessary for other system calls too.

Run-Away Process Creation

• Every request creates a new process.

  • An easy denial-of-service attack.

• Create a maximum number of children.

  • This is known as throttling.

Iterative Datagram Server Architecture

void ius(inet_addr ina, port_no pno)

  skt s = udp_socket(ina, pno)
  msg m
  end_point sender

  while read_msg(s, m, sender)
    write_msg(s, reply(m), sender)

Process-Concurrent Datagram Server Architecture

void pus(inet_addr ina, port_no pno)

  skt s = udp_socket(ina, pno)
  msg m
  end_point sender

  signal(SIGCHLD, reaper)

  while read_msg(s, m, sender)
    switch fork()
      case 0
	write_msg(s, reply(m), sender)
	close(s)
	exit(EXIT_SUCCESS)

      case -1
	perror("fork() failed")
	exit(EXIT_FAILURE)

  close(s)

This page last modified on 3 March 2003.