ProSim4: Process-based Simulation

Overview

What is ProSim4:

How to write ProSim4 programs:

Include the header file ProSim4.h (found in /home/cs558000/lib)
The header file contains variable definitions and function prototypes

Link with the libraries ProSim4 and OnAbort:

cc ...... -L /home/cs558000/lib -lProSim4 -lOnAbort -lm

Types of ProSim4 library functions:

ProSim4 internal management functions

InitProsim(): allocate memory for ProSim4 system variables
StartSimulate(): run the simulation
GetSimTime(): return the current simulation (virtual) clock value
GetMyArrivalTime(): return the simulation time at which the ProSim4 process was created (arrived)

Process creation/desctruction

Process scheduling

Hold(): stop the current co-routine and schedule an event time to resume the co-routine
Passivate(): stop the current co-routine.
Does not schedule any event time to resume the co-routine
(The co-routine must be resume by a ReActivate() call)
ReActivate(): schedule an event at the current time to resume a co-routine

Queue management

Enqueue(): enter the queue of a ProSim4 process
Dequeue(): remove the head element from the queue
MyQLength(): return the number of clients (ProSim4 processes) in my queue

Random number generation:

Uniformly distributed random numbers:

Expontially distributed random numbers (to simulute an arrival process)

Exponential(): Exponentially distributed random numbers with a given mean
RateExponential(): Exponentially distributed random numbers with a given (arrival) rate

Prosim processes and their process control blocks

Prosim processes (co-routines):

The Prosim system allows the user to create/destroy Prosim processes
Each Prosim process is a co-routine
(A co-routine are independent thread of execution, but unlike parallel threads, co-routines are run sequentially)
The ProSim4 simulation system maintains state information of a Prosim process in a Prosim Process Control Block record

(Partial) structure of the Prosim Process Control Block:

typedef struct PCB { char Name[12]; /* Name to id Prosim Entity (for debugging) */ long *Param; /* Parameter */ int State; /* State of the process can be: (PASSIVE, WAITING or ACTIVE) */ struct QElem *Queue; /* Queue of this Prosim entity */ double ArrivalTime; /* Time of arrival */ double EventTime; /* Next event time */ long Mem[MAXWSSIZE]; /* Stack space for process */ ..... } PCBType;

Notes:

The Name[] variable is used to identify a specify co-routine and is used for debugging purposes only.
The param variable can be used to pass information to the Prosim process in some Prosim function calls (e.g., in the function Generate())

State = the current state of the Prosim process

Meaning of the states:

ACTIVE: process is running (when Now == process resumption time) or has a fixed resumption event time.
The process will be resumed at its fixed resumption event time
PASSIVE: process is not running and it does not have a resumption time.
A PASSIVE process must be ReActivated by another Prosim process before it will resume execution
WAITING: process has a flexible resumption event time.
A WAITING process will resume execution at its scheduled resumption event time OR when it is ReActivated by another Prosim process before its resumption event time
(The WAITING state is used simulate Time Outs in network protocols)

Queue: contains a queue (linked list) of Prosim Process Control Blocks

Special feature in the Prosim simulation systems:

A Prosim process can be in the queue of another Prosim process
(This is used to simulate clients (Prosim processes) waiting in the queue of a server (also a Prosim processes)

Arrival time: the simulation time when the Prosim Process Control Black was created
In other words:
EventTime: contains the scheduled event time of the Prosim process when its state is equal to ACTIVE or WAITING
Mem[]: stack space to store local variables of the fuction

Initializing the ProSim4 system: InitProsim()

Syntax:

void InitProsim(unsigned int MaxNProcess, unsigned int MaxNQElems, unsigned int MaxNTimeHeap);
Parameters: MaxNProcess: Max # of Prosim process records MaxNQElems: Max # queue records MaxNTimeHeap: Max # processes in Events List

Effect:

Allocate the given number of system variables to run the simulation
You should set MaxNProcess to a value that is larger than the maximum number of clients in the system.
You should use MaxNQElems ≥ MaxNProcess and MaxNTimeHeap ≥ MaxNProcess

Example:

InitProsim( 1000, 1000, 1000 );

Creating a Prosim Process: Generate()

Syntax:

PCBType * Generate(char *name, void (*ProcName)(), void *param);
Parameters: name: (String) name of the process (usually not used) ProcName: function that is executed by the Prosim co-routine param: parameter passed to the co-routine Output: A pointer to the Prosim process record that store the context information of the co-routine

Effect:

Request one the Prosim process control block (record) and store the start address of the function ProcName in the Prosim process record
The Prosim process record is added to the Event list with the "event time = Now" (the co-routine will start as soon as possible)
You can optionally pass a parameter to the co-routine by means of the 3rd input parameter
Use 0 if you don't want to pass any parameter

Example:

/* -------------------------------------------------- Function that is executed by a Prosim co-routine -------------------------------------------------- */ void Proc1() { while (1) { Hold(1.2); printf("Proc1: Now = %lf\n", Now); } } int main(int argc, char **argv) { .... Generate("Name:Proc1", Proc1, 0); .... }

Terminating a Prosim co-routine: Terminate()
- Syntax:
- Effect:
- Example:

Simulating the servicing of clients: Hold()

Syntax:

Effect:

Schedule an event to resume the invoking Prosim process at time "Now" + time
The invoking Prosim process will not resume execution until simulation time = "Now" + time
Comment:

Example:

double serviceTime = ....; Hold( serviceTime ); // Sim. serving a client for given service time !

Waiting for servce to complete: Passivate()

Syntax:

void Passivate(0, 0);
Note: This function is more complex than what I explain here. I only describe the most commonly used form

Effect:

Stop the current Prosim co-routine from running
But does not schedule any resume event
The invoking process will remain inactive until another Prosim process ReActiavtes it.

Comment:

The Passivate(0,0) call is used by a client process to stop execution and wait for service at a server
When the service is completed, the server process must ReActivate the client process

Example:

Resuming a Passivated co-routine: ReActivate()

Syntax:

void ReActivate(PCBType *PCBPtr, 0, 0);
Parameter: PCBPtr: pointer to a Prosim process control block (record) Note: This function is more complex than what I explain here. I only describe the most commonly used form

Effect:

Schedule a resume event action for the process indicated by the Prosim process control block PCBPtr with event time = "Now"
(The corresponding Prosim co-routine will be resume as soon as possible)
Comment:

Example: typical server code

PCBType * client; .... Dequeue(HEAD, &client, 0, 0, 0); // Get next client from head of queue Hold( serviceTime ); // Serve client ReActivate( client, 0, 0 ); // Resume client (so it can do calculations...)

Queue management - insert: Enqueue()

Syntax:

void Enqueue(int pos, PCBType *ServerPCBPtr, 0, 0, 0);
Parameter: pos: must be equal to HEAD or TAIL ServerPCBPtr: pointer to a Prosim process control block
Note: This function is more complex than what I explain here. I only describe the most commonly used form

Effect:

Enqueue the Prosim process control block of the invoking process to the queue of the Prosim process ServerPCBPtr
Comment:

Example: how a client enters server's queue and obtain service

PCBType *Server; void Client() { .... Enqueue( HEAD, Server, 0, 0, 0 ); /* Enter server's queue */ ReActivate(Server, 0, 0); /* ReActivate the server */ Passivate(0, 0); /* Wait until server finishes serving me */ }

Queue management - delete: Dequeue()

Syntax:

void Dnqueue(int pos, PCBType **ClientPCBPtr, 0, 0, 0);
Parameter: pos: must be equal to HEAD or TAIL ClientPCBPtr: address of a pointer variable to a Prosim process control block (This is an output variable)
Note: This function is more complex than what I explain here. I only describe the most commonly used form

Effect:

Unlink the Prosim process control block from the given position (pos) from the queue of the current Prosim process
The unlinked Prosim process control block is returned in the variable ClientPCBPtr
Comment:

Example: how a server remove clients from its queue and provide service

void Server() { PCBType *Client; .... while (1) { if ( my queue is empty ) { Passivate(0, 0); } /* ---------------------------------------------- There is a client in my queue (Server MAY have been ReActivated by a client) ---------------------------------------------- */ Dequeue( HEAD, &Client, 0, 0, 0 ); /* Enter server's queue */ Hold(serviceTime); /* Provide service to client */ ReActivate(Server, 0, 0); /* ReActivate the server */ }

A Simple Prosim Simulation program

We will simulate the follow system:

Client generator process:

/* ------------------------------------------------------- Client generator process ------------------------------------------------------- */ void GeneratorProc() { while(1) { Hold( ARRIVAL_DELAY ); // Wait Inter-arrval time Generate("Cli", ClientProc, 0); // Create a client process... // The client process will do furthero processing for itself } }

The action of a client:

/* ------------------------------------------------------- Client() ------------------------------------------------------- */ void ClientProc() { /* ---------------------- Enter server's queue ---------------------- */ Enqueue(TAIL, Server, 0, 0, 0); /* ---------------------- ReActivate the server (it may be Passivated due to empty queue) ---------------------- */ ReActivate(Server, 0, 0); /* ------------------------------------------ Wait for server to complete serving me... ------------------------------------------ */ Passivate(0, 0); /* --------------------------------------- Print delay experienced by the client --------------------------------------- */ printf("Now = %lf: Client is done... my delay = %lf\n", GetSimTime(), GetSimTime() - GetMyArrivalTime() ); /* ------------------------------------------ De-allocate Prosim resources (PCB) ------------------------------------------ */ Terminate(); }

The server process:

/* ------------------------------------------------------- Server() ------------------------------------------------------- */ void ServerProc() { PCBType *Client; while (1) { if (MyQLength() == 0) { Passivate(0, 0); // Wait for a client to arrive } /* ----------------------------------------------------- We execution reaches/resumes here, we know there is a client in the server's queue ! ----------------------------------------------------- */ Dequeue(HEAD, &Client, NULL, NULL, NULL); // Get client at head of queue Hold( SERVICE_DELAY ); // "Service" the client (it only takes time :-)) ReActivate(Client, 0, 0); // Make client resume (further processing)... } }

The main program (set up simulation):

int main(int argc, char **argv) { double SimLength; .... /* ----------------------------------------- Allocate space for 1000 Prosim processes ----------------------------------------- */ InitProsim(1000, 1000, 1000); /* ----------------------------------------- Create the "client generator" process (now you have 999 PCB's left) ----------------------------------------- */ Generator = Generate("Gen", GeneratorProc, 0); /* ----------------------------------------- Create one "server" process (now you have 998 PCB's left) ----------------------------------------- */ Server = Generate("Serv", ServerProc, 0); /* ---------------------------------------------- Run simulation for "SimLength" virtual seconds ---------------------------------------------- */ StartSimulate(SimLength); printf("Done.\n"); }

Example Program: (Demo above code)

Prog file: click here

Compile with:

cc -g -O -o main2 -I /home/cs558000/lib main2.c \ -L /home/cs558000/lib -lProSim4 -lOnAbort -lm

Simulating random behavious: random number generators

UNIX's uniformly distributed random numbers generator:

#include <stdlib.h> void srandom(unsigned int seed); /* Set the seed for the RN generator */ long random(); /* Get a random number between (0 .. 2^31-1) */

Prosim's uniformly distributed random numbers generator:

long I_Uniform(int a, int b, int stream); /* Integer Unif[a..b] */ double D_Uniform(double a, double b, int stream); /* Unif[a..b] */

Note:

There are 10 independent random generators (streams) in Prosim
The value for stream must be between [0..9]

Simulating Poisson arrivals:

Recall that the time between 2 consecutive arrivals in a Poisson arrival process has the exponential distribution (see: click here )
Therefore, to simulate a Poisson arrival process, we need to generate random number r₁, r₂, r₃, .... that have an exponential distribution:
Note:

The exponential distributed number generator in Prosim:

double RateExponential(double lambda, int stream); /* Exponential dist with rate */

An M/M/1 queue Simulation program

We will now write a Prosim simulation for the M/M/1 queue

Client generator process:

/* ------------------------------------------------------- Client generator process ------------------------------------------------------- */ void GeneratorProc() { while(1) { /* -------------------------------- Wait an expon. dist. random time -------------------------------- */ Hold( RateExponential(ARRIVALRATE, 0) ); // ***** Inter-arrval time is expon. distr. !!! Generate("Cli", ClientProc, 0); // Create a client process... // The client process will do further processing for itself } }

The action of a client: no change !!!

The server process:

/* ------------------------------------------------------- Server() ------------------------------------------------------- */ void ServerProc() { PCBType *Client; while (1) { if (MyQLength() == 0) { Passivate(0, 0); // Wait for a client to arrive } /* ----------------------------------------------------- We execution reaches/resumes here, we know there is a client in the server's queue ! ----------------------------------------------------- */ Dequeue(HEAD, &Client, NULL, NULL, NULL); // Get client at head of queue Hold( RateExponential(SERVICERATE, 1) ); // ***** Expon. distr. departure rate ! ReActivate(Client, 0, 0); // Make client resume (further processing)... } }

The main program (set up simulation): no changes !

Example Program: (Demo above code)

Prog file: click here

Compile with:

cc -g -O -o main3 -I /home/cs558000/lib main3.c \ -L /home/cs558000/lib -lProSim4 -lOnAbort -lm