CS452 - Real-Time Programming - Spring 2009

Lecture 21 - Task Structure

Task Structure: the Administrator

1. Proprietor with a Notifier

2. Proprietor/Notifier with a Courier

3. Warehouse

4. Specialization

5. Secretary

6. Proprietor compared to Monitor

Controls a resource

data structure
hardware
etc.

Provides mutual exclusion by owning the 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	Comments
access to resource	localized	localized	Means one at a time.
service model	self-service	full-service
service structure	subroutine of client	independent task
priority	client	probably different	Do we want client priority or resource priority?
address space	client	separate	Hardware vs software protection
permissions	client	different	Does client have permission to run certain instructions?
CPU	same	could be different	Do you need threading?

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?
- how is state shared?
nested receive
- can block proprietor
- don't know that another client is waiting
early reply
- create worker to do work
- reply Pid of worker

7. 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( );
  Receiver ( serverPid, ... );
  Reply( serverPiD )
    // Avoid critical races
  workResult = null;
  FOREVER {
    Send( administrator, workResult, workOrder );
    doWork( workOrder );
  }
}

Administrator code

Administrator( ) {
  Initialize( );
  for ( i = 0; i < NUM_WORKERS; i++ ) worker[i] = Create( workerCode );
  for ( i = 0; i < NUM_WORKERS; i++ ) Send( worker[i], ... , ... );
    // Initialize orderQueue, workerQueue
    // RegisterAs
  FOREVER {
    error = Receive( requester, request );
    switch( request.type ) {
    case CLIENT:
       workOrder = {client = requester, request};
       if( worker = dequeue( workerQueue ) && dataAvailable( ) ) Reply( worker, workOrder );
       else enqueue( orderQueue, workOrder );
       break;
    case NOTIFIER:
       // Acquire data
       // Update state
       // for each queued client
       //    if complete data available && worker available
       //       workorder = {client, request}
       //       Reply( worker, workOrder );
       //    else enqueue client 
       break;
    case WORKER:
      Reply( request.client, request.result );
      if( ( workOrder = deQueue( orderQueue) ) ) {
        workOrder = {workOrder.client, workOrder.request};
        Reply( requester, workOrder );
      } else enqueue( workerQueue, requester );
    }
  }
}

Alternative Administrator Code

Administrator( ) {
  Initialize( );
  for ( i = 0; i < NUM_WORKERS; i++ ) worker[i] = Create( workerCode );
  for ( i = 0; i < NUM_WORKERS; i++ ) Send( worker[i], ... , ... );
    // Initialize orderQueue, workerQueue
    // RegisterAs
  FOREVER {
    error = Receive( requester, request );
    switch( request.type ) {
    case CLIENT:
       workOrder = {client = requester, request};
       if( worker = dequeue( workerQueue ) ) {
          Reply( client, workerTid );
          if ( data complete )  Reply( worker, workOrder );
          else enqueue( client );
       else Reply( client, sorry );
       break;
    case NOTIFIER:
       // Acquire data
       // Update state
       // for each queued client
       //    if complete data available && worker available
       //       workorder = {client, request}
       //       Reply( worker, workOrder );
       //    else requeue client 
       break;
    case WORKER:
      if( ( workOrder = deQueue( orderQueue) ) ) {
        workOrder = {workOrder.client, workOrder.request};
        Reply( requester, workOrder );
      } else enqueue( workerQueue, requester );
    }
  }
}

8. The Detective

Simple Events

The notifier is a task that waits on events.

AwaitEvent is like Send
It has two features
- a simple, kernel-defined event that it waits on
- hardware/kernel is like Receive/Reply
- can only serve one master
The notifier needs to pass on that the event has happened
- which it does using Send
```
FOREVER {
  AwaitEvent( eventId );
  Send( server );
}
```

You could call a notifier a detective,

who looks around on your behalf,
and let's you know when something you care about happens,
but really it is a detective's worker.

Complex Events

In an application there is likely to be lots of waiting on combinations of events.

form the combinations using Boolean operators

We use the detective to discover that a complex event has occurred.

How does the detective work?

Conjunction

Code could be

FOREVER {
  Send( part1 );
  Send( part2 );
  ...
  Send( master );
}

Disjunction

Code above doesn't work! Try instead

// InitializeDB;
// Create workers and synchronize;
// Synchronize with client;
FOREVER {
  Receive( *requester, request );
  if ( request.type == CLIENT ) {
    parsedRequest = parse( request );
    if ( happened( parsedRequest, DB ) ) Reply( requester );
    else enqueue( parsedRequest );
  }
  else if (request.type == WORKER ) {
    updateDB ( request );
    Reply( requester );
    foreach ( queuedRequest )
      if ( happened( parsedRequest, DB ) ) {
        dequeue( parsedRequest );
        Reply( client );
      }
  }
}

This is the code of a detective.

Not

We can say that an event has not happened yet.

Only at the end of the universe can we say that an event simply has not happened.

Time-outs are needed for NOT

OR with Delay on the clock server.

Who is the client of the detective

Initiator of a normal action
Housekeeper of the system who will clean up pathologies (Idletask?))

Return to: