Lecture Notes for Client-Server Interfaces

6 February 2003 - Servers

Server Behavior

• More complex that clients.

• Never stops.

• Handles multiple requests, somehow.

Architectural Issues

• Handling multiple requests - concurrent vs iterative.

• Communication style - confusion reigns.

• Stateless vs Stateful Servers

• The quad design space - connection type x concurrency

Handling Multiple Requests

• real or simulated concurrency

• design, implementation, operation

• concurrent harder than iterative - but not that much harder

• concurrent much harder than iterative - primitive concepts, language support, tools; subtle errors, difficult to reproduce

• concurrent faster than iteration - but perhaps not that much better; latency over throughput; iteration responds better to more hardware

Communication Style

• point to point vs multiplex-multicast

• reliable vs unreliable - connection, delivery, and shut-down

• flow control vs firehose

• stream vs datagram

• you only get two choices - trade-offs conflict

• tcp servers - reliable at the protocol; resource use

• udp servers - lightweight; reliable at the server, expensive and hard

Stateless vs Stateful Servers

• Reliability and performance.

• State creeps in on little cats' feet - caching.

• Lost state wastes resources and causes bloat.

  • And eventually your sever fall down go boom.

Determining Issues

• Service time vs arrival rate

• Service importance.

Iterative Servers

• Iterative servers are simpler, resource light, a potential bottleneck

• Can either be connection-oriented or connection-less.

Connection-Oriented Servers

• listener <- socket()
  bind(listener, ipa, pno)
  listen(listener)
  loop
    active <- accept()
    loop
      msg <- read(active)
      rsp <- f(msg)
      write(active, rsp)
    close(active)
  

• where to listen - at any interface (INADDR_ANY); at any port (0, unlikely)

• no addresses necessary - everything's in the connection

Connection-Less Servers

• active <- socket()
  bind(active, ipa, pno)
  loop
    msg <- recvfrom(active, requester)
    rsp <- f(msg)
    sendto(active, rsp, requester)
  

• where to listen - as above

• The requester's address must be retrieved from the system.

Concurrent Servers

• increasing complexity but improved performance

  • well, maybe - certainly on io-bound communication

  • but - concurrency management overhead

• master-slave architecture

  • also known as the bag o' tasks

  • general approach - master controls the listener socket; slaves handle the active sockets; note connection-oriented description

  • connectionless, concurrent server architecture - mostly pointless without application protocol support

    • master creates the active socket and receives the requests (messages)

    • master demultiplexes the requests to the slaves

    • slaves process the request and send back the reply

    • how many slaves -

    • the active socket is a shared resource - responder contention

  • connection-oriented, concurrent architecture

    • master creates the listening socket and accepts connections

    • each connection accepted is farmed out to a slave

    • the slave handles and closes the connection

  • the slaves

    • from where do they come - fork or threads

    • how many of them are there - resource limitations

    • how long are the around - start-up tear-down overhead

• simulating concurrency - a.k.a. event-driven concurrency

  • osterhout's paper

  • simpler, less resource intensive, good latency and throughput

  • select or poll driven

Trade Offs

• iterative vs. concurrent

  • iterative - simple design, simple implementation, good throughput

  • concurrent - complex design, complex implementation, good latency

• real vs. apparent concurrency

  • context switch costs, information sharing costs

Server Deadlock

• Blocking on request reads.

  • Potentially on reply writes too.

• Single thread hangs; multi-thread wastes resources

• Misbehaving clients

• can be dealt with using signals and timers in unix

This page last modified on 4 February 2003.