Trailing-Edge
-
PDP-10 Archives
-
decuslib20-03
-
decus/20-0078/util/gpssst.ibm
There is 1 other file named gpssst.ibm in the archive. Click here to see a list.
ZQ
//JBGPSSS JOB (XAO875,JB142M332,1,3),'J BOSE',
// MSGLEVEL=(2,1) ,CLASS=S,TIME=(0,15)
/*SD L#GGS I PROJEKT 13-FACKET
//SIMULA EXEC SIMCLG,REGION=208K
//SIM.SYSIN DD *
%NORESWD
COMMENT (/E/L);
SIMULATION CLASS GPSSST(MAX_QUEUES,MAX_STATIONS,MAX_STORAGES,
UNIT,SECDEC);
CHARACTER UNIT;
INTEGER MAX_QUEUES,MAX_STATIONS,MAX_STORAGES,SECDEC;
COMMENT NOT HIDDEN PROTECTED OBJECT_TRACE_ON,NOREPORT,
TRANSID,SET_STORAGE,RESTART,GPSSS_TIME,CONTENTS_STATION,
STATION,BOX,FILE,SECDEC,UNIT,STANDARD_REPORT,U,TRANSACTION,WAIT_UNTIL,
TIME_SPENT_ONLY,SKIP,TRACE_ON,BEGIN_TIME,HOLD_UNTIL_READY,TRACE_OBJECT,
CONTENTS_STORAGE,CONTENTS_QUEUE,WAITING_STATION,WAITING_STORAGE,
OUTTIME,TRANS_NAME,QUEUE_NAME,STATION_NAME,STORAGE_NAME,WAITING_QUEUE,
BBEGIN_TIME;
COMMENT NOT HIDDEN PROCESS,CURRENT,TIME,HOLD,PASSIVATE,WAIT,
CANCEL,ACCUM,MAIN,LINKAGE,LINK,HEAD;
BEGIN
COMMENT **************************************************
MONTREAL GPSSS PACKAGE + VERSION 4.1 +
WRITTEN - FEBRUARY 1972
UPDATED - SEPTEMBER 1974
AUTHOR - JEAN G. VAUCHER
PROFESSEUR AGREGE
DEPARTEMENT D INFORMATIQUE
UNIVERSITE DE MONTREAL
C.P. 6128 , MONTREAL 101
CANADA
CONVERTED TO DECSYSTEM 10 - JUNE 1976
BY H-JOACHIM BOSE
**********************************************************;
REF (FACILITY) ARRAY STATION (1:MAX_STATIONS );
REF (STORAGE ) ARRAY BOX (1:MAX_STORAGES);
REF (Q ) ARRAY FILE (1:MAX_QUEUES) ;
TEXT ARRAY QUEUE_NNAME(1:MAX_QUEUES);
TEXT ARRAY STATION_NNAME(1:MAX_STATIONS);
TEXT ARRAY STORAGE_NNAME(1:MAX_STORAGES);
TEXT TRANS_NNAME,FIELD;
REAL BBEGIN_TIME ;
INTEGER MAXLENGTH,LLENGTH;
BOOLEAN TRACE_ON,OBJECT_TRACE_ON,NOREPORT,TIME_SPENT_ONLY;
REF(HEAD)FINISHED_OBJECTS;
COMMENT **********************************************************
OCCURRENCE_STAT. DEFINITION. LINK TO OCCURENCES,ATTRIBUT TO TRANS.
******************************************************************;
LINK CLASS
OCCURRENCE_STATISTICS(OCCURRENCE_NUMBER,RESOURCE_NUMBER,
OCCURRENCE_TIME);
INTEGER OCCURRENCE_NUMBER,RESOURCE_NUMBER;
REAL OCCURRENCE_TIME; ;
INTEGER TRANSID ;
INTEGER NSTAT, NSTOR, NQUE, PASSE ;
BOOLEAN OUTOFORDER ;
COMMENT *******************************************************
QUEUE_NAME DEFINITION
***************************************************************;
PROCEDURE QUEUE_NAME(I,NEW_NAME);
VALUE NEW_NAME;
INTEGER I;
TEXT NEW_NAME;
BEGIN
CHECK_LIMITS(I,1); IF OUTOFORDER THEN GOTO OUT;
IF NEW_NAME.LENGTH>MAXLENGTH THEN MAXLENGTH:=NEW_NAME.LENGTH;
QUEUE_NNAME(I):-NEW_NAME;
OUT: OUTOFORDER := FALSE
END;
COMMENT *******************************************************
STATION_NAME DEFINITION
***************************************************************;
PROCEDURE STATION_NAME(I,NEW_NAME);
VALUE NEW_NAME;
INTEGER I;
TEXT NEW_NAME;
BEGIN
CHECK_LIMITS(I,2); IF OUTOFORDER THEN GOTO OUT;
IF NEW_NAME.LENGTH>MAXLENGTH THEN MAXLENGTH:=NEW_NAME.LENGTH;
STATION_NNAME(I):-NEW_NAME;
OUT: OUTOFORDER := FALSE
END;
COMMENT *******************************************************
STORAGE_NAME DEFINITION
***************************************************************;
PROCEDURE STORAGE_NAME(I,NEW_NAME);
VALUE NEW_NAME;
INTEGER I;
TEXT NEW_NAME;
BEGIN
CHECK_LIMITS(I,3); IF OUTOFORDER THEN GOTO OUT ;
IF NEW_NAME.LENGTH>MAXLENGTH THEN MAXLENGTH:=NEW_NAME.LENGTH;
STORAGE_NNAME(I):-NEW_NAME;
OUT: OUTOFORDER := FALSE
END;
COMMENT ***************************************
OUTOFORDER DEFINITION
***********************************************;
BOOLEAN PROCEDURE CHECK_LIMITS(NR,FAC);
INTEGER NR,FAC;
BEGIN
SWITCH MSG:=Q,STA,STO;
GOTO MSG(FAC);
Q: IF NR<1 OR NR>MAX_QUEUES THEN BEGIN
ERREUR(10);
OUTOFORDER :=TRUE;END; GOTO OUT;
STA:IF NR<1 OR NR>MAX_STATIONS THEN BEGIN
ERREUR(11);
OUTOFORDER :=TRUE;END; GOTO OUT;
STO:IF NR<1 OR NR>MAX_STORAGES THEN BEGIN
ERREUR(12);
OUTOFORDER :=TRUE; END;
OUT: ERLOC:=NR;
END OF OUTOFORDER ;
INTEGER TLENGTH;
COMMENT ***************************************************
TRANS_NAME DEFINITION
***********************************************************;
PROCEDURE TRANS_NAME(TRNAME);
VALUE TRNAME;
TEXT TRNAME;
BEGIN
TRANS_NNAME:- TRNAME;
TLENGTH:=TRNAME.LENGTH;
END OF TRANS_NAME ;
COMMENT **************************************************
BEGIN_TIME DEFINITION
**********************************************************;
REAL PROCEDURE BEGIN_TIME(TIME);
REAL TIME;
BEGIN
BBEGIN_TIME:=60*ENTIER(TIME)+100*(
TIME-ENTIER(TIME));
BEGIN_TIME:=BBEGIN_TIME ;
END ;
COMMENT **************************************************
TRACE_OBJECT DEFINITION
**********************************************************;
PROCEDURE TRACE_OBJECTS;
IF OBJECT_TRACE_ON THEN BEGIN
INTEGER TT;
BOOLEAN NOTFIRST;
FIELD:-IMAGE.SUB(MAXLENGTH+18,LLENGTH);
IF NOT FINISHED_OBJECT.EMPTY THEN BEGIN
IF LINE>4 THEN SKIP(100);
OUTTEXT(" THE TRANSACTIONS LEAVING THE SYSTEM ARE");
SKIP(0);
OUTTEXT(" =======================================");
TRACE_QUEUE(FINISHED_OBJECTS);
END;
FOR TT:=1 STEP 1 UNTIL MAX_STORAGES DO
IF BOX(TT)=/=NONE THEN BEGIN
IF NOT BOX(TT).INQ.EMPTY THEN BEGIN
IF NOT NOTFIRST THEN BEGIN
HEADER(1);
NOTFIRST:=TRUE;
END;
OUTTEXT(" /");
FACILITY_NAME_OUT(3,TT);
OUTTEXT("/");
TRACE_QUEUE(BOX(TT).INQ);
END;
END;
NOTFIRST:=FALSE;
FOR TT:=1 STEP 1 UNTIL MAX_STATIONS DO
IF STATION(TT)=/= NONE THEN BEGIN
IF NOT STATION(TT).INQ.EMPTY THEN BEGIN
IF NOT NOTFIRST THEN BEGIN
HEADER(2);
NOTFIRST:=TRUE;
END;
OUTTEXT(" /");
FACILITY_NAME_OUT(2,TT);
OUTTEXT("/");
TRACE_QUEUE(STATION(TT).INQ);
END;
END;
IF NOT WAITQ.EMPTY THEN BEGIN
IF LINE > 4 THEN SKIP(100) ELSE SKIP(4);
OUTTEXT("THE TRANSACTIONS STUCKED IN WAITQUEUE ARE");
SKIP(0);
OUTTEXT("=========================================");
SKIP(0);
OUTTEXT("( PASSIVATED IN THE PROCEDURE WAIT_UNTIL )");
SKIP(1);
TRACE_QUEUE(WAITQ);
END;
END ELSE BEGIN
SKIP(0);OUTTEXT(
"YOU HAVE TO SET OBJECT_TRACE_ON := TRUE ");
SKIP(0);OUTTEXT(" IF YOU WANT TO USE TRACE_OBJECTS ");
SKIP(10);
END OF TRACE_OBJECT ;
COMMENT *******************************************
TRACE_QUEUE DEFINITION
***************************************************;
PROCEDURE TRACE_QUEUE (Q_REF);
REF(HEAD) Q_REF;
BEGIN
REF(TRANSACTION) CURRENT_TRANSACTION;
REF(OCCURRENCE_STATISTICS) CURRENT_OCCURRENCE;
INTEGER TT;
CURRENT_TRANSACTION:-Q_REF.FIRST;
WHILE CURRENT_TRANSACTION=/=NONE DO
INSPECT CURRENT_TRANSACTION DO BEGIN
IF NOT TIME_SPENT_ONLY THEN BEGIN
IF LINE+1.5*OCCURRENCES.CARDINAL+10>54 THEN
SKIP(100) ELSE SKIP(2);
END ELSE IF LINE + OCCURRENCES.CARDINAL/2
+ 4 > 54 THEN SKIP(100) ELSE SKIP(2);
SETPOS(8);
TRANS_NAME_OUT(ID);
SKIP(0);
SETPOS(8);
IF TRANS_NNAME==NOTEXT THEN
OUTTEXT("----------") ELSE
BEGIN
FOR TT:=1 STEP 1 UNTIL TLENGTH DO
OUTTEXT("-");
OUTTEXT("----");
END;
SKIP(2);
IF NOT TIME_SPENT_ONLY THEN PRINT_OUT(OCCURRENCES);
SKIP(1);
COMPARE(CURRENT_TRANSACTION);
CURRENT_TRANSACTION:-SUC;
END INSPECT TRANSACTION ;
END OF PROC. TRACE_QUEUE ;
COMMENT ****************************************************
HEADER DEFINITION
************************************************************;
PROCEDURE HEADER(NR);
INTEGER NR;
BEGIN SKIP(100);
OUTTEXT("THE TRANSACTIONS WAITING TO ENTER ");
IF NR=1 THEN OUTTEXT("STORAGE ") ELSE
OUTTEXT("STATION "); OUTTEXT("ARE :");
SKIP(0);
OUTTEXT("===============================================");
SKIP(1);
END;
COMMENT **************************************************
PRINT_OUT DEFINITION
**********************************************************;
PROCEDURE PRINT_OUT (TRANSOCCURRENCE);
REF(HEAD) TRANSOCCURRENCE ;
BEGIN
REF(OCCURRENCE_STATISTICS) Z ;
Z:- TRANSOCCURRENCE.FIRST;
WHILE Z =/= NONE DO
INSPECT Z DO BEGIN
IF OCCURRENCE_NUMBER>0 THEN
OUTTEXT("ENTERED ") ELSE
OUTTEXT("LEAVED ");
FACILITY_NAME_OUT(ABS(OCCURRENCE_NUMBER),RESOURCE_NUMBER);
SETPOS(11+MAXLENGTH);
OUTTEXT("AT TIME ");
PUTTIME(OCCURRENCE_TIME+BBEGIN_TIME);
SKIP(0);
Z:-Z.SUC;
END;
END PROC. PRINT_OUT;
COMMENT *****************************************************
COMPARE DEFINITION
*************************************************************;
PROCEDURE COMPARE(TRANSOCCURRENCE);
REF(TRANSACTION) TRANSOCCURRENCE;
INSPECT TRANSOCCURRENCE DO BEGIN
REF(OCCURRENCE_STATISTICS)X,Y;
X:-OCCURRENCES.FIRST;
WHILE X=/= NONE DO BEGIN
Y:-X.SUC;
WHILE Y=/= NONE DO BEGIN
IF X.RESOURCE_NUMBER=
Y.RESOURCE_NUMBER AND
X.OCCURRENCE_NUMBER=
-(Y.OCCURRENCE_NUMBER) THEN BEGIN
WTIME_SPENT_OUT(X,Y);
Y.OUT;
GOTO NEXT_X;
END;
Y:-Y.SUC;
END;
NEXT_X:
X:-X.SUC;
END;
END COMPARE ;
COMMENT *********************************************
WTIME_SPENT_OUT DEFINITION
*****************************************************;
PROCEDURE WTIME_SPENT_OUT(OCCUR1,OCCUR2);
REF(OCCURRENCE_STATISTICS) OCCUR1,OCCUR2;
BEGIN
OUTTEXT("TIME SPENT IN ");
INSPECT OCCUR1 DO
FACILITY_NAME_OUT(OCCURRENCE_NUMBER,RESOURCE_NUMBER);
SETPOS(17+MAXLENGTH);
OUTTEXT(":");
PUTTIME(OCCUR2.OCCURRENCE_TIME-
OCCUR1.OCCURRENCE_TIME);
SKIP(0);
END WTIME_SPENT_OUT;
COMMENT ***********************************************
TRANS_NAME_OUT DEFINITION
*******************************************************;
PROCEDURE TRANS_NAME_OUT(NR);
INTEGER NR;
BEGIN
IF TRANS_NNAME==NOTEXT THEN OUTTEXT("OBJECT") ELSE
OUTTEXT(TRANS_NNAME);
OUTINT(NR,4);
SETPOS(POS+2);
END OF TRANS_NNAME ;
COMMENT *********************************************
FACILITY_NAME_OUT DEFINITION
*****************************************************;
PROCEDURE FACILITY_NAME_OUT(NUMBER,RESOURCE);
INTEGER NUMBER,RESOURCE;
BEGIN
SWITCH MSG:=Q,STA,STO;
GOTO MSG(ABS(NUMBER));
Q:
IF QUEUE_NNAME(RESOURCE)==NOTEXT THEN BEGIN
OUTTEXT(" QUEUE ");
OUTINT(RESOURCE,4);
END ELSE
OUTTEXT(QUEUE_NNAME(RESOURCE));
GOTO OUT;
STA:
IF STATION_NNAME(RESOURCE)==NOTEXT THEN BEGIN
OUTTEXT(" STATION");
OUTINT(RESOURCE,4);
END ELSE
OUTTEXT( STATION_NNAME(RESOURCE));
GOTO OUT;
STO:
IF STORAGE_NNAME(RESOURCE)==NOTEXT THEN BEGIN
OUTTEXT(" STORAGE");
OUTINT(RESOURCE,4);
END ELSE
OUTTEXT(STORAGE_NNAME(RESOURCE));
OUT:
END OF FAC_NAME_OUT;
COMMENT ***********************************************
PUTTIME DEFINITION
*******************************************************;
TEXT PROCEDURE PUTTIME(TIME);
REAL TIME;
IF FIELD.LENGTH >=
(IF SECDEC < 0 THEN 12 ELSE IF SECDEC = 0 THEN 15 ELSE SECDEC+16)
THEN
BEGIN INTEGER DAYS,HOURS,M,POWERSEC; REAL SECONDS;
PROCEDURE FIXEDIT(X,W); REAL X; INTEGER W;
BEGIN
FIELD.SUB(FIELD.POS,W).PUTFIX(
X,IF SECDEC>=0 THEN SECDEC ELSE 0);
FIELD.SETPOS(FIELD.POS+W);
END OF FIXEDIT;
PROCEDURE INTEDIT(I,W); INTEGER I,W;
BEGIN
FIELD.SUB(FIELD.POS,W).PUTINT(I);
IF FIELD.GETCHAR = ' ' THEN
BEGIN FIELD.SETPOS(FIELD.POS-1);
FIELD.PUTCHAR('0');
END;
FIELD.SETPOS(FIELD.POS-1+W);
END OF INTEDIT;
BOOLEAN PROCEDURE ADJUSTED;
BEGIN
IF M = 60 THEN
BEGIN ADJUSTED:= TRUE;
HOURS:= HOURS + 1; M:= 0;
IF HOURS = 24 THEN
BEGIN DAYS:= DAYS + 1; HOURS:= 0 END
END;
FIELD.SUB(2,6):= " D ";
FIELD.SETPOS(5);
IF DAYS < 1 THEN
FIELD.PUTCHAR(' ') ELSE
IF DAYS < 10 THEN
BEGIN
FIELD.SETPOS(4);
FIELD.PUTCHAR(CHAR(DAYS+RANK('0')));
END ELSE
IF DAYS < 100 THEN
BEGIN FIELD.SETPOS(3); INTEDIT(DAYS,2) END ELSE
IF DAYS < 1000 THEN
BEGIN FIELD.SETPOS(2); INTEDIT(DAYS,3) END ELSE
FIELD.SUB(2,3):= "***";
FIELD.SETPOS(8);
INTEDIT(HOURS,2); FIELD.PUTCHAR(':');
END OF ADJUST;
POWERSEC:= 1;
FOR M:= 1 STEP 1 UNTIL SECDEC DO POWERSEC:= POWERSEC*10;
IF UNIT = 'D' OR UNIT = 'D' THEN TIME:= 1440*TIME ELSE
IF UNIT = 'H' OR UNIT = 'H' THEN TIME:= 60*TIME ELSE
IF UNIT = 'S' OR UNIT = 'S' THEN TIME:= TIME/60;
FIELD.SETPOS(1);
FIELD.PUTCHAR(IF TIME < 0 THEN '-' ELSE ' ');
TIME:= ABS(TIME);
IF TIME > 2 147 483 647 THEN GO TO ERROR;
M:= ENTIER(TIME);
SECONDS:= 60*(TIME - M);
HOURS:= M//60;
M:= MOD(M,60);
DAYS:= HOURS//24;
HOURS:= MOD(HOURS,24);
IF SECDEC >= 0 THEN
BEGIN
IF ENTIER(SECONDS*POWERSEC+0.5) = 60*POWERSEC THEN
BEGIN M:= M + 1; SECONDS:= 0 END;
ADJUSTED;
INTEDIT(M,2); FIELD.PUTCHAR('.');
IF SECONDS < 9.5 THEN
BEGIN FIELD.PUTCHAR('0');
FIXEDIT(SECONDS,IF SECDEC = 0 THEN 1 ELSE SECDEC+2)
END ELSE
FIXEDIT(SECONDS,IF SECDEC = 0 THEN 2 ELSE SECDEC+3);
END ELSE
BEGIN TIME:= M + SECONDS/60;
M:= TIME;
IF ADJUSTED THEN TIME:= 0;
IF TIME < 9.5 THEN FIELD.PUTCHAR('0');
FIXEDIT(TIME,IF TIME < 9.5 THEN 1 ELSE 2)
END;
FIELD.SETPOS(1); PUTTIME:- FIELD
END OF PUTTIME OK ELSE
ERROR:
BEGIN FIELD.SETPOS(1);
WHILE FIELD.MORE DO FIELD.PUTCHAR('*');
FIELD.SETPOS(1);
PUTTIME:- FIELD ;
END OF PUTTIME ERROR;
PROCEDURE OUTTIME(U_TIME); REAL U_TIME ;
BEGIN
TEXT SAVEFIELD;
SAVEFIELD:- FIELD ;
IF POS + LLENGTH > LENGTH + 1 THEN OUTIMAGE ;
FIELD:- IMAGE.SUB(POS,LLENGTH);
PUTTIME(U_TIME);
SETPOS(POS + LLENGTH);
FIELD :- SAVEFIELD ;
END OF OUTTIME ;
COMMENT **************************************************
HOLD_UNTIL_READY DEFINITION
**********************************************************;
PROCEDURE HOLD_UNTIL_READY;
BEGIN
IF CURRENT.NEXTEV==NONE THEN
BEGIN
OUTTEXT("THE SIMULATION WAS ALREADY FINISHED.");
SKIP(0);
OUTTEXT("DO NOT MAKE ""HOLD"" IN THE MAIN PROGRAM,");
SKIP(0);
OUTTEXT("BEFORE HOLD_UNTIL_READY");
SKIP(0);
END ELSE PASSIVATE;
END;
COMMENT **************************************************
FACILITY DEFINITION
**********************************************************;
CLASS FACILITY;
BEGIN
REF (HEAD) INQ;
REF (TRANSACTION) OCCUPIER;
INTEGER ENTRIES ;
REAL TLAST, BUSY_TIME ;
BOOLEAN PROCEDURE BUSY;
BUSY := OCCUPIER =/= NONE ;
INQ :- NEW HEAD ;
TLAST := TIME_ORIGIN ;
END FACILITY DEFINITION;
COMMENT **************************************************
STORAGE DEFINITION
**********************************************************;
CLASS STORAGE (CAPACITY);
INTEGER CAPACITY;
BEGIN
REF (HEAD) INQ;
INTEGER MAX,ENTRIES,UNIT_ENTRIES; REAL CONTENTS;
REAL TLAST, INTGRL;
COMMENT ********************************************
CHECK_INQ DEFINITION
****************************************************;
PROCEDURE CHECK_INQ;
BEGIN
REF (TRANSACTION) CLIENT, NEXT_CLIENT;
CLIENT :- INQ.FIRST;
LOOP:
IF CLIENT == NONE OR CONTENTS= CAPACITY
THEN GOTO FIN;
NEXT_CLIENT :- CLIENT.SUC ;
ACTIVATE CLIENT ;
CLIENT :- NEXT_CLIENT;
GOTO LOOP;
FIN:
END OF CHECK_INQ ;
INQ :- NEW HEAD ;
TLAST := TIME_ORIGIN ;
END STORAGE DEFINITION ;
COMMENT ************
STORAGE CREATION
********************;
PROCEDURE SET_STORAGE (N,CAPACITY);
INTEGER N, CAPACITY;
BEGIN
NSTOR := NSTOR + 1 ;
BOX (N) :- NEW STORAGE (CAPACITY);
END ;
COMMENT **************************************************
QUEUE DEFINITION
**********************************************************;
CLASS Q ;
BEGIN
INTEGER ENTRIES, MAX ;
REAL INTGRL, TLAST, CONTENTS;
TLAST := TIME_ORIGIN ;
END ;
BOOLEAN INIT;
COMMENT **************************************************
TRANSACTION DEFINITION
**********************************************************;
PROCESS CLASS TRANSACTION ;
COMMENT NOT HIDDEN PROTECTED ENTER_QUEUE,LEAVE_QUEUE,ENTER_STATION,
LEAVE_STATION,ENTER_STORAGE,LEAVE_STORAGE,ID,TIME_MARK,
OCCURRENCES,PRIORITY,PRIORITY_INTO;
COMMENT NOT HIDDEN IDLE,NEXTEV,OUT,FOLLOW,PRECEDE,INTO,SUC,PRED;
BEGIN
REAL TIME_MARK, PRIORITY;
INTEGER ID ;
REF(HEAD) OCCURRENCES;
COMMENT ***************************************************
TRACE DEFINITION
***********************************************************;
PROCEDURE TRACE(N);
INTEGER N;
BEGIN
IF NOT INIT THEN BEGIN
IF LINE>1 THEN SKIP(100) ELSE SKIP(1);
INIT:=TRUE;
END;
FIELD:-IMAGE.SUB(POSITION,LLENGTH);
TRANS_NAME_OUT(ID);
IF MR<0 THEN OUTTEXT(" LEAVING ") ELSE
OUTTEXT(" ENTERING ");
FACILITY_NAME_OUT(MR,N);
SETPOS(MAXLENGTH+15+
(IF TRANS_NNAME==NOTEXT THEN 11 ELSE TLENGTH+5));
OUTTEXT("AT TIME ");
PUTTIME(GPSSS_TIME+BBEGIN_TIME);
IF MOD(LINE,5)=0 THEN SKIP(1) ELSE SKIP(0);
IF LINE>58 THEN SKIP(100);
END TRACE ;
COMMENT ***************
FINAL_WAIT DEFINITION
***********************;
PROCEDURE FINAL_WAIT(Q_REF);
REF(HEAD)Q_REF;
BEGIN
REF(TRANSACTION)CURRENT_TRANSACTION;
CURRENT_TRANSACTION:-Q_REF.LAST;
WHILE CURRENT_TRANSACTION =/=NONE DO
BEGIN
IF ID>CURRENT_TRANSACTION.ID THEN
BEGIN
FOLLOW(CURRENT_TRANSACTION);
GOTO OUT;
END;
CURRENT_TRANSACTION:-CURRENT_TRANSACTION.PRED;
END;
FOLLOW(Q_REF);
OUT:
END FINAL_WAIT ;
COMMENT ************
ENTER_STATION
********************;
PROCEDURE ENTER_STATION (N);
INTEGER N ;
BEGIN
CHECK_LIMITS(N,2);
IF OUTOFORDER THEN GOTO UT;
START:
INSPECT STATION(N) DO
BEGIN
IF OCCUPIER == THIS TRANSACTION THEN
BEGIN
ERLOC := N ;
ERREUR(6);
GOTO EXIT;
END ;
IF BUSY THEN BEGIN
PRIORITY_INTO(INQ);
IF NEXTEV==NONE THEN ACTIVATE MAIN DELAY 0 ;
PASSIVATE;
OUT;
END ELSE TLAST := TIME;
ENTRIES := ENTRIES+1;
OCCUPIER :- THIS TRANSACTION;
MR:=2;
IF TRACE_ON THEN TRACE(N);
IF OBJECT_TRACE_ON THEN
NEW OCCURRENCE_STATISTICS(2,N,GPSSS_TIME
).INTO(OCCURRENCES);
EXIT:
END
OTHERWISE BEGIN
STATION (N) :- NEW FACILITY;
NSTAT := NSTAT+1;
GOTO START;
END ;
UT:OUTOFORDER :=FALSE;
END ENTER_STATION ;
COMMENT ************
LEAVE_STATION
********************;
PROCEDURE LEAVE_STATION (N) ;
INTEGER N ;
BEGIN
CHECK_LIMITS(N,2);
IF OUTOFORDER THEN GOTO UT;
INSPECT STATION (N) WHEN FACILITY DO
BEGIN
IF OCCUPIER =/= THIS TRANSACTION THEN
BEGIN
ERLOC := N ;
ERREUR (3);
GOTO EXIT ;
END ;
IF INQ.EMPTY THEN BEGIN
OCCUPIER :- NONE ;
BUSY_TIME:=BUSY_TIME + TIME - TLAST;
END
ELSE BEGIN
OCCUPIER :- INQ.FIRST;
ACTIVATE INQ.FIRST DELAY 0 ;
END ;
MR:=-2;
IF TRACE_ON THEN TRACE(N);
IF OBJECT_TRACE_ON THEN
NEW OCCURRENCE_STATISTICS(
-2,N,GPSSS_TIME).
INTO(OCCURRENCES);
EXIT:
END OTHERWISE BEGIN
ERLOC := N ;
ERREUR(3) ;
END ;
UT:OUTOFORDER :=FALSE;
END LEAVE_STATION ;
COMMENT ************
ENTER_STORAGE
********************;
PROCEDURE ENTER_STORAGE (N, UNITS_REQUIRED) ;
INTEGER N, UNITS_REQUIRED ;
BEGIN
CHECK_LIMITS(N,3);
IF OUTOFORDER THEN GOTO UT;
IF BOX (N) == NONE THEN SET_STORAGE(N,1000000) ;
INSPECT BOX (N) WHEN STORAGE DO
BEGIN
IF UNITS_REQUIRED>CAPACITY THEN
BEGIN
ERLOC := N ;
ERREUR (4);
GOTO ERROR_EXIT ;
END ;
PRIORITY_INTO (INQ);
TEST:
IF UNITS_REQUIRED <= CAPACITY-CONTENTS THEN GOTO EXIT;
IF NEXTEV==NONE THEN ACTIVATE MAIN DELAY 0 ;
PASSIVATE;
GOTO TEST;
EXIT:
MR:=3;
IF TRACE_ON THEN TRACE(N);
IF OBJECT_TRACE_ON THEN
NEW OCCURRENCE_STATISTICS(
3,N,GPSSS_TIME).
INTO(OCCURRENCES);
OUT;
ENTRIES:=ENTRIES+1;
UNIT_ENTRIES:=UNIT_ENTRIES+UNITS_REQUIRED;
ACCUM(INTGRL,TLAST,CONTENTS,UNITS_REQUIRED);
IF CONTENTS> MAX THEN MAX := CONTENTS;
HOLD (0);
END INSPECT ;
ERROR_EXIT:
UT: OUTOFORDER :=FALSE;
END ENTER_STORAGE;
COMMENT ************
LEAVE_STORAGE
********************;
PROCEDURE LEAVE_STORAGE (N,UNITS_RELEASED);
INTEGER N,UNITS_RELEASED;
BEGIN
CHECK_LIMITS(N,3);
IF OUTOFORDER THEN GOTO UT;
INSPECT BOX (N) WHEN STORAGE DO
BEGIN
ACCUM(INTGRL,TLAST,CONTENTS,-(UNITS_RELEASED)) ;
IF CONTENTS< 0 THEN BEGIN
ERLOC:=N;
ERREUR (5);
CONTENTS:= 0;
END ELSE BEGIN
CHECK_INQ;
MR:=-3;
IF TRACE_ON THEN TRACE(N);
IF OBJECT_TRACE_ON THEN
NEW OCCURRENCE_STATISTICS(
-3,N,GPSSS_TIME).
INTO(OCCURRENCES);
END;
END
OTHERWISE SET_STORAGE (N,1000000) ;
UT:OUTOFORDER :=FALSE;
END;
COMMENT ************
ENTER_QUEUE
********************;
PROCEDURE ENTER_QUEUE (N);
INTEGER N ;
BEGIN
CHECK_LIMITS(N,1);
IF OUTOFORDER THEN GOTO UT;
IF FILE (N) == NONE THEN BEGIN
FILE (N) :- NEW Q;
NQUE := NQUE + 1;
END ;
INSPECT FILE (N) DO
BEGIN
ENTRIES := ENTRIES +1;
ACCUM (INTGRL,TLAST,CONTENTS,1);
IF CONTENTS>MAX THEN MAX := CONTENTS;
MR:=1;
IF TRACE_ON THEN TRACE(N);
IF OBJECT_TRACE_ON THEN
NEW OCCURRENCE_STATISTICS(
1,N,GPSSS_TIME).
INTO(OCCURRENCES);
END ;
UT:OUTOFORDER :=FALSE;
END ENTER_QUEUE;
COMMENT ************
LEAVE_QUEUE
********************;
PROCEDURE LEAVE_QUEUE (N) ;
INTEGER N;
BEGIN
CHECK_LIMITS(N,1);
IF OUTOFORDER THEN GOTO UT;
INSPECT FILE (N) DO
IF CONTENTS= 0 THEN BEGIN
ERLOC:= N ;
ERREUR(7) ; END
ELSE BEGIN
ACCUM (INTGRL,TLAST,CONTENTS,-1);
MR:=-1;
IF TRACE_ON THEN TRACE(N);
IF OBJECT_TRACE_ON THEN
NEW OCCURRENCE_STATISTICS(
-1,N,GPSSS_TIME).
INTO(OCCURRENCES);
END
OTHERWISE BEGIN
ERLOC := N ;
ERREUR(8);
FILE (N) :- NEW Q ;
NQUE := NQUE +1 ;
END ;
UT:OUTOFORDER :=FALSE;
END;
COMMENT ************
PRIORITY_INTO
********************;
PROCEDURE PRIORITY_INTO (QUEUE) ;
REF (HEAD) QUEUE;
BEGIN
REF (TRANSACTION) PT ;
REF (PROCESS) P ;
IF QUEUE.EMPTY THEN INTO(QUEUE)
ELSE BEGIN
COMMENT SKIP NON TRANSACTION OBJECTS ;
P:-QUEUE.LAST ;
L: IF P IN TRANSACTION OR P== NONE THEN BEGIN
PT:-P;
GOTO LOOP;
END ;
P:-P.PRED ;
GOTO L;
PREDEC: PT :- PT.PRED ;
LOOP: IF PT== NONE THEN PRECEDE(QUEUE.FIRST)
ELSE IF PRIORITY<PT.PRIORITY THEN GOTO PREDEC
ELSE IF PRIORITY=PT.PRIORITY AND PRIORITY<0
THEN GOTO PREDEC
ELSE FOLLOW (PT);
END ;
END PROCEDURE PRIORITY_INTO ;
INTEGER MR;
TIME_MARK := GPSSS_TIME ;
TRANSID := TRANSID + 1 ;
ID := TRANSID ;
IF OBJECT_TRACE_ON THEN OCCURRENCES:-NEW HEAD;
INNER;
IF OBJECT_TRACE_ON THEN FINAL_WAIT (FINISHED_OBJECTS);
IF NEXTEV==NONE THEN ACTIVATE MAIN DELAY 0;
END CLASS TRANSACTION ;
COMMENT *******************************
WAIT_UNTIL PARAPHENALIA
***************************************;
REF (HEAD) WAITQ ;
REF (WAIT_MONITOR) WAIT_MONITEUR ;
BOOLEAN WAIT_ACTION ;
PROCEDURE WAIT_UNTIL (B); NAME B; BOOLEAN B ;
INSPECT CURRENT DO BEGIN
IF B THEN GOTO EXIT ;
IF CURRENT IN TRANSACTION THEN
CURRENT QUA TRANSACTION.PRIORITY_INTO(WAITQ)
ELSE INTO(WAITQ);
IF WAIT_MONITEUR.IDLE THEN
ACTIVATE WAIT_MONITEUR AFTER NEXTEV ;
LOOP:
PASSIVATE;
IF NOT B THEN GOTO LOOP ;
OUT ;
WAIT_ACTION := TRUE ;
EXIT:
END WAIT_UNTIL ;
PROCESS CLASS WAIT_MONITOR ;
BEGIN
REF (PROCESS) PT ;
START:
IF WAITQ.EMPTY THEN PASSIVATE ;
WAIT_ACTION := FALSE ;
PT :- WAITQ.FIRST ;
LOOP:
IF PT == NONE THEN GOTO WAIT ;
ACTIVATE PT ;
IF WAIT_ACTION THEN GOTO START ;
PT :- PT.SUC ;
GOTO LOOP ;
WAIT:
REACTIVATE CURRENT AFTER NEXTEV ;
GOTO START ;
END WAIT_MONITOR ;
COMMENT
******************************
PROCEDURES UTILITAIRES
******************************;
PROCEDURE SKIP (N) ;
INTEGER N;
BEGIN
OUTIMAGE;
IF N>0 THEN BEGIN
IF LINE+N > 60 THEN EJECT(2)
ELSE EJECT (LINE+N);
END ;
END PROC SKIP;
REAL PROCEDURE GPSSS_TIME ;
GPSSS_TIME := TIME- SIMULATION_START_TIME ;
PROCEDURE CLEAR_SQS ;
L1: IF CURRENT.NEXTEV =/= NONE THEN
BEGIN
CANCEL (CURRENT.NEXTEV) ;
GOTO L1 ;
END ;
PROCEDURE RESTART ;
BEGIN
INTEGER I ;
IF CURRENT =/= MAIN THEN BEGIN
ERREUR(9) ; GOTO OUT ; END ;
ERROR_REPORT ;
IF NOT NOREPORT THEN STANDARD_REPORT ;
PASSE := PASSE + 1 ;
COMMENT CANCEL ALL RESOURCES ;
FOR I := 1 STEP 1 UNTIL MAX_STATIONS DO
STATION (I) :- NONE ;
FOR I := 1 STEP 1 UNTIL MAX_STORAGES DO
BOX (I) :- NONE ;
FOR I := 1 STEP 1 UNTIL MAX_QUEUES DO
FILE (I) :- NONE ;
COMMENT CANCEL ALL EVENTS ;
CLEAR_SQS ;
INIT:=FALSE;
SIMULATION_START_TIME := TIME ;
NSTAT := NSTOR := NQUE := 0 ;
TRANSID := 0 ;
U := 987654321 ;
FINISHED_OBJECTS :- NEW HEAD ;
OUT:
END ;
COMMENT *****************************************
ENQUIRY PROCEDURES
*************************************************;
INTEGER PROCEDURE CONTENTS_STATION(N) ;
INTEGER N ;
BEGIN CHECK_LIMITS(N,2);
IF OUTOFORDER THEN GOTO UT;
INSPECT STATION(N) DO
IF BUSY THEN CONTENTS_STATION := 1 ;
UT:
END;
INTEGER PROCEDURE CONTENTS_STORAGE (N) ;
INTEGER N ;
BEGIN CHECK_LIMITS(N,2);
IF OUTOFORDER THEN GOTO UT;
INSPECT BOX (N) DO
CONTENTS_STORAGE := CONTENTS;
UT:
END;
INTEGER PROCEDURE CONTENTS_QUEUE (N) ;
INTEGER N ;
BEGIN CHECK_LIMITS(N,2);
IF OUTOFORDER THEN GOTO UT;
INSPECT FILE (N) DO
CONTENTS_QUEUE := CONTENTS ;
UT:
END;
INTEGER PROCEDURE WAITING_STATION (N) ;
INTEGER N ;
BEGIN CHECK_LIMITS(N,2);
IF OUTOFORDER THEN GOTO UT;
INSPECT STATION (N) DO
WAITING_STATION := INQ.CARDINAL ;
UT:
END;
INTEGER PROCEDURE WAITING_STORAGE (N) ;
INTEGER N ;
BEGIN CHECK_LIMITS(N,2);
IF OUTOFORDER THEN GOTO UT;
INSPECT BOX (N) DO
WAITING_STORAGE := INQ.CARDINAL ;
UT:
END;
INTEGER PROCEDURE WAITING_QUEUE (N) ;
INTEGER N ;
BEGIN CHECK_LIMITS(N,2);
IF OUTOFORDER THEN GOTO UT;
WAITING_QUEUE := 0 ;
UT:
END;
COMMENT **************************************************
REPORT GENERATOR
**********************************************************;
PROCEDURE STANDARD_REPORT ;
BEGIN
INTEGER I;
BOOLEAN SBUS;
REAL DTIME;
DTIME := TIME-TIME_ORIGIN;
SKIP(100);
OUTTEXT("***************************");
OUTTEXT(" -VERSION 4.1-") ; OUTIMAGE ;
OUTTEXT("*** MONTREAL GPSSS ***"); SKIP(0) ;
OUTTEXT("*** SIMULATION REPORT ***");
SKIP(0); OUTTEXT("***************************");
SKIP(2);
OUTTEXT("PASSE =") ;
OUTINT(PASSE,3) ;
SKIP(1) ;
OUTTEXT("START TIME=");
FIELD:-IMAGE.SUB(13,LLENGTH);
PUTTIME(TIME_ORIGIN-SIMULATION_START_TIME
+BBEGIN_TIME ) ;
SKIP(0);
OUTTEXT("END TIME=");
PUTTIME(GPSSS_TIME + BBEGIN_TIME);
IF DTIME=0 THEN BEGIN
SKIP(2);
OUTTEXT("ELAPSED TIME = 0 - REPORT SKIPPED") ;
GOTO EXIT ;
END ;
SKIP(2);
IF NSTAT=0 THEN BEGIN
OUTTEXT("* NO STATIONS *");
GOTO L1;
END ;
OUTTEXT("* STATIONS *");
SKIP(0); OUTTEXT("************");
SKIP(1);
SETPOS(15);
OUTTEXT("AVERAGE");
SETPOS(38);
OUTTEXT("AVERAGE");
SKIP(0);
OUTTEXT
(" STATION UTILISATION ENTRIES TRANSIT TIME STATUS");
SKIP(1);
FIELD:-IMAGE.SUB(32,LLENGTH);
FOR I:=1 STEP 1 UNTIL MAX_STATIONS DO
INSPECT STATION(I) DO
BEGIN
SBUS := BUSY ;
IF SBUS THEN BUSY_TIME:=BUSY_TIME+TIME-TLAST;
OUTINT(I,7);
OUTFIX(BUSY_TIME/DTIME,2,13);
OUTINT(ENTRIES,10);
PUTTIME(BUSY_TIME/ENTRIES);
SETPOS(52);
IF SBUS THEN OUTTEXT("BUSY")
ELSE OUTTEXT("FREE");
COMMENT RE-INITIALISATION DES STATISTIQUES ;
IF SBUS THEN ENTRIES :=1 ELSE ENTRIES :=0 ;
BUSY_TIME := 0;
TLAST := TIME;
SKIP(0);
END ;
L1:
SKIP(2);
IF NSTOR=0 THEN BEGIN
OUTTEXT("* NO STORAGES *");
GOTO L2;
END ;
OUTTEXT("* STORAGES *");
SKIP(0); OUTTEXT("************");
SKIP(1);
SETPOS(23); OUTTEXT("AVG.");
SETPOS(32); OUTTEXT("AVG.");
SETPOS(51); OUTTEXT("THRU TIME");
SETPOS(67); OUTTEXT("CONTENTS");
SKIP(0);
OUTTEXT
("STORAGE CAPACITY CONTENTS UTIL. ENTRIES ");
OUTTEXT
(" / UNIT MAX NOW");
SKIP(1);
FIELD:-IMAGE.SUB(46,LLENGTH);
FOR I:=1 STEP 1 UNTIL MAX_STORAGES DO
INSPECT BOX(I) DO
BEGIN
ACCUM(INTGRL,TLAST,CONTENTS,0);
OUTINT(I,5) ;
OUTINT(CAPACITY,10) ;
OUTFIX(INTGRL/DTIME,2,12) ;
IF CAPACITY=0 THEN SETPOS(38) ELSE
OUTFIX(INTGRL/(DTIME*CAPACITY),4,8);
OUTINT(ENTRIES,8);
IF UNIT_ENTRIES=0 THEN SETPOS(61) ELSE
PUTTIME (INTGRL/UNIT_ENTRIES);
SETPOS(63);
OUTINT(MAX,7);
OUTINT(CONTENTS,7);
SKIP(0);
COMMENT RE-INITIALISATION DES STATISTIQUES ;
ENTRIES := 0;
UNIT_ENTRIES := CONTENTS;
INTGRL := 0 ;
TLAST := TIME;
MAX := CONTENTS;
END ;
L2:
SKIP(2);
IF NQUE=0 THEN BEGIN
OUTTEXT("* NO QUEUES *");
GOTO EXIT;
END ;
OUTTEXT("* QUEUES *") ;
SKIP(0); OUTTEXT("**********") ;
SKIP(1);
SETPOS(19); OUTTEXT(
"MAX. CURRENT AVG. AVG.") ;
SKIP(0); OUTTEXT(
"QUEUE ENTRIES CONTENTS CONTENTS CONTENTS TIME/TRANS");
SKIP(1);
FIELD:-IMAGE.SUB(46,LLENGTH);
FOR I := 1 STEP 1 UNTIL MAX_QUEUES DO
INSPECT FILE (I) DO
BEGIN
ACCUM(INTGRL,TLAST,CONTENTS,0);
OUTINT(I,4) ;
OUTINT(ENTRIES,8);
OUTINT(MAX,10);
OUTINT(CONTENTS,10);
OUTFIX(INTGRL/DTIME,2,11);
IF ENTRIES=0 THEN GOTO OVER;
PUTTIME(INTGRL/ENTRIES);
OVER:
INTGRL := 0;
MAX := ENTRIES := CONTENTS;
SKIP(0) ;
END ;
EXIT:
TIME_ORIGIN := TIME;
END PROC STANDARD_REPORT ;
COMMENT ******************************
ERROR PACKAGE
***************************************;
INTEGER ERNUM,ERLOC ;
INTEGER ARRAY ERTYPE(1:15),ERRES (1:15), ERTRAN (1:15) ;
REAL ARRAY ERTIME (1:15) ;
PROCEDURE ERREUR (N) ;
INTEGER N ;
BEGIN
ERNUM := ERNUM + 1 ;
ERTIME (ERNUM) := GPSSS_TIME ;
IF N<2 OR N>12 THEN
ERTYPE(ERNUM) := 1
ELSE BEGIN
ERTYPE(ERNUM) := N ;
ERRES (ERNUM) := ERLOC ;
INSPECT CURRENT WHEN TRANSACTION DO
ERTRAN (ERNUM) := ID
OTHERWISE
ERTRAN (ERNUM) := 0 ;
END ;
IF ERNUM = 14 THEN BEGIN
ERREUR(2) ;
CLEAR_SQS ;
ERROR_REPORT ;
IF CURRENT =/= MAIN THEN BEGIN
ACTIVATE MAIN DELAY 0 ;
PASSIVATE;
END ;
END ;
ERLOC := 0 ;
END ;
PROCEDURE ERROR_REPORT ;
BEGIN
INTEGER I ;
PROCEDURE PHRASE1 (N) ; INTEGER N;
BEGIN
IF N=1 THEN OUTTEXT("IN STATION") ELSE
IF N=2 THEN OUTTEXT("IN STORAGE") ELSE
IF N=3 THEN OUTTEXT("IN QUEUE" ) ELSE
OUTTEXT("IN XXX" ) ;
OUTINT(ERRES(I),3) ;
OUTIMAGE ;
END ;
PROCEDURE PHRASE2 ;
BEGIN
OUTTEXT(" TRANSACTION") ;
OUTINT(ERTRAN(I),4) ;
END ;
IF ERNUM=0 THEN GOTO EXIT ;
SKIP(100) ;
OUTTEXT("GPSSS ERROR REPORT - AT TIME=") ;
FIELD:-IMAGE.SUB(34,LLENGTH);
PUTTIME(GPSSS_TIME);
OUTIMAGE ;
OUTTEXT("******************") ; SKIP(1) ;
OUTTEXT("PASSE =") ;
OUTINT(PASSE,3) ;
SKIP(1) ;
OUTTEXT("** TIME **") ; OUTIMAGE ;
FIELD:-IMAGE.SUB(1,LLENGTH);
FOR I:=1 STEP 1 UNTIL ERNUM DO
BEGIN
SWITCH MSG:= L1,L2,L3,L4,L5,L6,L7,L8,L9,L10,L11,L12;
OUTIMAGE ;
PUTTIME(ERTIME(I));
SETPOS(LLENGTH);
OUTTEXT(" - ") ;
GOTO MSG(ERTYPE(I));
L1:OUTTEXT("SYSTEM ERROR") ;
GOTO OUT ;
L2:OUTTEXT("TOO MANY ERRORS - SIMULATION TERMINATED");
GOTO OUT ;
L3:PHRASE1 (1) ; PHRASE2 ;
OUTTEXT(" TRIES TO LEAVE BEFORE ENTERING") ;
GOTO OUT ;
L4:PHRASE1 (2) ; PHRASE2 ;
OUTTEXT(" REQUIRES MORE THAN MAX CAPACITY") ;
GOTO OUT ;
L5:PHRASE1 (2) ; PHRASE2 ;
OUTTEXT(" CAUSES OVERFLOW WHEN LEAVING") ;
GOTO OUT ;
L6:PHRASE1 (1) ; PHRASE2 ;
OUTTEXT(" TRIES TO RE-ENTER") ;
GOTO OUT ;
L7:PHRASE1 (3) ; PHRASE2 ;
OUTTEXT(" TRIES TO LEAVE EMPTY QUEUE") ;
GOTO OUT ;
L8:PHRASE1 (3) ; PHRASE2 ;
OUTTEXT(" TRIES TO LEAVE NON-EXISTENT QUEUE") ;
GOTO OUT ;
L9:OUTTEXT("RESTART USED OUTSIDE MAIN PROGRAM");
OUTTEXT(" - NO ACTION") ;
GOTO OUT ;
L10:PHRASE1 (1);GOTO L13;
L11:PHRASE1 (2);GOTO L13;
L12:PHRASE1 (3);GOTO L13;
L13:OUTTEXT(" = NON-EXISTENT RESOURCE ");
OUT:
OUTIMAGE ;
END ;
ERNUM := 0 ;
EXIT:
END ;
COMMENT *********************
POSITION DEFINITION
*****************************;
INTEGER PROCEDURE POSITION ;
IF
(IF TLENGTH = 0 THEN 10 ELSE TLENGTH + 4 )
+ 24 + MAXLENGTH > 79 - TLENGTH
THEN BEGIN
POSITION:= 45 ;
MAXLENGTH:= 11 ;
TLENGTH:=0;
CLEAR_NAMES;
SKIP(0);
OUTTEXT(" YOU HAVE TO MANY CHARACTERS IN YOUR NAME(S) ");
SKIP(1);
END ELSE POSITION:=
(IF TLENGTH = 0 THEN 10 ELSE TLENGTH + 4 )
+ 24 + MAXLENGTH ;
COMMENT ******************
CLEAR_NAMES DEFINITION
**************************;
PROCEDURE CLEAR_NAMES;
BEGIN INTEGER J;
FOR J:=1 STEP 1 UNTIL MAX_QUEUES DO
QUEUE_NNAME(J):-NOTEXT;
FOR J:=1 STEP 1 UNTIL MAX_STATIONS DO
STATION_NNAME(J):-NOTEXT;
FOR J:=1 STEP 1 UNTIL MAX_STORAGES DO
STORAGE_NNAME(J):-NOTEXT;
TRANS_NNAME:-NOTEXT;
END;
COMMENT ************************************
INITIALISATION
********************************************;
INTEGER U ;
REAL TIME_ORIGIN, SIMULATION_START_TIME ;
U :=987654321;
PASSE := 1 ;
MAXLENGTH:=11;
LLENGTH:=(IF SECDEC<0 THEN 13 ELSE
IF SECDEC=0 THEN 16 ELSE 17+SECDEC);
WAITQ :- NEW HEAD ;
WAIT_MONITEUR :- NEW WAIT_MONITOR ;
FINISHED_OBJECTS:-NEW HEAD;
INNER ;
ERROR_REPORT ;
IF NOT NOREPORT THEN STANDARD_REPORT ;
END GPSSS DEFINITION
COMMENT L#KARMOTTAGNING MED PROVTAGNING ;
GP3S2(3,4,1,'M',-1) BEGIN
TRANSACTION CLASS PATIENT (TID1,TID2) ;
REAL TID1 , TID2 ;
BEGIN
PROCEDURE TILL_STATION (NUM) ;
INTEGER NUM ;
BEGIN ENTER_QUEUE( NUM ) ;
WAIT_UNTIL(CONTENTS_STATION(NUM)=0
OR CONTENTS_STATION(NUM+1)=0);
LEAVE_QUEUE( NUM ) ;
IF CONTENTS_STATION ( NUM ) = 0 THEN
ENTER_STATION( NUM ) ELSE
ENTER_STATION( NUM + 1 ) ;
HOLD(IF NUM=1 THEN TID1 ELSE TID2);
IF STATION(NUM).OCCUPIER==THIS TRANSACTION
THEN LEAVE_STATION( NUM ) ELSE
LEAVE_STATION( NUM + 1 );
END PROC. TILL_STATION ;
ENTER_STORAGE(1,1) ;
FOR I := 1,3 DO TILL_STATION( I ) ;
LEAVE_STORAGE( 1 , 1 ) ;
END PATIENT ;
INTEGER I , J , U1 , U2;
OBJECT_TRACE_ON := TRUE ;
TIME_SPENT_ONLY := TRUE ;
SET_STORAGE( 1 , 10 ) ;
QUEUE_NAME( 1," K@N TILL PROVTAGNINGEN" ) ;
QUEUE_NAME( 3," V#NTRUMMET TILL L#KARNA " ) ;
STORAGE_NAME( 1 ," L#KARHUSET " ) ;
STATION_NAME( 1 ," PROVSTATION - 1 - " ) ;
STATION_NAME( 2 ," PROVSTATION - 2 - " ) ;
STATION_NAME( 3," / HOS L#KARE - ETT -") ;
STATION_NAME( 4," / HOS L#KARE - TV$ -") ;
BEGIN_TIME(9.00); U1:=123987 ; U2:=987123 ;
FOR J := 1 STEP 1 UNTIL 10 DO BEGIN
ACTIVATE NEW PATIENT( NORMAL( 60 , 20 , U1 ) ,
UNIFORM(20 , 120 , U2 ) ) DELAY 0 ;
HOLD( NEGEXP( 2/60 , U ) );
END INIT PATIENT ;
HOLD_UNTIL_READY;
TRACE_OBJECTS;
END ;
END
//