CS452 - Real-Time Programming - Fall 2008

Lecture 17 - Serial Hardware

Questions & Comment

1. out 2

Task Structure

Server Notifier Buffer Courier

1. Simplest

1. Notifier
   • Initialize

     // Initialize Hardware
     Receive( serverPid );// Find server Pid
                         // could be parentPid
     Reply( );           // Should be last thing FOREVER
             

   • Work

     FOREVER {
       AwaitEvent( eventid );  //Should event ids be hard coded?
       // Acquire volatile data
       // Enable interrupts
       Send( serverPid, .... )
     }
             

2. Server
   • Initialize

     notifierPid = Create( notifier );                //Should notifier code name be hard coded?
     Send( notifierPid, { MyPid( ), eventId }, ... ); //On return notifier is okay
     RegisterAs( );                                   //On return requests can begin.
             

   • Work

     FOREVER {
       requesterPid = Receive( request );
       switch ( request.type ) {
       case NOTIFIER:
         provideNotifierService( ); // may release queued clients
         doQueuedReplies( );
         Reply( requester );
       case CLIENT:
         if ( provideClientService( ) ) Reply( requesterPid );
         else enQueue( requesterPid );
       }
     }
             

Remember that all the calls provide error returns. You can/should use them for error recovery

• static error recovery: debugging
• dynamic error recovery: at run time

2 Using a Courier

Simplest is best

1. Notifier
   • Initialize

     // Initialize Hardware
     Receive( requester, eventId );
     Reply( requester );            // Should be the last thing before FOREVER
         

   • Work

     FOREVER {
       AwaitEvent( eventid );       //Should event ids be hard coded?
       // Acquire volatile data
       // Enable interrupts
       Receive( .... )
     }
      

2. Courier
   • Initialize

     Receive( requester, { notifierId, serverId } ); // Now knows the the server/notifier Pids
     Reply( requester );                             // Should be the last thing before FOREVER
             

   • Work

     FOREVER {
           Send( notifierPid ... );
           Send( serverPid ... );
         }

3. Server
   • Initialize

     notifierPid = Create( notifier );                 //Should notifier code name be hard coded?
     courierPid = Create( courier );
     Send( courierPid, { notifierPid, MyPid( ) } ... ) // On return courier is okay
     Send( notifierPid, eventId, ... );                 //On return notifier is okay
     RegisterAs( ); //On return requests can begin.
             

   • Work

     FOREVER {
       requesterPid = Receive( request );
       switch ( request.type ) {
       case COURIER:
         provideCourierService( ); // may release queued clients
         doReplies( );
       case CLIENT:
         if ( provideClientService( ) ) Reply( requesterPid );
         else enQueue( requesterPid );
       }
     }
         

This gets you through a bottleneck where no more than two events come too fast.

Remember that all the calls provide error returns. You can/should use them for error recovery

• static error recovery: debugging
• dynamic error recovery: at run time

3. Buffering

Add buffer before courier and server.

1. Notifier
   • Initialize

     // Initialize Hardware
     Receive( bufferPid )// Find server Pid
     Reply( ) // Should be the last thing before FOREVER
             

   • Work

     FOREVER {
       AwaitEvent( eventid );  //Should event ids be hard coded?
       // Acquire volatile data
       // Enable interrupts
       Send( bufferPid, .... )
     }
             

2. Buffer
   • Initialize

   • Work

     FOREVER {
       Receive( requesterPid, request );
       switch ( request.type ) {
       case COURIER:
         enQueue( queue, request.data );
         Reply( );
       case SERVER:
         Reply( queue );
       }
     }
             

3. Courier
   • Initialize

     Receive( requester, ..., bufferPid, ); // Now knows the the server/buffer Pids
     Reply( requester, ... );               // Should be the last thing before FOREVER
             

   • Work

     FOREVER {
       Send( bufferPid ... );
       Send( serverPid ... );
     }
             

4. Server
   • Initialize

     notifierPid = Create( notifier ); //Should notifier code name be hard coded?
     courierPid = Create( courier );
     bufferPid = Create( buffer );
     Send( courierPid, { myPid, bufferPid } ... ); // On return courier is okay
     Send( notifierPid, { bufferPid }, ... ); //On return notifier is okay
     RegisterAs( ); //On return requests can begin.
             

   • Work

     FOREVER {
       requesterPid = Receive( request );
       switch ( request.type ) {
       case COURIER:
         provideCourierService( ); // may release queued clients
         Reply( requesterPid );
         doReplies( );
       case CLIENT:
         if ( provideClientService( ) ) Reply( requesterPid );
         else enQueue( requesterPid );
       }
     }
         

This structure clears up problems when the notifier runs too fast for the server.

Two issues:

1. Handles bottlenecks of all sizes.

   Define `bottleneck'.

2. Server could be buffered on the other side

   Called a guard.

What this amounts to is

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

Administrator, Worker

Return to:

• Bill Cowan's Fall 2008 CS452 page
• Bill Cowan's CS452 page
• Bill Cowan's teaching page
• Bill Cowan's home page