Node Process Control Block (PCB) and local variables

PCB structure

Each node has some standard local information included in a C structure called PCB. Node i can refer to its PCB as PCB[i] in a protocol. The format of the PCB is presented below.

    typedef  struct  {
           int      state ; (*)
           int      id ; (*)
           int      adjacents; (*)
           PORT     *adjust ;
           int      step_dur [3] ;
           MESSAGE  *mes_buf ;
           TIMER    clock[5] ;
           int      loc_clock ;
           double   dr_loc_clock ;
           int      wake_time ;
           int      sy_init_time ;
           int      dpq ;
           double   dr_dpq ;
           int      step ;
           int      cycle ;
           int      idle ;
           int      init_time ;
    }  PCBS ;

• state: Process current state.
• id: Process current identity number.
• adjacents: The number of adjacent nodes.
• adjust: An array of adjacents ports, each dedicated to one of the adjacent nodes. The structure of each PORT is

  
                 typedef struct {
                        int   id;
                        int   delays [3] ;
                        int   state;
                        int   weight;
                 }  PORT ;
  

  • id: The number of the corresponding adjacent node.
  • delays: The delay (timing) parameters of the corresponding link (e.g. lower and upper bounds and expected message transmission delay over the link; these values are used by a random number generator which generates values according to some probablility distribution that can be specified by the user in a network description file).
  • state: The current state of the corresponding link as this node means it.
  • weight: The imposed weight of the link. All weights are initialized by the simulator in such a way as to have unique values. User may reinitialize weights in routine init().
• step_dur: Step duration (timing) parameters (e.g. lower and upper bounds and expected duration of the node's step; these values are used by a random number generator which generates values according to some probablility distribution that can be specified by the user in a network description file).
• mes_buf: The queue of messages that arrived by have not been received yet.
• clock[]: An array of timers that can be used for generation of interrupts (timeouts).
• loc_clock: The local clock of the node.
• dr_loc_clock: A drifting local clock of the node.
• wake_time: This field keeps the time that the node's local clock started to count.
• sy_init_time: Keeps the time that the node is going to wake up during the sychronizer's initialization phase.
• dpq: The difference between the wake_times of two nodes p,q.
• dr_dpq: The difference between the wake_times of two nodes p,q when a synchronizer with drifting local clocks is simulated.
• step: Current step.
• cycle: Keeps the cycle of the local clock of the node.
• idle: Till when this node is idle.
• init_time: The time that a node is going to wake up.

Local Variables

Each node may contain some protocol-defined local variables. These variables must be given by the user, in the action file (cf. section on protocol creation), as a C structure e.g.

          typedef struct {
                int parent ;
                LIST ack ;
                .......
          } REGISTERS ;

          REGISTERS *REG ;

Each node i can then refer to its local variable parent as REG[i].parent

These local variables may be initialized in a procedure init() and must be allocated enough memory for them in a procedure reg_alloc() (these should be taken care of in the action file, at the creation of the protocol; cf. section on protocol creation) e.g.

          reg_alloc()
          {
              REG = (REGISTERS *)malloc (processes * sizeof (REGISTERS));
          }

Global Variables and Structures

There are also some read-only globle variables most of which are regularly used by the user.

• PARAM[]: Array of parameters a protocol may use.
• TIME: Global clock. If this variable must be used in a protocol, it is preferable to use get_time(), that returns the current value of TIME, in order to avoid errors.
• me: Current process (node); i.e the process for which the simulator is currently simulating a step. (*)
• CURMESS: Current received message if any. (*)
• new_state: The new state of the process that currently makes a step (i.e. the process for which the simulator is currently simulating). (*)
• processes: Number of processes (nodes). (*)
• rmin, rmax, dmin, dmax: The minimum and maximum values for step and link delay respectively. These variables are mainly used in Archimedean protocols (see Section 4.3.1).

Moreover, there are also available routines in LYDIAN which are useful for the user (see Section 7.2

Now, we have enough information to implement the protocol of the Broadcast with ACK algorithm.