CS452 - Real-Time Programming - Spring 2012

Lecture 23 - Administrator, Detective

Public Service Annoucements

Exam: 9.00, August 8 to 11.30, August 9.
- What is the earliest that anybody is planning to start?
I now have back my document creation tools. Assignments will start to be more uptodate.

5. Administrator, Worker

Administrator is a proprietor who does no work but only assigns work to others

Tasks are given to workers
If Create is fast and you have a method for reclaiming resources you can Create and Destroy workers on demand.
Otherwise workers are created at initialization and the administrator maintains a pool of free workers
each free worker is a REPLY-BLOCKED task

Real administrators manage workers

Static organizations hire a workforce of employees who are assigned tasks as they come up.
- And if they have run out of employees then you (the client) just have to wait.
- If the worker is waiting for some data to be available, which is the most common case, then
  - a worker at the priority of the client does the waiting,
  - the administrator goes on to supply workers to other clients,
  - nobody loses
Dynamic organizations hire workers after the need for work appears, and fire them when the work is done. These are called contract workers or consultants.
- You need Destroy to achieve a dynamic structure.
- Helpers hired by the consultant fired with the consultant.
Semi-dynamic organizations are between static and dynamic.
- New workers are hired (created),
- but they are not fired.
- If two dynamic administrators exist in a system you may have to regulate the system globally in order to resolve a creation race between them.
- The type of independent agent system studied by Kate Larson handles such problems locally

Most workers prefer employee status to consultant status.

Worker code

  Send( administrator, nil, workOrder );
  FOREVER {
    Send( administrator, workResult, workOrder );
    workResult = doWork( workOrder );
  }

doWork might require further sends to servers or warehouses, which is harmless in this context.

Administrator code

Initialization

Administrator( ) {
  for ( i = 0; i < NUM_WORKERS; i++ ) worker[i] = Create( mypriority - 1, workerCode );
    
  FOREVER {
    Receive( requester, request );
    switch( request.type ) {
    case CLIENT:
      enqueue( orderQ, {order = {client, request}} );
      if ( !empty( employeeQ ) ) Reply( dequeue( employeeQ ) ), dequeue( orderQ ) ); 
      break;
    case WORKER:
      enqueue( employeeQ, requester);
      if ( !empty( orderQ ) ) Reply( dequeue( employeeQ ), { dequeue( orderQ ) );
      if ( request != nil ) { Reply( request.client, request.request );
      break;
    }
}

Note: Tid of the client is included in the workorder to the administrator does not have to maintain and search a list of jobs being done. (Administrators are by nature lazy!)

Alternative Worker/Administrator Model

As above, Administrator includes Tid of the client in the order.
Worker replies to client with result and to administrator with request for another order to process.

Comments

The administrator can add a little more value.
- Suppose that there is data required for processing each order.
- The administrator could receive it from a notifier or courier.
- It would be maintained internally and added to the appropriate order before the order is despatched to the worker.
- Another model: the worker queries a detective.

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 (`one' defined in terms of the kernel events)
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, whom you employ directly.

Complex Events

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

form the combinations using Boolean operators
for example, Respond `okay' when this sensor is triggered or `time-out' when Delay returns.

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 even pretend to work!

Try instead, something like

FOREVER {
  Receive( *requester, request );
  switch ( request.type ) {
  case CLIENT:
    case = {requester, request.event, request.delay} );
    insert( caseDB, case );
    if ( !empty( delayQ ) && !empty( irregularQ ) ) {
      Reply( dequeue( delayQ ), case );
      Reply( dequeue( irregularQ ), case );
    }
  case DELAY:
    enqueue( delayQ, requester );
    if ( case = pending( caseDB, nil ) && !empty( irregularQ ) ) {
      Reply( dequeue( delayQ ), case );
      Reply( dequeue( irregularQ ), case );
    } 
    case = extract( caseDB, request.requester );
    if ( case != nil ) Reply( case.requester, TIME_OUT );
    break;
  case CLUE:
    enqueue( irregularQ, requester );
    if ( ( case = pending( caseDB, nil )!=nil && !empty( delayQ ) ) {
      Reply( dequeue( delayQ ), case );
      Reply( dequeue( irregularQ ), case );
    } 
    case = extract( caseDB, request.requester );
    if ( case != nil ) Reply( case.requester, EVENT );
    break;
  }
}

This is the code of a particular detective, one that notifies you which occurs first, a time-out or an event.

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: how to do them is shown above.

Who is the client of the detective

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

Return to: