CS452 - Real-Time Programming - Winter 2015

Lecture 10 - Name Server

Public Service Annoucements

  1. Due date for kernel 2: 30 January, 2015
  2. Updated k2.pdf

Inter-task Communication


What is a server?

How are servers implemented?

We usually try to make each service simple, so the code of the server that provides it is simple.

A typical server has a lot in common with a warehouse

       Receive( *tid, request );
       switch( request.type )
       case PRODUCER:
	  if ( consumer-queued )
	     Reply ( dequeue( consumer ), request.content );
	     Reply ( producer );
	  if ( space-available ) 
	     store( request.content );
	     Reply( producer );
	  queue( producer );
       case CONSUMER:
	  if ( producer-queued )
	     Reply ( consumer, content );
	     Reply ( dequeue( producer) )
	  if ( content-available )
	     Reply( consumer, content );
	  queue( consumer );

Name Server

What is a name server?

Why Do We Need a Name Server

Names constant across applications
& executions
interface Associated with a set of services (an API)
Task Ids vary across applications
& executions
implementation Associated with particular code
and data (an execution)

How do You Get the Task Id of the Name Server?

Remember what you did when you were installing Linux?

  1. Make it a constant across executions.
  2. Is there any other way that's not disgusting.

Name Server API

int RegisterAs( char *name );
int WhoIs( char *name );

Name Server Semantics




Analogy to Name Service on the Internet

Name Server Implementation

What does the client need to know in order to use the name server

  1. its taskid
  2. the requests it services
  3. its API: function signatures and type definitions

User Pseudo-Code

First we need a struct for requests and reponses.

    struct NSmsg {
		  char name[MAXNAMESIZE];
		  int tid;
Using this struct send to the name server looks something like
    Send( NSTid, (NSmsg *) msg, sizeof( NSmsg ), (NSmsg *) msg, sizeof ( NSmsg ) );

Name Server

  1. One service associates a taskid with a name
  2. The second service looks up the taskid and replys it to the requestor


  1. How much will this code run?
  2. What should happen when a WhoIs request is made for an unregistered name?
  3. How would you implement insert & lookup?
  4. What should be allowable as a name?

Hardware Interrupts

What is a Hardware Interrupt?

In the CPU

  1. Test interrupt signal before fetching the next instruction
  2. If asserted, change mode to IRQ
  3. Disable interrupt in CPSR
  4. Execute instruction at 0x18

In the Interrupt Control Unit (ICU)

In the Peripheral Hardware

When two interrupts are present

May have been two present when interrupt processing started

May have occurred since interrupt processing started

What happens next?

  1. Kernel executes with interrupts disabled
  2. Context switch into user task turns on interrupts
  3. Before fetching the first user task instruction test interrupt signal
  4. If asserted, re-initiate interrupt processing

Context Switches for Interrupts

Difference from Software Interrupts

It is impossible to predict where they occur

Assymmetry between User Task and Kernel

Scratch Registers must be saved

Two Link Registers

  1. One to return from interrupt
  2. One to move to the caller's stack frame

Helpful Features of the ICU

  1. Several places where you can read state
  2. Several places where you can block interrupt flow
  3. Trigger hardware interrupt from software

The Hardware in the Trains Lab

32-bit Timer

Base address: 0x80810080

Three registers:

Offset Function R/W Bits Comments
0x0 Timer3Load R/W 32: <Load/Reload Value>
0x4 Timer3Value R 32:<Current value> Set when Load is written,
even when counting
0x8 Timer3Control R/W 3:xxx<CLKSEL>xx<MODE><ENABLE> <CLKSEL>: 0, 2KHz clock; 1, 508KHz
<MODE>: 1, count continuously; 0, count once
<ENABLE>: Clock turned on
0xc Timer3Clear W 32: Writing anything clears the interrupt

Interrupt Control Unit (ICU)

The actual device is the ARM PL190

The logic in this design is completely asynchronous, so it functions when the CPU clock is turned off.

All input signals are

Base addresses

Basic Operation

VIC powers up with



  1. leave protection off
  2. enable in VICxIntEnable when you are ready to handle the interrupt

On an interrupt

  1. Read VICxIRQStatus
  2. Choose which interrupt you wish to handle
  3. Clear the interrupt source in the device

For debugging

  1. Use VICxSoftInt and VICxSoftIntClear to turn interrupt sources off and on in software

Hardware Definitions

Registers for Basic Operation
Register Name Offset R/W Description
VICxIRQStatus 0x00 RO One bit for each interrupt source

1 if interrupt is asserted and enabled

VICxFIQStatus 0x04 RO As above for FIQ
VICxRawIntr 0x08 RO As above but not masked
VICxIntSelect 0x0c R/W 0: IRQ, 1: FIQ
VICxIntEnable 0x10 R/W 0: Masked, 1: Enabled
VICxIntEnClear 0x14 WO Clears bits in VICxIntEnable
VICxSoftInt 0x18 R/W Asserts interrupt from software
VICxSoftIntClear 0x1c WO Clears interrupt from software
VICxProtection 0x20 R/W Bit 0 enables protection from user mode access
VICxVectAddr 0x30 R/W Enables priority hardware

See documentation.

Helpful Features of the ICU

  1. Several places where you can read state
  2. Several places where you can block interrupt flow
  3. Trigger hardware interrupt from softwareonce
    1. What makes interrupts hard is that you are doing two semi-hard things at once
      • Making the hardware produce the interrupt
      • Responding to the interrupt
    2. Software interrupt generation allows you to separate them in developing/debugging

Non-vectored Operation


  1. Enable interrupt in device
  2. Enable interrupt in ICU
  3. Enable interrupt in CPU, usually by MOVS

Interrupt occurs

  1. AND of IRQ and NOT( IRQ disabled bit in CPSR ) is checked before each instruction fetch.
  2. If set IRQ exception is taken in place of next instruction fetch.
  3. Context switch into kernel

    Context switch novelties

    Difference from Software Interrupts

  4. Turn off interrupt in device

You are now ready to process the interrupt in the kernel

Return to: