CS452 - Real-Time Programming - Spring 2008

Lecture 26 - The Administrator

Questions & Comment

Kernel hand-in

Server Structure

What this amounts to is

Server should be lean and hungry
- do as little as possible
- always be receive blocked

Proprietor

Controls a resource

data structure
hardware
etc.

Provides mutual exclusion by having the only code that accesses the resource

sequential code
ergo, easy

Proprietor provides service to clients

nameserver is an example.
one client is receiving service (REPLY-BLOCKED)
the others are waiting (RECEIVE-BLOCKED)
in this respect, like a monitor

Like a subroutine call to the client

does not facilitate concurrency
proprietor must fail requester if anything is missing

Proprietors versus Monitors


	Monitor	Proprietor
access to resource	localized	localized
service model	self-service	full-service
service structure	subroutine of client	independent task
priority	client	possibly different
address space	client	separate
permissions	client	possibly different
CPU	same	could be different

Generic Problem: Local Delay

Proprietor begins processing

discovers that it cannot complete

Can other requests be processed? Possible strategies

refusal
- client may poll
siblings
- pass requests along
- how does a client find the free one?
nested receive
- can block proprietor
- don't know that another client is waiting
early reply
- create worker to do work
- reply Pid of worker

Administrator, Worker

Generalization of proprietor

spawns workers to handle tasks

Administrator maintains an array of records

each record is a REPLY-BLOCKED task

Administrator works as he can on any one of the tasks.

Real administrators manage workers

static administrators create an array of unemployed workers in advance
dynamic administrators create workers as they need them

Worker code

Worker( ) {
  Initialize( );
    // Find administrator Pid
    // Avoid critical races
  Send( administrator, requestForWork, workOrder );
  FOREVER {
    doWork( workOrder );
    Send( administrator, workResult, workOrder );
  }
}

Administrator code

Administrator( ) {
  Initialize( );
    // start up workers
    // RegisterAs
  FOREVER {
    error = Receive( requester, request )
    if ( request.type == CLIENT ) {
      workOrder = {client = requester, request};
      if ( workerAvailable ) Reply( worker, workOrder );
      else enQueueWorkOrder( );
    }
    if ( request.type == WORKER ) {
      Reply( request.client, request.result );
      if ( ( client = clientWaiting( ) ) ) {
        workOrder = {client, client.request};
        Reply( worker = requester, workOrder );
      } else putWorkerIntoUnemployedWorkerArray( );
    }
  }
}

Remote delay

Return to: