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
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: