Chapter 7 - Block Statements

You use Block Statements to create GPSS Block Entities. Block Statements which are part of the Initial Model Translation create permanent Blocks in the simulation. A Block Statement sent to an existing simulation creates a one-time temporary Block to be used in a mode called Manual Simulation. This is discussed in more detail in Section 2.3.

A model is simply a sequence of Model Statements. A GPSS World Model Statement is either a GPSS Statement or a PLUS Procedure definition. The GPSS Statements, in turn, are either Block Statements, which cause a Block to be created, or Commands, which do not. Any Model Statement can be sent to an existing simulation as an Interactive Statement.

This chapter contains reference information for each Block Statement supported by GPSS World.

The GPSS Block statements are:

ADOPT - Change Assembly Set.

ADVANCE - Place Transaction on Future Events Chain.

ALTER - Test and modify Transactions in a Group.

ASSEMBLE - Wait for and destroy related Transactions.

ASSIGN - Modify Transaction Parameter.

BUFFER - Place Transaction on the Current Events Chain behind its priority peers.

CLOSE - End the Data Stream.

COUNT - Place count of entities into a Transaction Parameter.

DEPART - Decrement content of a Queue Entity.

DISPLACE - Change the Next Sequential Block of a Transaction.

ENTER - Occupy or wait for storage units in a Storage Entity.

EXAMINE - Test group membership.

EXECUTE - Perform action specified by a different Block.

FAVAIL - Change status of a Facility Entity to "available".

FUNAVAIL - Change status of a Facility Entity to "not available".

GATE - Test entity and modify Transaction flow.

GATHER - Wait for related Transactions.

GENERATE - Create Transaction and place on Future Events Chain.

INDEX - Modify Transaction Parameter.

INTEGRATION - Turn the integration of a User Variable On or Off.

JOIN - Place a member into a Numeric or Transaction Group.

LEAVE - Release storage units of a Storage Entity.

LINK - Move Transaction to Userchain Entity.

LOGIC - Modify Logicswitch Entity.

LOOP - Decrement Parameter, jump to different Block if result is nonzero.

MARK - Place value of system clock into Transaction Parameter.

MATCH - Wait for related Transaction to reach conjugate MATCH Block.

MSAVEVALUE - Assign value to Matrix Entity element.

OPEN - Initialize a Data Stream.

PLUS - Evaluate PLUS Expression and save result in Parameter.

PREEMPT - Displace Facility owner.

PRIORITY - Modify Transaction priority.

QUEUE - Increment content of a Queue Entity.

READ - Bring the next line of data from a Data Stream.

RELEASE - Free Facility Entity.

REMOVE - Take a member out of Numeric or Transaction Group.

RETURN - Free Facility Entity.

SAVAIL - Change status of Storage Entity to "available".

SAVEVALUE - Assign a value to Savevalue Entity.

SCAN - Test Transaction group, place value in Parameter.

SEEK - Change the line pointer in a Data Stream.

SEIZE - Assume ownership of or wait for a Facility Entity.

SELECT - Place selected entity number into Transaction Parameter.

SPLIT - Create related Transaction.

SUNAVAIL - Change status of Storage Entity to "not available".

TABULATE - Update Table Entity.

TERMINATE - Destroy Transaction, decrement Termination Count.

TEST - Test arithmetic condition and modify Transaction flow.

TRACE - Set Trace Indicator of the Active Transaction.

TRANSFER - Move to specified Block.

UNLINK - Remove Transaction from Userchain Entity.

UNTRACE - Turn off Trace Indicator in the Active Transaction.

WRITE - Send a value to a Data Stream.

 

 

 

Operands

Statements usually have one or more operands which you must fill in. Most operands have several different forms which are valid. In the descriptions which follow, a valid class of operands may be described by an italicized word. You must choose a member of the class and type it into the operand field. For example, if one of the valid forms of an operand is given as PosInteger, you could type:

21

The italicized words are usually suggestive, but you may need to refer to the formal definition in the Appendix.

Windows

A wide variety of windows are available for you to observe the state of Blocks and their effects on the other entities in your simulations. In general, windows are specialized by the entity type.

 Model Window - Text View ó Full screen textual model editor.

 Block Input Window - Drag and Drop model building.

 Journal Window - Record session events.

 Blocks Window - Online view of Block dynamics.

 Expressions Window - Online view of values of expressions.

 Facilities Window - Online view of Facility Entity dynamics.

 Logicswitches Window - Online view of Logicswitch Entity dynamics.

 Matrix Window - Online view of the dynamics of a Matrix cross-section.

 Plot Window - Online view of a plot of up to 8 expressions.

 Queues Window - Online view of Queue Entity dynamics.

 Savevalues Window - Online view of Savevalue Entity dynamics.

 Storages Window - Online view of Storage Entity dynamics.

 Table Window - Online view of Table Entity dynamics.

 

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 Numeric Groups Snapshot - Picture of the state of the Numeric Groups in the simulation.

 Userchains Snapshot - Picture of the state of the User Chains in the simulation.

 Transaction Groups Snapshot - Picture of the state of the Transaction Groups in the simulation.

 

 

        ADOPT

ADOPT Blocks are used to change the Assembly Set of the Active Transaction.

ADOPT A

Operand

A - Assembly Set. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

ADOPT 2000

The numerical Assembly Set value of the Active Transaction is given the value 2000. In effect, the Active Transaction becomes a member of Assembly Set 2000.

 

Action

When a Transaction enters an ADOPT Block, Operand A is evaluated numerically, and truncated. If the result is less than or equal to zero, an Error Stop occurs. Otherwise, the result is assigned to the Assembly Set value of the Active Transaction.

Every Transaction is assigned to an Assembly Set when it is created. For Transactions created in GENERATE Blocks, the initial assignment uses the same number for the Assembly Set as was used for the Transaction Number. For Transactions created in SPLIT Blocks, the offspring Transactions are placed in the same Assembly Set as their parent Transaction.

Assembly Sets are used to combine related Transactions in ASSEMBLE and GATHER Blocks. The ADOPT Block provides for easy control of Assembly Set assignments.

Special Restriction

 A must be positive.

Refuse Mode

A Transaction is never refused entry to an ADOPT Block.

Related Blocks

 ASSEMBLE - Wait for and destroy Assembly Set members.

 GATHER - Wait for Assembly Set members.

 MATCH - Wait for Assembly Set member.

 SPLIT - Create Transaction(s) in the same Assembly Set.

Related SNAs

 A1 - Assembly Set. Return the Assembly Set of the Active Transaction.

 MBEntnum - Match at Block. MBEntnum returns a 1 if there is a Transaction at Block Entnum which is in the same Assembly Set as the Active Transaction. MBEntnum returns a 0 otherwise.

Related Window

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 

ADVANCE

An ADVANCE Block delays the progress of a Transaction for a specified amount of simulated time.

ADVANCE A,B

Operands

A - The mean time increment. Optional. The operand must be Name, Number, String, ParenthesizedExpression, SNA or SNA*Parameter. The default is 0.

B - The time half-range or, if a function, the function modifier. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

ADVANCE 101.6,50.3

This example creates a Block which chooses a random number between 51.3 and 151.9, inclusively (i.e. 101.6 plus or minus 50.3), and delays the entering Transaction that amount of simulated time.

 

Action

An ADVANCE Block calculates a time increment and places the entering Transaction on the Future Events Chain (FEC) for that amount of simulated time.

The time increment can be calculated in several ways. If only the A Operand is specified, it is evaluated and used as the time increment. If the A and B operands are present, and B does not specify a function, both A and B are evaluated numerically and a random number between A-B and A+B, inclusively, is used as the time increment. You can select which random number generator number is to be used as the source of the random number. This is set in the "Random" page of the Model Settings Notebook.

                                CHOOSE View / Settings / Model

then select the Random page. Then fill in the desired random number stream entity number in the entry box marked "ADVANCE". The installation default is to use Random Number Stream number 1.

If B is an FN class SNA, called a Function Modifier, the evaluating B is multiplied by the result of evaluating the A Operand; the product is used as the time increment.

If zero is calculated as the time increment (ADVANCE 0), the entering Transaction is placed on the Current Events Chain in front of priority peers. Such a Block then behaves as a null operation. A further discussion of the Current Events Chain can be found in Chapter 9.

Special Restriction

 If a negative number is calculated as the time increment, an Error Stop occurs.

Refuse Mode

Normally, Transactions are not refused entry to an ADVANCE Block. However, since preempted Transactions are not permitted to exist on the Future Events Chain, a preempted Transaction will not be permitted to enter an ADVANCE Block if the time increment is positive (nonzero).

When a Transaction is refused entry, its Delay Indicator is set and remains so until the Transaction enters a "Simultaneous" Mode TRANSFER Block. To coordinate the state of multiple entities, it is better to use a TEST Block and BOOLEAN VARIABLE instead of a TRANSFER SIM Block.

Related Windows

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

ALTER

An ALTER Block changes the priority or a Parameter of selected members of a Transaction Group.

ALTER O A,B,C,D,E,F,G

Operands

O - Conditional operator. Relationship of E to F for the alteration to occur. These choices are explained below. Optional. The operator must be Null, E, G, GE, L, LE, MAX, MIN, or NE.

A - Transaction Group. Group whose members will be tested for alteration. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Limit. The maximum number of Transactions to be altered. The default is ALL. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Altered attribute. The member Transaction Parameter to be altered, or PR to alter the member Transaction priority. The operand must be PR, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Replacement value. The value which will replace attribute C. Required. The operand must be Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

E - Test value. PR or Parameter number. The member Transaction Parameter which determines whether each Group member Transaction should be altered, or PR to use the Transaction priority for the determination. It is evaluated with respect to the Transaction Group member. Optional. The operand must be PR, Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

F - Reference value. The value against which the E Operand is compared. It is evaluated with respect to the Active Transaction. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

G - Alternate Block number. The alternate destination for the Active Transaction. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Examples

ALTER Inventory,ALL,Price,49.95

In this simple example, all Transactions in the Transaction Group named Inventory have their Parameter named Price set equal to 49.95.

 

ALTER NE Bin7,10,Price,49.95,PartNum,99.95,Out

In this example, when a Transaction enters the ALTER Block, Transaction Group named Bin7 is scanned for Transactions which do not have a value of 99.95 in their Parameter named PartNum. The first 10 Transactions which meet the test have the value of their Parameter named Price set to 49.95. If 10 Transactions cannot be found which pass the test, the entering Transaction attempts to enter the Block labeled Out. Otherwise, it proceeds to the Next Sequential Block.

 

Action

An ALTER Block selects Transactions from a Transaction Group and alters one of the attributes of each of these Transactions. When a Transaction Group member is altered, its Transaction attribute specified by the C Operand is given the value specified by the D Operand. Altered Transactions are not displaced from their context. However, the Transaction entering the ALTER Block may be redirected according to the G Operand.

If you do not use a conditional operator, or operands E or F, all Transactions up to the limit (Operand B) are altered. In this case, no priority or Parameter test is made to determine whether or not to alter the attribute of the member Transaction.

If you use operands E, F, or a conditional operator, each Group member must pass a test before it is altered. Operand E specifies which attribute of the member Transactions is to be tested. It may be compared to the minimum or the maximum of all such Group member attributes by using MIN or MAX as the conditional operator. All Transactions which are tested and have the maximum or minimum attribute are altered. In this case, you must not use Operand F.

You may use a conditional operator to specify the relationship between the Transaction attribute (Operand E) and the reference value (Operand F) which will initiate the alteration of the Transaction. The default for the conditional operator is E for equality. If you use no conditional operator, but you use operand E and Operand F, the values must be equal for the member Transaction attribute to be altered.

You may compare the Group member attribute to Operand F, with or without a conditional operator. In this case, the conditional operator must not be MIN or MAX. Operand E always refers to the Group member under test. However, if any other operand is a Transaction related SNA, it is evaluated with respect to the entering Transaction.

The B Operand cuts off the Group scan when it equals the number of Transactions that have been altered. The default is ALL. If there is no attribute test, that is, if E is not specified, Transactions are altered until the alteration count equals B or until the entire Group has been tested.

The G Operand indicates an alternate destination Block to be taken by the entering Transaction when a special condition occurs. The G Operand is used for the next Block under the following conditions:

 No Transaction is altered.

 The count of altered Transactions specified by B cannot be reached.

If the G Operand is not used, the entering Transaction always goes to the Next Sequential Block.

Conditional Operators

The conditional operator may be E, G, GE, L, LE, MAX, MIN, or NE. If no conditional operator is used, E (equality) is assumed. When the condition is true, the Transaction being tested is altered. The conditions are defined as follows:

 E - The member Transaction attribute specified by Operand E must be equal to the reference value specified by Operand F for the member Transaction to be altered.

 G - The member Transaction attribute specified by Operand E must be greater than the reference value specified by Operand F for the member Transaction to be altered.

 GE - The member Transaction attribute specified by Operand E must be greater than or equal to the reference value specified by Operand F for the member Transaction to be altered.

 L - The member Transaction attribute specified by Operand E must be less than the reference value specified by Operand F for the member Transaction to be altered.

 LE - The member Transaction attribute specified by Operand E must be less than or equal to the reference value specified by Operand F for the member Transaction to be altered.

 MAX - The member Transaction attribute specified by Operand E must be equal to the largest such attribute of all Transactions in the Group for the member Transaction to be altered.

 MIN - The member Transaction attribute specified by Operand E must be equal to the smallest such attribute of all Transactions in the Group for the member Transaction to be altered.

 NE - The member Transaction attribute specified by Operand E must be unequal to the reference value specified by Operand F for the member Transaction to be altered.

If no conditional operator is used, E is assumed.

Special Restrictions

 If Operand E is used, then you must use Operand F or else you must use the conditional operator MIN or MAX.

 If Operand F is used, you must use Operand E, and not MIN or MAX.

 If MIN or MAX is used for the conditional operator, Operand E must be used and Operand F must not be used.

Refuse Mode

A Transaction is never refused entry to an ALTER Block.

Related Blocks

Transactions are added to Transaction Groups, and numbers are added to Numeric Groups by JOIN Blocks. Transactions in Groups can be referenced by ALTER, EXAMINE, REMOVE, and SCAN Blocks. Numbers in Numeric Groups can be referenced by EXAMINE and REMOVE Blocks.

Related SNA

 GTEntnum - Transaction Group count. GTEntnum returns the membership count of Transaction Group Entnum.

Related Windows

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 Transaction Groups Snapshot - Picture of the state of the Transaction Groups in the simulation.

 

ASSEMBLE

Wait for and destroy related Transactions.

ASSEMBLE A

Operand

A - Transaction count. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

ASSEMBLE 2

This is the simplest way to use the ASSEMBLE Block. The first Transaction of an Assembly Set (see Section 9.3) is caused to wait when it enters an ASSEMBLE Block. When another Transaction in the same Assembly Set enters the Block, it is destroyed and the waiting Transaction is allowed to continue.

 

Action

When a Transaction enters an ASSEMBLE Block, the Match Chain of the Block is searched for a waiting Transaction of the same Assembly Set. If there are no other members of the same Assembly Set present, the A Operand is evaluated, truncated, decremented by one, and saved in a storage location in the Transaction. If this number is zero, the Transaction immediately attempts to enter the Next Sequential Block. Otherwise the Transaction is placed on a queue attached to the ASSEMBLE Block called the Match Chain to await the arrival of other members of its Assembly Set.

When a Transaction enters an ASSEMBLE Block, if a waiting Transaction is found, the entering Transaction is destroyed and the Transaction count that was saved in the chained Transaction is reduced by one. When this count becomes 0, the waiting Transaction is removed from the Match Chain. If this Transaction has not been preempted at any Facility, it attempts to enter the Next Sequential Block. When it does so, it is scheduled behind active Transactions of the same priority.

Preempted Transactions which complete an assembly at an ASSEMBLE Block are not permitted to leave the Block until all preemptions have been cleared. More discussion of the preemption mechanism can be found in Section 9.4. Preempted Transactions which have been removed from the Match Chain do not participate in later assemblies even though they remain in the ASSEMBLE Block.

ASSEMBLE Blocks differ from GATHER Blocks in that succeeding Transactions are destroyed at an ASSEMBLE.

Special Restriction

 Transactions which are currently preempted are not permitted to leave ASSEMBLE Blocks.

Refuse Mode

A Transaction is never refused entry to an ASSEMBLE Block.

Related Blocks

 ADOPT - Set the Assembly Set of the Active Transaction.

 GATHER - Wait for members of an Assembly Set.

 MATCH - Wait for Assembly Set member.

 SPLIT - Create Transactions in the same Assembly Set.

Related SNAs

 A1 - Assembly Set. Return the Assembly Set of the Active Transaction.

 MBEntnum - Match at Block. MBEntnum returns a 1 if there is a Transaction at Block Entnum which is in the same Assembly Set as the Active Transaction. MBEntnum returns a 0 otherwise.

Related Windows

 Blocks Window - Online view of Block dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

ASSIGN

ASSIGN Blocks are used to place or modify a value in a Transaction Parameter.

ASSIGN A,B,C

Operands

A - Parameter number of the Active Transaction. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter, followed by +, -, or Null.

B - Value. Required. the operand must be Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Function number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

 

Examples

ASSIGN 2000,150.6

This is the simplest way to use the ASSIGN Block. The value 150.6 is assigned to Parameter number 2000 of the entering Transaction. If no such Parameter exists, it is created.

ASSIGN TEXT,"Look on my works, ye Mighty, and despair."

In this example, a string is assigned to the Parameter of the Active Transaction named TEXT. If no such Parameter exists, it is created.

ASSIGN 2000+,-3

In this example, the [+] following Operand A indicates that the value of Operand B is to be added to the original Parameter value. This Block adds a -3 to the value contained in Transaction Parameter 2000. If there is no such Transaction Parameter, one is created and initialized to 0 before the addition. In this case, the value of the Transaction Parameter becomes -3.

 

ASSIGN 2000-,-3

In this example, the [-] following Operand A indicates that the value of Operand B is to be subtracted from to the original Parameter value. This Block subtracts a -3 from the value contained in Transaction Parameter 2000. If there is no such Transaction Parameter, one is created and initialized to 0 before the subtraction. Then value of the Transaction Parameter becomes 3.

 

Action

When a Transaction enters an ASSIGN Block, the value of the Transaction Parameter identified in the A Operand is set according to the B and C operands. A Transaction Parameter is created if necessary.

You may assign, add to, or subtract from the numeric equivalent of the Transaction Parameterís value. If there is no C Operand, Operand B is evaluated and is used as the new value, or its numeric equivalent is used as the increment or decrement. Addition and subtraction are specified by a + or - suffix immediately following the A Operand. If there is no such suffix, Operand B is evaluated and the result is given to the value of the Transaction Parameter.

Optionally, Operand C may be used to determine the number of a function, here called a "Function Modifier". If specified, the function is evaluated, multiplied by the numerical equivalent of the evaluated B Operand, and the result is added, subtracted, or assigned to the value of the Transaction Parameter depending on the optional suffix of the A Operand. Notice that Operand C specifies a Function Entity number or name (do not precede it with an FN or FN$). If an FN class SNA is used, the GPSS Function is evaluated and the result is used to specify a second GPSS Function which is then evaluated.

Special Restriction

 A must be positive, but may be followed by a + or - suffix.

Refuse Mode

A Transaction is never refused entry to an ASSIGN Block.

Related SNA

 PParameter or *Parameter - Parameter value. PParameter returns the value of Parameter Parameter. (note: e.g. P1 or *1 or P$NAME will yield the value in the Parameter 1 in the first two cases and the Parameter called NAME in the final case.)

Related Window

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 

BUFFER

A BUFFER Block places the Active Transaction on the Current Events Chain behind its priority peers.

BUFFER

Operands

None.

 

Example

BUFFER

This example creates a Block which gives Transactions other than the Active Transaction a chance to be scheduled.

 

Action

When a Transaction enters a BUFFER Block, it is placed on the Current Events Chain behind Transactions of equal priority.

The Transaction scheduler tries to move the Active Transaction as far as it can in the simulation. In effect, the Transaction scheduler removes the Active Transaction from the CEC, calls the routine for the Next Sequential Block (NSB), and unless something extraordinary occurs, replaces the Transaction on the CEC IN FRONT of its peers (i.e. same priority) on the CEC. This replacement is modified by PRIORITY and BUFFER Blocks. After a Transaction enters a BUFFER Block, it is replaced BEHIND its peers on the CEC. A more detailed discussion of Transaction scheduling is in Chapter 9.

BUFFER Blocks are used to allow newly reactivated Transactions to get ahead of the Active Transaction. It is a common occurrence that the Active Transaction enters a Block which triggers an event which must proceed to completion before the Active Transaction should proceed. It may be necessary to follow such Blocks by BUFFER Blocks in order to allow reactivated Transaction(s) to proceed immediately in the simulation. Alternately, the reactivated Transactions could be given a higher priority.

Refuse Mode

A Transaction is never refused entry to a BUFFER Block.

Related Windows

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

CLOSE

A CLOSE Block terminates a Data Stream and retrieves its error code.

CLOSE A,B,C

Operands

A - Transaction Parameter. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

B - Data Stream. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter. The default is 1.

C - Alternate Destination. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

CLOSE Error_Parm,2

In this example, the CLOSE Block terminates the operation of Data Stream 2 and frees all the resources associated with it. The internal error code of Data Stream 2 is placed in Parameter Error_Parm of the Active Transaction.

Action

A CLOSE Block shuts down a Data Stream and retrieves its error code.

If Operand A is used, it is evaluated numerically, truncated, and used as the number of a Parameter of the Active Transaction. If no such Parameter exits, one is created. The error code of the Data Stream is placed in this Parameter.

If Operand B is used, it is evaluated numerically, truncated, and used as the entity number of the Data Stream. The result must be a positive integer. If Operand B is not used, Data Stream number 1 is closed.

If Operand C is used, it is evaluated numerically, truncated, and used as the Block Entity number of an Alternate Destination Block. When the error code of the Data Stream is nonzero, the Active Transaction proceeds to the Alternate Destination Block after it enters the CLOSE Block.

Chapter 4 (4.16) contains a full discussion of Data Streams, including the error code descriptions, under the Section entitled Data Streams.

Blocking Condition

The simulation is blocked while CLOSE retrieves the error code.

Special Restrictions

 A and B, if specified, must be positive.

 C, if specified, must be a valid Block location in the simulation.

Refuse Mode

A Transaction is never refused entry to a CLOSE Block.

Related Blocks

 OPEN - Create a Data Stream.

 READ - Retrieve a text line from a Data Stream.

 WRITE - Send a text line to a Data Stream.

 SEEK - Set the Current Line Position of a Data Stream.

 

 

COUNT

A COUNT Block places an entity count into a Parameter of the Active Transaction.

COUNT O A,B,C,D,E

Operands

O - Conditional operator or logical operator. These choices are explained below. Required. The operator must be FNV, FV, I, LS, LR, NI, NU, SE, SF, SNE, SNF, SNV, SV, U, E, G, GE, L, LE, MIN, MAX, or NE.

A - Parameter number to receive count. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Number or name of entity at lower end of range. The entity number of the first entity to be tested. The entity type is implicitly specified by the logical operator or by Operand E. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Number or name of entity at upper end of range. The entity number of the last entity to be tested. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Reference value for E Operand. Required only when in Conditional Mode. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

E - SNA class name. Entity attribute specifier for Conditional Mode tests. Required only for Conditional Mode. The type of SNA implies the entity type. You do not specify the entity number in Operand E. This is done automatically as the entity number range is searched. You may use any entity SNA class. The operand must be Null or entitySNAclass.

Examples

COUNT SF FullCount,Warehouse1,Warehouse13

In this example, the number of full Storage Entities whose entity numbers fall between Warehouse1 and Warehouse13 and will be stored in the Transaction Parameter named FullCount. Normally, the Storage Entity Labels should be assigned contiguous integers in a set of EQU Commands.

COUNT E EmptyCount,FirstQueue,LastQueue,0,Q

In this example, the COUNT Block operates in Conditional Mode. Operand E specifies SNA class Q, which refers to a Queue Entity. Each Queue Entity with entity number between that of FirstQueue and LastQueue is tested. Any such queue entity whose current content is 0 is counted. EmptyCount is the name of the Parameter of the Active Transaction to receive the count of "empty" Queue Entities in the specified range. Normally, the Queue Entity Labels should be assigned contiguous integers in a set of EQU Commands.

 

Action

When the COUNT Block is entered, the entity specified by Operand B is tested. If the entity does not exist and does not require a separate Command for its definition, a new entity is created. Thereafter, each entity in the range indicated by operands B and C is tested. An SNA is built automatically for each entity. The SNA class used to build the SNA is taken from Operand E or is specified by the logical operator.

A COUNT Block operates in either Logical Mode or in Conditional Mode, depending on whether a logical operator or a conditional operator is used.

When a logical operator is used (defined below), Operands A, B, and C are used. The condition specified by the logical operator is tested for the entities whose numbers fall between B and C. The count of entities in that condition is placed in the Parameter of the entering Transaction whose number or name is given by Operand A. If the Parameter does not exist, it is created. The entity type is implied by the logical operator.

When a conditional operator is used, Operands A, B, C, D, and E are used. Operands A, B, C, are used to specify the target Parameter, and the range of entity numbers, as above. But now the conditional operator specifies the relationship between operands D and E that must hold for the entity to be counted.

In Conditional Mode, the SNA class is combined with the entity specifications in order to build an SNA. The entity type implied by each SNA class is given in Section 3.4. The complete SNA is built from this class and the number of the entity being tested. Each such SNA is evaluated for each entity and compared to the reference value in Operand D. If the condition set up in the conditional operator is met, the entity is counted.

Logical Operators

Either a conditional operator or a logical operator is required. The logical operator may be FNV, FV, I, LS, LR, NI, NU, SE, SF, SNE, SNF, SNV, SV, or U. When the logical operator is true, the entity being tested is counted. The conditions are defined as follows:

 FNV - The Facility must be unavailable in order to be counted.

 FV - The Facility must be available in order to be counted.

 I - The Facility must be currently interrupted (preempted) in order to be counted.

 LS - The Logicswitch Entity must be set (in the "on" state) in order to be counted.

 LR - The Logicswitch Entity must be reset (in the "off" state) in order to be counted.

 NI - The Facility must NOT be currently interrupted (preempted) in order to be counted.

 NU - The Facility must not be in use in order to be counted.

 SE - The Storage must be empty in order to be counted.

 SF - The Storage must be full in order to be counted.

 SNE - The Storage must NOT be empty in order to be counted.

 SNF - The Storage must NOT be full in order to be counted.

 SNV - The Storage must NOT be available in order to be counted.

 SV - The Storage must be available in order to be counted.

 U - The Facility must be in use in order to be counted.

 

Conditional Operators

Either a conditional operator or a logical operator is required. The conditional operator may be E, G, GE, L, LE, MAX, MIN, or NE. The conditions are defined as follows:

 E - The value of the automatic SNA must be equal to the reference value specified by Operand D for the entity to be counted.

 G - The value of the automatic SNA must be greater than the reference value specified by Operand D for the entity to be counted.

 GE - The value of the automatic SNA must be greater than or equal to the reference value specified by Operand D for the entity to be counted.

 L - The value of the automatic SNA must be less than the reference value specified by Operand D for the entity to be counted.

 LE - The value of the automatic SNA must be less than or equal to the reference value specified by Operand D for the entity to be counted.

 MAX - The value of the automatic SNA must be equal to the greatest of all such SNAs, for the entity to be counted.

 MIN - The value of the automatic SNA must be equal to the least of all such SNAs, for the entity to be counted.

 NE - The value of the automatic SNA must be unequal to the reference value specified by Operand E for the entity to be counted.

Special Restrictions

 D and E are required if O is a conditional operator.

 When evaluated, C must be greater than or equal to B.

Refuse Mode

A Transaction is never refused entry to a COUNT Block.

Related Windows

 Facilities Window - Online view of Facility Entity dynamics.

 Logicswitches Window - Online view of Logicswitch Entity dynamics.

 Storages Window - Online view of Storage Entity dynamics.

 

DEPART

A DEPART Block registers statistics which indicate a reduction in the content of a Queue Entity.

DEPART A,B

Operands

A - Queue Entity name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

B - Number of units by which to decrease content of the Queue Entity. Default value is 1. Optional. The operand must be Null, Name, PosInteger, String, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

DEPART WaitingLine

In this example the content of the Queue Entity named WaitingLine is reduced by one and the associated statistics accumulators are updated.

 

Action

When a Transaction enters a DEPART Block, Operand A is evaluated, truncated, and used to find the Queue Entity with that number. The Queue Entity is created if necessary. If a Queue Entity is created, the attempt to decrement the content of the Queue Entity will cause an Error Stop. Manual Simulation can be used to alter the Queue Entity content interactively.

Operand B specifies the value to be used to decrease the content of the Queue Entity. If B was specified, Operand B is evaluated numerically, truncated, and used as the result. If B was not specified, the value of 1 is used.

Finally, the statistics accumulated on behalf of the Queue Entity are updated. If Qtable Entities have been defined for this same Queue Entity, they are also updated.

Special Restrictions

 A and B must be positive, if specified.

 If the content of the Queue Entity is about to become negative, an Error Stop occurs.

Refuse Mode

A Transaction is never refused entry to a DEPART Block.

Related SNAs

 QEntnum - Current content of queue entity. The current count value of Queue Entity Entnum.

 QAEntnum - Average queue content. The time weighted average count for Queue Entity Entnum.

 QCEntnum - Total queue entries. The sum of all queue entry counts for Queue Entity Entnum.

 QMEntnum - Maximum queue content. The maximum count (high water mark) of Queue Entity Entnum.

 QTEntnum - Average queue residence time. The time weighted average of the count for Queue Entity Entnum.

 QXEntnum - Average queue residence time excluding zero entries. The time weighted average of the count for Queue Entity Entnum not counting entries with a zero residence time.

 QZEntnum - Queue zero entry count. The number of entries of Queue Entity Entnum with a zero residence time.

Related Window

 Queues Window - Online view of Queue Entity dynamics.

 

DISPLACE

A DISPLACE Block moves any Transaction.

DISPLACE A,B,C,D

Operands

A - Transaction number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

B - Displaced Transaction destination. Block name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Parameter number. Parameter of displaced Transaction to receive residual time if preempted Transaction is removed from FEC. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Alternate destination for the Active Transaction. Block name or number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

DISPLACE X$Culprit,Compensate,Residual,NotCaught

In this example, the DISPLACE Block moves the Transaction whose number is kept in the Savevalue named Culprit. If the target Transaction exists, it is sent to the Block labeled Compensate as its Next Sequential Block. If it was residing on the Future Events Chain, any time left until its reentry into the simulation is calculated and stored in the Parameter named Residual of the displaced Transaction. If the Transaction was on the FEC and no such Parameter exists, it is created. If the target Transaction does not exist, the Active Transaction moves to the alternate destination Block labeled NotCaught, after entering the DISPLACE Block.

Action

A DISPLACE Block moves any Transaction in the simulation to any Block. The displaced Transaction is removed from Transaction chains, as discussed below, and is scheduled to enter the destination Block.

When a Transaction enters a DISPLACE Block, Operand A is evaluated numerically, truncated, and used to find the Transaction to be displaced. If that Transaction does not exist, processing ceases, and the Active Transaction is sent to the Alternate Destination specified by Operand D, if any.

If the Transaction exists, it is given the new Block destination specified by Operand B.

If the displaced Transaction is on the FEC, it is removed from it and the residual time duration is calculated as the time which the Transaction is scheduled to come off the FEC minus the current time. If the C Operand is used, the residual time is saved in a Transaction Parameter. If no such Parameter exists and Operand C is used, a new Parameter is created.

When a Transaction is displaced, it is given a new Block destination and is dequeued from:

 FEC

 PENDING (INTERRUPT-MODE PREEMPT) CHAINS

 DELAY (MAJOR PRIORITY) CHAINS

 USER CHAINS

 RETRY CHAINS

and not dequeued from:

 CEC

 INTERRUPT (PREEMPTED) CHAINS

 GROUP CHAINS

When a Transaction is displaced, preemptions at Facilities are not cleared.

Refuse Mode

A Transaction is never refused entry to a DISPLACE Block.

Related SNA

 XN1 - Transaction number of the Active Transaction.

Related Windows

 Blocks Window - Online view of Block dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

Related Library Procedures

 QueryXNExist - determine the existence of a Transaction.

 QueryXNParameter - retrieve the value of a Transaction Parameter.

 QueryXNAssemblySet - retrieve the Assembly Set of a Transaction.

 QueryXNPriority - retrieve the priority of a Transaction.

 QueryXNM1 - retrieve the Mark Time of a Transaction.

 

ENTER

When a Transaction attempts to enter an ENTER Block, it either takes or waits for a specified number of storage units.

ENTER A,B

Operands

A - Storage Entity name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

B - Number of units by which to decrease the available storage capacity. Default value is 1. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

ENTER Toolkit,2

In this example the Active Transaction demands 2 storage units from the storage units available at the Storage Entity named Toolkit. If there are not enough storage units remaining in the Storage Entity, the Transaction comes to rest on the Delay Chain of the Storage Entity.

 

Action

When a Transaction enters an ENTER Block, Operand A is evaluated and used to find the Storage Entity with that number. If the Storage Entity does not exist, an Error Stop occurs. Storage entities must be defined by a STORAGE Command.

If the Storage Entity exists, Operand B is used to determine the storage demand. If B was specified, Operand B is evaluated, truncated, and used as the result. If B was not specified, the value of 1 is used.

If the Storage Entity is in the available state, and if there are enough storage units to satisfy the demand, the Transaction is allowed to enter the ENTER Block and the demand is granted by reducing the current storage units by the amount of the demand. Otherwise, the Transaction comes to rest on the Delay Chain of the Storage Entity in priority order.

When storage units are freed by a LEAVE Block, a "first-fit-with-skip" discipline is used to choose the next Transaction(s) to be allowed entry into the ENTER Block. Any such entry is permitted before the Active Transaction leaves the LEAVE Block. This prevents "line-bucking".

When a Transaction enters an ENTER or LEAVE Block, the statistics accumulated on behalf of the Storage Entity are updated.

Special Restrictions

 A must be positive.

 B must be nonnegative.

 A request for more storage than exists will result in an Error Stop. (e.g. a B Operand that is larger than the defined size of the STORAGE named in Operand A.)

Refuse Mode

 The Active Transaction is refused entry to the ENTER Block if its storage demand cannot be met.

 The Active Transaction is refused entry to the ENTER Block if the Storage Entity is in the unavailable state.

When a Transaction is refused entry, its Delay Indicator is set and remains so until the Transaction enters a "Simultaneous" Mode TRANSFER Block. Simultaneous Mode TRANSFER Blocks are rarely used. A BOOLEAN VARIABLE can more efficiently control the coordination of the state of a number of resources when used in a TEST Block.

Related Command

A Storage Entity must be defined in a STORAGE Command before it can be updated by an ENTER Block. The STORAGE Command must exist in the model, or must be sent to the Simulation Object interactively, before a Transaction can enter the ENTER Block. Any attempt to do so before the Storage Entity is defined, cases an Error Stop.

A Storage Entity can be redefined by an interactive STORAGE Command.

Related SNAs

 REntnum - Unused storage capacity. The storage content (or "token" spaces) available for use by entering Transactions at Storage Entity Entnum.

 SEntnum - Storage in use. SEntnum returns the amount of storage content (or "token" spaces) currently in use by entering Transactions at Storage Entity Entnum.

 SAEntnum - Average storage in use. SAEntnum returns the time weighted average of storage capacity (or "token" spaces) in use at Storage Entity Entnum.

 SCEntnum - Storage use count. Total number of storage units that have been entered in (or "token" spaces that have been used at) Storage Entity Entnum.

 SEEntnum - Storage empty. SEEntnum returns 1 if Storage Entity Entnum is completely unused, 0 otherwise.

 SFEntnum - Storage full. SFentnum returns 1 if Storage Entity Entnum is completely used, 0 otherwise.

 SREntnum - Storage utilization. The fraction of total usage represented by the average storage in use at Storage Entity Entnum. SREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 SMEntnum - Maximum storage in use at Storage Entity Entnum. The "high water mark".

 STEntnum - Average holding time per unit at Storage Entity Entnum.

 SVEntnum - Storage in available state. SVEntnum returns 1 if Storage Entity Entnum is in the available state, 0 otherwise.

Related Window

 Storages Window - Online view of Storage Entity dynamics.

 

EXAMINE

An EXAMINE Block may be used to test for membership in a Numeric Group or a Transaction Group.

EXAMINE A,B,C

Operands

A - Group number. Group whose members will be examined. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Numeric Mode only. The value to be tested for membership in the Numeric Group. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Block number. Alternate destination for Active Transaction if no membership is found. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Examples

EXAMINE ValidColors,P$Color,NotCorrectColor

In this simple example, if the Numeric Group named ValidColors does not include the value contained in the Transaction Parameter named Color, the Active Transaction proceeds to the Block location NotCorrectColor. If the value is a Numeric Group member, the Active Transaction proceeds to the Next Sequential Block (NSB).

 

EXAMINE ValidXNs,,NotValidXN

In this example, if the Active Transaction is not a member of the Transaction Group named ValidXNs, the Active Transaction proceeds to the Block location NotValidXN. If the Transaction is a Transaction Group member, it proceeds to the Next Sequential Block (NSB).

 

Action

An EXAMINE Block operates in either "Numeric Mode" or "Transaction Mode". If the B Operand is used, the EXAMINE Block operates in Numeric Mode. In this case the value of Operand B is tested for membership in the Numeric Group. If the B Operand is not used, the EXAMINE operates in Transaction Mode. Then, It is the Active Transaction which is tested for membership in a Transaction Group.

When a Transaction enters an EXAMINE Block, Operand A is evaluated and the appropriate Group entity is found. If there is no such Group, one is created.

If the B Operand is used, it is evaluated numerically and the result is tested for membership in the Numeric Group. If Operand B is not used, the Active Transaction is tested for membership in the Transaction Group specified by the A Operand.

There is some loss of efficiency when non-integers are used in Numeric Groups.

If the membership test fails, Operand C is evaluated, truncated, and used as the destination Block number for the Active Transaction. If the membership test is successful, the Active Transaction proceeds to the Next Sequential Block (NSB).

Special Restrictions

 A and C must be positive.

 C must be a Block location in the simulation.

Refuse Mode

A Transaction is never refused entry to an EXAMINE Block.

Related Blocks

Transactions and numbers are added to Groups by JOIN Blocks. Transactions in Transaction Groups can be referenced by ALTER, EXAMINE, REMOVE, and SCAN Blocks. Numbers in Numeric Groups can be referenced by EXAMINE and REMOVE Blocks.

Related SNAs

 GNEntnum - Numeric Group Count. GNEntnum returns the membership count of Numeric Group Entnum.

 GTEntnum - Transaction Group Count. GTEntnum returns the membership count of Transaction Group Entnum.

Related Windows

 Numeric Groups Snapshot - Picture of the state of the Numeric Groups in the simulation.

 Transaction Groups Snapshot - Picture of the state of the Transaction Groups in the simulation.

 

EXECUTE

The EXECUTE Block can cause any Block routine in the simulation to be done on behalf of the Active Transaction.

EXECUTE A

Operand

A - Block number. The name or number of the Block to be "performed". required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

Example

EXECUTE P$ActiveBlock

This EXECUTE Block will cause the Block, whose number is in the Parameter named ActiveBlock, to be executed with respect to the Active Transaction.

 

Action

When a Transaction enters an EXECUTE Block, the A Operand is evaluated and is used to find the Block with that number or name. Then the Block routine associated with the target Block is done on behalf of the Active Transaction.

If the Active Transaction is refused entry to the target Block, it remains in the EXECUTE Block.

After the target Block routine is performed, the Active Transaction is normally scheduled for the Block following the EXECUTE Block. However, if the target Block schedules an alternate destination for the Active Transaction, that Block, and not the EXECUTE Blockís next sequential Block, is scheduled.

Special Restrictions

 A must be a Block location in the simulation.

 An EXECUTE Block cannot act on another EXECUTE Block.

Refuse Mode

An EXECUTE Block never refuses entry to a Transaction.

Related Window

 Blocks Window - Online view of Block dynamics.

 

FAVAIL

A FAVAIL Block ensures that a Facility Entity is in the available state.

FAVAIL A

Operand

A - Facility number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

Example

FAVAIL Teller1

This Block, when entered by an Active Transaction, will ensure that the Facility Entity named Teller1 is in the available state.

Action

A FAVAIL Block ensures that a Facility Entity is in the available state. If the Facility Entity was previously idle, the FAVAIL Block tries to give ownership to a waiting Transaction. This is discussed in more detail in Chapter 9.

If the Facility Entity was previously available, FAVAIL has no effect.

FAVAIL cancels the affects of FUNAVAIL on the Facility Entity, but does not affect displaced Transactions.

Refuse Mode

A Transaction is never refused entry to a FAVAIL Block.

Related Block

 FUNAVAIL - Place Facility Entity in the unavailable state.

Related SNAs

The SNAs associated with Facilities are:

 FEntnum - Facility busy. If Facility Entity Entnum is currently busy, FEntnum returns 1. Otherwise FEntnum returns 0.

 FCEntnum - Facility capture count. The number of times Facility Entity Entnum has become owned by a Transaction.

 FIEntnum - Facility Entnum interrupted. If Facility Entity Entnum is currently preempted, FIEntnum returns 1. Otherwise FIEntnum returns 0.

 FREntnum - Facility utilization. The fraction of time Facility Entity Entnum has been busy. FREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 FTEntnum - Average Facility holding time. The average time Facility Entity Entnum is owned by a capturing Transaction.

 FVEntnum - Facility in available state. FV Entnum returns 1 if Facility Entity Entnum is in the available state, 0 otherwise.

Related Window

 Facilities Window - Online view of Facility Entity dynamics.

 

FUNAVAIL

FUNAVAIL Blocks are used to make a Facility Entity unavailable for ownership by Transactions.

FUNAVAIL A,B,C,D,E,F,G,H

Operands

A - Facility name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

B - REmove or COntinue Mode for owning Transaction. Optional. The operand must be RE, CO, or Null.

C - Block number. New Block for Transaction owning the Facility Entity. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Parameter number. Parameter to receive residual time if owning Transaction is removed from FEC. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

E - REmove or COntinue Mode for preempted Transactions. Optional. The operand must be RE, CO or Null.

F - Block number. New Block for Transactions preempted at the Facility Entity. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

G - REmove or COntinue Mode for Transactions pending or delayed at the Facility Entity. Optional. The operand must be RE, CO or Null.

 

H - Block number. New Block for Transactions pending or delayed at the Facility Entity. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

 

Examples

FUNAVAIL Teller1

This is the simplest way to use the FUNAVAIL Block. The Facility Entity named Teller1 is "frozen" during the unavailable period. Several types of Transactions other than the Active Transaction are affected. If an owning Transaction is in an ADVANCE Block, it will be rescheduled on the FEC automatically when the Facility again becomes available. The time remaining in the ADVANCE Block (i.e. the "residual time") is calculated and saved automatically when the Transaction is removed from the FEC. The residual time becomes the time increment when the Transaction is rescheduled on the FEC. Other Transactions delayed or pending at TELLER1 will not be able to move during the unavailable period.

 

FUNAVAIL TELLER,RE,TLR2,300,RE,MGR,CO

In this example, the Facility Entity TELLER is made unavailable. This means that newly arriving Transactions will be delayed. The Transactions at or preempted at the Facility TELLER are dealt with according to operands B-H. If the Transaction which owns Facility TELLER is on the FEC, it is dequeued and the residual time is saved in its Parameter number 300. The owning Transaction is displaced and sent to the Block named TLR2. Transactions currently preempted at Facility TELLER are removed from contention and sent to Block named MGR. Since Operand G is CO, Transactions currently delayed at Facility TELLER are allowed to own the Facility, even though itís in the unavailable state.

 

Action

The complexity of the FUNAVAIL Block is due to the three classes of Transactions which must be dealt with:

1. the owning Transaction (operands B-D),

2. preempted Transactions on the Interrupt Chain (operands E-F), and

3. delayed Transactions on the Delay Chain or Pending Chain (operands G-H).

A FUNAVAIL Block allows you to put a Facility "out of action" and to control the fate of Transactions waiting for, using, or preempted at the Facility Entity. Transactions arriving during the unavailable period will be delayed and not be granted ownership. A FUNAVAIL Block has no effect if the Facility is already unavailable.

When the REmove option is used, the Transactions are removed from contention for the Facility If the REmove option is used for pending and delayed Transactions, i. e. if G is RE, then H must be used to redirect the Transactions.

When the COntinue option is used, the Transactions on the specific Facility chain may continue to own the Facility, even during the unavailable period. In this case, Facility utilization statistics are adjusted to include this time.

When an alternate destination Block is used, the Transactions are displaced from their current context and redirected to the new Block. Delayed and pending Transactions, which are controlled by operands G and H, cannot be redirected without also using the REmove option. The owning Transaction, controlled by operands B through D, and preempted Transactions, controlled by operands E and F, can remain in contention for the Facility and yet be displaced to a new destination. This is done by specifying an alternate destination without using the corresponding RE option.

When RE is not used in Operand B, any owning Transaction becomes preempted at this Facility. Such Transactions cannot leave ASSEMBLE, GATHER, or MATCH Blocks or enter (nonzero) ADVANCE Blocks until all preemptions are cleared.

When a Transaction is displaced by using the C, F, or H Operand, it is given a new Block destination and is dequeued from:

 FEC

 PENDING (waiting to preempt) CHAINS

 DELAY (waiting to seize) CHAINS

 USER CHAINS

 RETRY CHAINS

and not dequeued from:

 CEC

 INTERRUPT (preempted) CHAINS of other Facilities

 GROUP CHAINS

When a Transaction is displaced from its present context anywhere in the model, by using an alternate destination, it is removed from any Blocking conditions but preemptions are not cleared. Such a displaced Transaction is scheduled to enter the Block specified in Operand C of the FUNAVAIL Block. When an owning Transaction RELEASEs or RETURNs a Facility, the next owner is chosen from the head of the Pending Chain, the Interrupt Chain, or the Delay Chain, in that order.

TheOwning Transaction

Operands B-D are used to control the owning Transaction.

If B is CO, the owning Transaction is not removed from ownership. It may, however, be given a new destination with the C Operand.

If B is RE, the owning Transaction is removed from contention for the Facility. This means that the Transaction may continue to circulate in the simulation without restrictions due to a preemption at this Facility (there may be outstanding preemptions at other Facilities, however). It also means that the owning Transaction must not attempt to RETURN or RELEASE the Facility. The C Operand must be used to redirect the course of such a Transaction.

If B is Null, the owning Transaction is preempted and placed on the Interrupt Chain of the Facility. If it was taken from the FEC and the C Operand is not used, it will be automatically restored to the FEC using the automatically saved residual time when the Facility again becomes available.

The C Operand may be used regardless of Operand B. It causes the owning Transaction to be displaced, and gives it a new destination Block. If you choose to return the Transaction to the FEC, having used the C Operand, you must explicitly route the Transaction to an ADVANCE Block. The D Operand causes the residual time to be saved in a Parameter of the owning Transaction. The residual time value is then available for explicit rescheduling when you use the Parameter value as Operand A of an ADVANCE Block.

Preempted Transactions

Operands E and F are provided to control the fates of Transactions currently preempted at this Facility.

If E is CO, preempted Transactions are not removed from contention for the Facility, and may own the Facility during any unavailable period. Preempted Transactions may be given a new destination with the F Operand.

If E is RE, preempted Transactions are removed from contention for the Facility. This means that the Transaction may continue to circulate in the simulation without restrictions due to a preemption at this Facility (there may be outstanding preemptions at other Facilities, however). It also means that preempted Transactions must not attempt to RETURN or RELEASE the Facility. Optionally, the F Operand is available to redirect the course of such a Transaction.

If E is Null, preempted Transactions are left on the Interrupt Chain of the Facility, and cannot be granted ownership of the Facility during the unavailable period.

The F Operand may be used regardless of Operand E. It causes preempted Transactions to be displaced, and gives them a new destination Block. Preempted Transactions may not exist on the FEC, so no residual time options are relevant. If E is Null, the preemption is not cleared for displaced Transactions.

Pending Interrupt Mode Transactions

Operands G and H are provided to control the fates of Transactions on the Pending Chain (i.e. pending Interrupt Mode PREEMPTs) or the Delay Chain.

If G is CO, delayed Transactions are not removed from contention for the Facility, and may own the Facility during any unavailable period.

If G is RE, delayed Transactions are removed from contention for the Facility and allowed to circulate in the simulation. These Transactions must not attempt to RETURN or RELEASE the Facility. The H Operand must be used to redirect the course of such Transactions.

If G is Null, delayed Transactions are left on the Delay Chain or the Pending Chain of the Facility, and cannot be granted ownership of the Facility during the unavailable period. The use of Operand H is invalid when G is Null.

Special Restrictions

 If B is RE, C must be used.

 If H is used, G must be RE.

 If G is RE, H must be used.

Refuse Mode

A Transaction is never refused entry to a FUNAVAIL Block.

Related Block

 FAVAIL - Place Facility in the available state.

Related SNAs

 FEntnum - Facility busy. If Facility Entnum is currently busy, FEntnum returns 1. Otherwise FEntnum returns 0.

 FCEntnum  - Facility capture count. The number of times Facility Entnum has become owned by a Transaction.

 FIEntnum - Facility Entnum interrupted. If Facility Entnum is currently preempted, FIEntnum returns 1. Otherwise FIEntnum returns 0.

 FREntnum - Facility utilization. The fraction of time Facility Entnum has been busy. FREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 FTEntnum - Average Facility holding time. The average time Facility Entnum is owned by a capturing Transaction.

 FVEntnum - Facility in available state. FV Entnum returns 1 if Facility Entnum is in the available state, 0 otherwise.

Related Windows

 Facilities Window - Online view of Facility Entity dynamics.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

GATE

A GATE Block alters Transaction flow based on the state of an entity.

GATE O A,B

Operands

O - Conditional operator. Condition required of entity to be tested for successful test. Required. The operator must be FNV, FV, I, LS, LR, M, NI, NM, NU, SE, SF, SNE, SNF, SNV, SV, or U.

A - Entity name or number to be tested. The entity type is implied by the conditional operator. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Destination Block number when test is unsuccessful. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, SNA*Parameter.

 

Examples

GATE SNF MotorPool

In this example of a "Refuse Mode" GATE Block, the Active Transaction enters the GATE Block if the Storage Entity named MotorPool is not full (i. e. if at least 1 unit of storage is available). If the Storage is full, the Active Transaction is blocked until 1 or more storage units become available.

GATE SNE MotorPool,CupboardIsBare

In this example of an "Alternate Exit Mode" GATE Block, the Active Transaction always enters the GATE Block. If the Storage Entity named MotorPool is not empty (i. e. if at least 1 unit of storage is in use) the Transaction proceeds to the NSB. If the Storage is empty (unsuccessful test), the Active Transaction is scheduled to enter the Block at the location named CupboardIsBare.

Action

A GATE Block operates in either "Refuse Mode" or "Alternate Exit Mode".

If Operand B is not used, the GATE Block operates in Refuse Mode. When a Transaction attempts to enter a Refuse Mode GATE Block, and the test is unsuccessful, the Transaction is blocked until the test is repeated and is successful. If the test is successful, the Active Transaction enters the GATE Block and then proceeds to the Next Sequential Block.

Blocked Transactions are placed on the Retry Chain of the tested entity. When the state of any of the entity changes, the blocked Transaction is reactivated, the test specified by the GATE block is retried, and if successful, the Transaction is permitted to enter the GATE Block. However, the integration of User Variables does not cause blocked Transactions to be reactivated. You should use the thresholds in an INTEGRATE Command if you need to be notified about the level of one or more continuous variables. This is discussed further in Chapter 1, in the Section entitled Continuous Variables.

If Operand B is used, the GATE Block operates in Alternate Exit Mode. When a Transaction attempts to enter such a GATE Block, and the test is unsuccessful, the Transaction enters the GATE Block, is scheduled for the alternate destination Block specified by the B Operand, and is placed on the Current Events Chain in front of its priority peers. If the test is successful, the Active Transaction enters the GATE Block and then proceeds to the Next Sequential Block.

Conditional Operators

The conditional operator is required. It may be FNV, FV, I, LS, LR, M, NI, NM, NU, SE , SF, SNE, SNF, SNV, SV, or U. When the condition is true, the Transaction enters the GATE Block and proceeds to the Next Sequential Block. The conditions are defined as follows:

∑ FNV - The Facility specified implicitly by Operand A must be unavailable for a successful test.

 FV - The Facility specified implicitly by Operand A must be available for a successful test.

 I - The Facility specified implicitly by Operand A must be currently interrupted for a successful test.

 LS - The Logicswitch entity specified implicitly by Operand A must be in the "set" state for a successful test.

 LR - The Logicswitch entity specified implicitly by Operand A must be in the "reset" state for a successful test.

 M - The Match Block specified implicitly by Operand A must have a related (to the Active Transaction) Transaction waiting for a Match Condition.

 NI - The Facility specified implicitly by Operand A must be not interrupted for a successful test.

 NM - The Match Block specified implicitly by Operand A must not have a related (to the Active Transaction) Transaction waiting for a Match Condition.

 NU - The Facility specified implicitly by Operand A must not be in use for a successful test.

 SE - The Storage Entity specified implicitly by Operand A must be empty for a successful test. All storage units must not be in use.

 SF - The Storage Entity specified implicitly by Operand A must be full for a successful test. All storage units must be being used.

 SNE - The Storage Entity specified implicitly by Operand A must be not empty for a successful test. At least one storage unit must be in use.

 SNF - The Storage Entity specified implicitly by Operand A must be not full for a successful test. There must be at least one storage unit that can be used.

 SNV - The Storage Entity specified implicitly by Operand A must be in the "unavailable" state for a successful test.

 SV - The Storage Entity specified implicitly by Operand A must be in the "available" state for a successful test.

 U - The Facility specified implicitly by Operand A must be in use for a successful test.

Special Restrictions

 B, if specified, must be the location of a Block in the simulation.

 GATE Blocks are extremely powerful, but they can cause a lot of computer time to be used in unsuccessful tests. You may need to arrange your simulation to reduce the frequency of unsuccessful tests. This can be done by placing Transactions with no chance of a successful test on a User Chain using LINK and UNLINK Blocks.

 The MB class of SNA should not be used alone to specify a blocking condition in a GATE Block. You should use MATCH Blocks instead.

Refuse Mode

A GATE Block operating in Refuse Mode will refuse entry to a Transaction when the test fails. The refused Transaction will be blocked until the test is successful.

When a Transaction is refused entry, its delay indicator is set and remains so until the Transaction enters a "Simultaneous" Mode TRANSFER Block. However, since the advent of the Boolean Variable in the GPSS language, it is more efficient to use a TEST Block and a Boolean Variable when it is necessary to coordinate the state of multiple entities.

Related Windows

 Blocks Window - Online view of Block dynamics.

 Facilities Window - Online view of Facility Entity dynamics.

 Logicswitches Window - Online view of Logicswitch Entity dynamics.

 Storages Window - Online view of Storage Entity dynamics.

 

GATHER

Wait for related Transactions.

GATHER A

Operand

A - Transaction count. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

GATHER 2

This is the simplest way to use the GATHER Block. The first Transaction of an Assembly Set (see Section 9.3) is caused to wait when it enters an GATHER Block. When another Transaction in the same Assembly Set enters the Block, both related Transactions are released and put on the Current Events Chain.

 

Action

When a Transaction enters a GATHER Block, the Match Chain of the Block is searched for a waiting Transaction of the same Assembly Set. If there are no other members of the same Assembly Set present, the A Operand is evaluated, truncated. decremented by one, and saved in a storage location in the Active Transaction. If this number is less than or equal to zero, the Transaction immediately attempts to enter the Next Sequential Block. Otherwise, the Transaction is placed on a special chain in the GATHER Block, called the Match Chain, to await the arrival of other members of its Assembly Set.

If the Active Transaction arrives to find other members of its Assembly Set already on the Match Chain, the Active Transaction is also placed on the chain and the Transaction count saved in the first chained Transaction is reduced by one. When this count becomes 0, all related Transactions are removed from the Match Chain. All Transactions which have not been preempted at any Facility are then placed on the CEC behind their priority peers.

Preempted Transactions which have completed an assembly at a GATHER Block are not permitted to leave the Block until all preemptions have been cleared. More discussion of the preemption mechanism can be found in Section 9.4. Preempted Transactions which have been removed from the Match Chain do not participate in later gatherings even though they remain in the GATHER Block.

GATHER Blocks differ from ASSEMBLE Blocks in that Transactions after the first are destroyed at an ASSEMBLE Block.

Special Restrictions

 A must be positive.

 Transactions which are currently preempted are not permitted to leave GATHER Blocks.

Refuse Mode

A Transaction is never refused entry to a GATHER Block.

Related Blocks

 ADOPT - Set the Assembly Set of the Active Transaction.

 ASSEMBLE - Wait for and destroy Assembly Set members.

 MATCH - Wait for Assembly Set member.

 SPLIT - Create Transactions in the same Assembly Set.

Related SNAs

 A1 - Assembly Set. Return the Assembly Set of the Active Transaction.

 MBEntnum - Match at Block. MBEntnum returns a 1 if there is a Transaction at Block Entnum which is in the same Assembly Set as the Active Transaction. MBEntnum returns a 0, otherwise.

Related Windows

 Blocks Window - Online view of Block dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

GENERATE

A GENERATE Block creates Transactions for future entry into the simulation.

GENERATE A,B,C,D,E

Operands

A - Mean inter generation time. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, or DirectSNA. You may not use Transaction Parameters.

B - Inter generation time half-range or Function Modifier. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, or DirectSNA. You may not use Transaction Parameters.

C - Start delay time. Time increment for the first Transaction. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, or DirectSNA. You may not use Transaction Parameters.

D - Creation limit. The default is no limit. Optional. The operand must be Null, Name, PosInteger, String, ParenthesizedExpression, or DirectSNA. You may not use Transaction Parameters.

E - Priority level. Optional. Zero is the default. The operand must be Null, Name, integer, String, ParenthesizedExpression, or DirectSNA. You may not use Transaction Parameters.

 

Example

GENERATE 0.1

This is the simplest way to use the GENERATE Block. This Block causes a priority zero Transaction to enter the simulation every tenth of a time unit.

 

Action

When a simulation is begun, or an interactive Command is performed, any GENERATE Block which has not been "primed" is called upon to schedule its first Transaction. Such Transactions are scheduled to enter the GENERATE Block and placed on the Future Events Chain if they have a positive time increment. Operand C can be used to specify a positive time increment for the first Transaction. Otherwise, the first time increment is calculated from operands A and B.

You cannot use Parameters in GENERATE Block operands. Newly GENERATEd Transactions do not have Parameters, and their entry into such a GENERATE Block would cause an Error Stop.

Before the new Transaction is created, Operand D is evaluated numerically to see if all the Transactions desired have been created. If the creation limit has not been exceeded, processing continues. The GENERATE Block then creates the new Transaction assigning it the next Transaction number, the priority from the E Operand, and the Transaction Mark Time is assigned the value in the absolute system clock. The new Transaction represents a new Assembly Set with one member.

The inter arrival time for the new Transaction is calculated from the A, B, and C operands. If only the A Operand is specified, it is evaluated numerically and used as the time increment. If the A and B operands are present, and B does not specify a function, both A and B are evaluated numerically and a random number between A-B and A+B, inclusively, is used as the time increment. You can select which random number generator number is to be used as the source of the random number. This is set in the "Random" page of the Model Settings Notebook.

CHOOSE Edit / Settings

then select the Random page. Then fill in the desired random number stream entity number in the entry box marked "GENERATE". The installation default is to use random number stream number 1.

When Operand B is an FN class SNA, it is a special case called a "function modifier". In this case, the time increment is calculated by multiplying the result of the function by the evaluated A Operand.

If the C Operand is specified, it is evaluated numerically and used as the time increment for the first Transaction. If you wish to cause the first transaction(s) to arrive at time 0, you must use a separate GENERATE block with a creation limit in Operand D and null values for Operands A and B. If Operand A and / or B is used and C=0, C will be interpreted as null. The following example will create three transactions at time 0.

GENERATE ,,0,3

If the time increment is strictly positive (nonzero), the Transaction is placed on the FEC, if it is zero the Transaction goes to the CEC behind its priority peers, if it is negative an Error Stop occurs.

Special Restrictions

 Time values must not be negative.

 Either Operand A or Operand D must be used.

 GENERATE is the only Block which cannot be used in Manual Simulation Mode. Use a SPLIT Block to create Transactions interactively.

 

Refuse Mode

A Transaction is never refused entry to a GENERATE Block.

Related Windows

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

INDEX

An INDEX Block updates a Parameter of the Active Transaction.

INDEX A,B

Operands

A - Parameter number. Parameter with source value. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Numeric value. Number to be added to contents of Parameter. The result goes into Parameter 1. Required. The operand must be Name, Number, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

INDEX 2,11.7

In this example, when a Transaction enters the INDEX Block its Parameter number 1 is given the sum of 11.7 and the value of Parameter 2 of the Active Transaction.

 

Action

The INDEX Block adds the numeric equivalent of Operand B to the numeric equivalent of the value of any Transaction Parameter and puts the result into Parameter 1.

If the source Parameter does not exist, an Error Stop occurs. Otherwise, if Parameter number 1 does not exist for the Active Transaction, it is created.

Special Restriction

 A must be positive.

Refuse Mode

A Transaction is never refused entry to an INDEX Block.

Related SNA

 PParameter or *Parameter - Parameter value. Returns the value of Parameter Parameter.

Related Window

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 

INTEGRATION

An INTEGRATION Block disables or enables the integration of a User Variable.

INTEGRATION A,B

Operands

A - User Variable. Required. The operand must be Name.

B - Integration state. Must be Null, ON, or OFF.

 

Examples

INTEGRATION Population

This is the simplest way to use the INTEGRATION Block. When a Transaction enters this INTEGRATION Block, the integration of the User Variable, Population, is set to the enabled state. This causes the User Variable to be integrated automatically with respect to simulated time. The default of Operand B is ON.

INTEGRATION Population,OFF

In this example, the entry of the Active Transaction into the INTEGRATION Block assures that the integration of the User Variable Population is disabled. The automatic update of Population will cease until the integration is again enabled.

 

Action

A INTEGRATION Block sets the state of an integration to either ON, or OFF, that is, enabled or disabled.

The default of Operand B is ON, and need not be specified when the integration is to be activated.

Integrations are defined by INTEGRATE Commands, and are automatically begun in the active state. For integrations that are never interrupted, there is no need for INTEGRATION Blocks in the simulation.

Each INTEGRATE Command can also define one or two threshold expressions. When the value of an integrated variable crosses from one side of a threshold to the other, a new Transaction is created and sent to a destination Block specified in the INTEGRATE Command. In this manner, Continuously integrated variables can be closely incorporated into the discrete side of your simulation. You can use them to perform important duties related to the state of the integrated variable, or simply to move the thresholds.

User Variables can be assigned new values discretely, as well as through integration. You can do so using an EQU Command, or a PLUS Assignment Statement. If you want such assignments to occur within the running of the simulation, you must define a PLUS Procedure that makes the assignment. For example, if you defined a PLUS Procedure as follows:

                PROCEDURE Setpop(Pop_Level) BEGIN
                        Population = Pop_Level ;
   
             END ;

you could reinitialize the Population User Variable by entering a PLUS Block, such as

                PLUS (Setpop(200))

or by using a parenthesized expression that invokes setpop( ) in some other Block.

See Chapter 4 for a detailed description of Continuous Simulation.

Refuse Mode

A Transaction is never refused entry to an INTEGRATION Block.

Related Command

 INTEGRATE - Define the derivative of a user variable for integration, and activate the integration.

Related Windows

 Expressions Window - Online view of values of expressions.

 Plot Window - Online view of a plot of up to 8 expressions.

 

 

JOIN

A JOIN Block adds the Active Transaction to a Transaction Group, or adds a number to a Numeric Group.

JOIN A,B

Operands

A - Group entity number. Group to which a member will be added. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Numeric value. Number to be added to numeric Group. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

JOIN Solditems

This is the simplest way to use the JOIN Block. The Transaction entering the JOIN Block becomes a member of the Transaction Group SoldItems.

 

Action

JOIN Blocks operate in "Numeric Mode" when a number is specified by the B Operand, and otherwise in "Transaction Mode".

In Numeric Mode, operands A and B are evaluated numerically, and the number specified by B is included in the Numeric Group specified by A. If this number is already a member of the Numeric Group, no operation is performed. There is some loss of efficiency when non-integers are used in Numeric Groups.

In Transaction Mode, the entering Transaction is included in the Transaction Group specified by the A Operand. If the Transaction is already a member of the Transaction Group, no operation is performed.

Numeric Groups are distinct from Transaction Groups even if they have the same Group number.

Transactions are in no way restricted because of their membership in a Transaction Group. After membership is achieved, the entering Transaction proceeds to the Next Sequential Block. The only way that a Transaction can be removed from a Group is to be terminated in a TERMINATE or ASSEMBLE Block, or to be chosen for removal in a REMOVE Block.

Special Restriction

 A must be positive.

Refuse Mode

A Transaction is never refused entry to a JOIN Block.

Related Blocks

Transactions in Transaction Groups can be referenced by ALTER, EXAMINE, REMOVE, and SCAN Blocks. Numbers in numeric Groups can be referenced by EXAMINE and REMOVE Blocks.

Related SNAs

 GNEntnum - Numeric Group count. GNEntnum returns the membership count of Numeric Group Entnum.

 GTEntnum - Transaction Group count. GTEntnum returns the membership count of Transaction Group Entnum.

Related Windows

 Numeric Groups Snapshot - Picture of the state of the Numeric Groups in the simulation.

 Transaction Groups Snapshot - Picture of the state of the Transaction Groups in the simulation.

 

 

LEAVE

A LEAVE Block increases the accessible storage units at a Storage Entity.

LEAVE A,B

Operands

A - Storage Entity name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Number of storage units. The default is 1. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

LEAVE RepairMen,10

In this example, when a Transaction enters the LEAVE Block, the available storage units at the Storage Entity named RepairMen is increased by 10.

 

Action

When a Transaction enters a LEAVE Block, Operand A is evaluated and truncated, and the corresponding Storage Entity is found. If no such entity exists, an Error Stop occurs. Storage entities must be defined in STORAGE Commands.

The number of storage units to be freed is found by evaluating and truncating Operand B. If B was not used, then it is assumed to be 1.

Then the available storage at the Storage Entity is increased by the value of the B Operand. If the result exceeds the original storage capacity of the Storage Entity, an Error Stop occurs.

If no error occurs, the Transaction is scheduled for the Next Sequential Block and is placed on the Current Events Chain ahead of its priority peers.

When storage becomes available, the Delay Chain of the Storage Entity is examined in decreasing priority for Transactions whose demands can now be met. A "first-fit-with-skip" discipline is used. Successful Transactions are allowed to enter the ENTER Block which refused them and then are placed on the CEC behind their priority peers. This is done before the current Active Transaction in the LEAVE Block proceeds in the simulation. In this way, no other Transaction can buck the line of Transactions waiting on the Delay Chain of the Storage Entity. You can see this in the Blocks Window. You will see the Transaction enter the ENTER Block and come to rest. The current Active Transaction in the LEAVE Block will then resume its movement.

Special Restrictions

 A must refer to a previously defined Storage Entity defined by a STORAGE Statement.

 B must be nonnegative.

 An attempt to free more storage than was defined will cause an Error Stop.

Refuse Mode

A Transaction is never refused entry to a LEAVE Block.

Related Command

A Storage Entity must be defined in a STORAGE Command before it can be updated by an LEAVE Block. The STORAGE Command must exist in the model, or must be sent to the Simulation Object interactively, before a Transaction can enter the LEAVE Block. Any attempt to do so before the Storage Entity is defined, cases an Error Stop.

A Storage Entity can be redefined by an interactive STORAGE Command.

Related SNAs

 REntnum - Unused storage capacity. The storage content (or "token" spaces) available for use by entering Transactions at Storage Entity Entnum.

 SEntnum - Storage in use. SEntnum returns the amount of storage content (or "token" spaces) currently in use by entering Transactions at Storage Entity Entnum.

 SAEntnum - Average storage in use. SAEntnum returns the time weighted average of storage capacity (or "token" spaces) in use at Storage Entity Entnum.

 SCEntnum - Storage use count. Total number of storage units that have been entered in (or "token" spaces that have been used at) Storage Entity Entnum.

 SEEntnum - Storage empty. SEEntnum returns 1 if Storage Entity Entnum is completely unused, 0 otherwise.

 SFEntnum - Storage full. SFEntnum returns 1 if Storage Entity Entnum is completely used, 0 otherwise.

 SREntnum - Storage utilization. The fraction of total usage represented by the average storage in use at Storage Entity Entnum. SREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 SMEntnum - Maximum storage in use at Storage Entity Entnum. The "high water mark".

 STEntnum - Average holding time per unit at Storage Entity Entnum.

 SVEntnum  - Storage in available state. SVEntnum returns 1 if Storage Entity Entnum is in the available state, 0 otherwise.

Related Window

 Storages Window - Online view of Storage Entity dynamics.

 

LINK

A LINK Block controls the placement of the Active Transaction on the User Chain of a Userchain Entity.

LINK A,B,C

Operands

A - Userchain number. The Userchain Entity which may receive the entering Transaction. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Chain ordering. The placement of new Transactions on the Userchain. Required. The operand must be LIFO, FIFO, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Next Block location. The destination Block for Transactions which find the Link Indicator of the Userchain in the off state (reset). Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

 

Example

LINK OnHold,FIFO

In this example, the Active Transaction is placed at the end of the User Chain Entity named OnHold. It is removed from all chains except Transaction Groups and Interrupt Chains. In other words, preemptions are not cleared. The Transaction remains on the User Chain until some other Transaction enters an UNLINK Block and specifically removes it. In the present example, the Transaction is placed at the end of the User Chain named OnHold.

Action

The simplest operation of a LINK Block occurs when the C Operand is not used. In this case, the entering Transaction is always placed on the User Chain specified by Operand A. It is removed from all other chains except transaction groups and interrupt chains.

The placement of the Transaction in the User Chain is controlled by Operand B. If FIFO (First-In-First-Out) is used for Operand B, newly arriving Transactions are placed at the tail of the User Chain. If LIFO (Last-In-First-Out) is used for Operand B, newly arriving Transactions are placed at the head of the User Chain. Any other item used in Operand B is evaluated for the Active Transaction and again for each Transaction on the User Chain, beginning at the front, until the value for the Active Transaction is greater. When a Transaction whose value is less than that of the Active Transaction is found, the Active Transaction is placed on the User Chain immediately in front of it. If the value for the Active Transaction never exceeds the value for an occupant of the User Chain, the Active Transaction is placed at the end of the chain. This leads to a descending order. P class SNAs are an exception. They are queued in ascending order of Parameter value.

If you do not use LIFO or FIFO in Operand B, you will normally use a Transaction oriented SNA such as PR, M1 or a class P SNA. However, indirect addressing may also be useful. If PR is used, the Transactions are placed in priority order. And finally, if a Parameter number is specified, the Transaction is inserted into the chain immediately behind those Transactions whose Parameter value is less than that of the entering Transaction.

The situation is more complicated when the C Operand is used.

A flag called a "Link Indicator" is part of each Userchain Entity. The Link Indicator is useful for using a User Chain to control the queuing of Transactions on a resource. It is on (set) when the hypothetical resource is "busy" and off (reset) when the hypothetical resource is "not busy". When the Link Indicator of a Userchain Entity is off, if the C Operand is used, the LINK Block will not place the Transaction on the User Chain. The Link Indicator is useful for letting the first of several Transactions avoid the User Chain and for causing following Transactions to be placed on the User Chain.

If the C Operand is used, the entering Transaction will NOT be placed on the User Chain if the Link Indicator is off. Instead, the Transaction will proceed to the Block specified by C, and then the Link Indicator will be set. Following Transactions entering the LINK Block will go onto the User Chain.

The Link Indicator is manipulated by both LINK and UNLINK Blocks. It is turned off (reset) when an UNLINK Block finds the User Chain empty. It may be useful to think of the Link Indicator as representing the "busy condition" of a hypothetical resource. When the Link Indicator is set, the resource is "busy". When a Transaction finds the resource idle it should not have to wait (on the User Chain). The Transaction would proceed to the Block specified by Operand C and the LINK Block then sets the Link Indicator of the Userchain Entity.

Consider two Transactions arriving at a LINK Block, one after the other. If, for example, the first Transaction does not enter an UNLINK Block before the second Transaction arrives, the second Transaction would find the Link Indicator on (set), and would be placed on the User Chain. In this example, when the first Transaction enters an UNLINK Block, the second Transaction is removed from the User Chain. At this time, the Link Indicator remains on (set). Then, when the second Transaction enters an UNLINK Block, and no waiting Transactions are found on the User Chain, the Link Indicator is finally turned off (reset).

User Chains allow you manipulate the queuing mechanisms of Transactions to a much more detailed level than do Facilities or Storages. It is possible to implement very complicated scheduling algorithms using LINK and UNLINK Blocks.

User Chains can be used to reduce the amount of computer time wasted on unsuccessful tests associated with GATE, TEST, TRANSFER BOTH, and TRANSFER ALL Blocks. You can create faster simulations by placing blocked Transactions on User Chains when there is no possibility of a successful condition test. Then, you must introduce each Transaction back into its test Block when an event occurs which might unblock the Transaction.

Special Restrictions

 A, B, and C, if specified, must be positive.

 C, if specified, must be a Block location in the simulation.

Refuse Mode

A Transaction is never refused entry to a LINK Block.

Related SNAs

 CAEntnum  - Average Userchain content. The time weighted average number of chained Transactions for Userchain Entnum.

 CCEntnum - Total Userchain entries. The cumulative count of all Transactions chained to Userchain Entnum.

 CHEntnum - Current Userchain content. The current number of Transactions chained to Userchain Entnum.

 CMEntnum - Maximum Userchain content. The maximum number of Transactions chained to Userchain Entnum. The "high water mark".

 CTEntnum - Average Userchain residence time. The average duration of s Transaction at Userchain Entnum.

Related Window

 Userchains Snapshot - Picture of the state of the Userchain Entities in the simulation.

 

LOGIC

A LOGIC Block changes the state of a Logicswitch entity.

LOGIC O A

Operands

O - Logic operator. Required. The operator must be S, R, or I.

A - Logicswitch Entity number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

LOGIC S PowerSwitch

In this example, the Logicswitch Entity named PowerSwitch is left in the true or "set" state.

 

Action

A LOGIC Block is used to set, reset, or invert the state of a Logicswitch Entity. A Logicswitch Entity has two states, on (set, or 1) and off (reset, or 0). If the logic operator is S or R, the Logicswitch Entity specified by the A Operand is left in the set or reset state, respectively.

If the logic operator is I, the state of the Logicswitch Entity specified by the A Operand is inverted. This means that if it is found to be set, it will be reset. If it is found to be reset, it will be set.

Logical Operators

A logical operator is required. It may be S, R, or I with the following effect:

 S - The logic switch is left in the "set" or on state.

 R - The logic switch is left in the "reset" or off state.

 I - The logic switch is inverted.

Refuse Mode

A Transaction is never refused entry to a LOGIC Block.

Related SNA

 LSEntnum - Logic switch set. LSEntnum returns 1 if Logic Switch Entity Entnum is in the "set" state, 0 otherwise.

Related Window

 Logicswitches Window - Online view of Logicswitch Entity dynamics.

 

LOOP

A LOOP Block modifies a Parameter and controls the destination of the Active Transaction based on the result.

LOOP A,B

Operands

A - Parameter containing count. required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Block number. Next Block if count nonzero after decrement. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

LOOP Customer_Count,Start_Over

Let us assume in this example that the Start_Over Block precedes the LOOP Block in the simulation. In this example, when a Transaction enters the LOOP Block its Parameter named Customer_Count is decremented by 1. If the result is nonzero, the Transaction proceeds to Block location Start_Over. This causes the Transaction to continue to loop until the value of the Parameter named Customer_Count is 0. The Transaction then proceeds to the Next Sequential Block.

 

Action

When a Transaction enters a LOOP Block, Operand A is evaluated, truncated, and used to find the Transaction Parameter with that number. If there is no such Parameter, an Error Stop occurs. Otherwise the value of the Parameter is decreased by 1.

If the new value of the Parameter is greater than zero and the B Operand is specified, the Transaction is scheduled for the location specified in the B Operand. Otherwise, the Transaction proceeds to the Next Sequential Block.

Special Restriction

 A must be positive.

Refuse Mode

A Transaction is never refused entry to a LOOP Block.

Related SNA

PParameter or *Parameter  - Parameter value. PParameter returns the value of Parameter Parameter.

Related Windows

 Blocks Window - Online view of Block dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 

MARK

A MARK Block places an absolute clock time stamp into the Active Transaction or into its Parameter.

MARK A

Operand

A - Parameter number. Parameter to receive value of system clock. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Examples

MARK Beginning

In this example, when a Transaction enters the MARK Block, its Transaction Parameter named Beginning is given a value equal to the value of the absolute system clock, AC1.

 

MARK

In this example, when a Transaction enters the MARK Block, its Mark Time is set equal to the value of the absolute system clock.

 

Action

When a Transaction enters a MARK Block and Operand A was not specified, its Mark Time is set equal to the absolute system clock.

If Operand A was specified, it is evaluated numerically, and truncated. The Parameter of the Active Transaction with that number is found and given a value equal to the value of the absolute system clock. If the Parameter does not exist, it is created.

The Active Transaction then proceeds to the Next Sequential Block (NSB).

The time stamps set up by a MARK Block can be retrieved by M1 and MP class SNAs. M1 returns the "transit time", which is the absolute system clock minus the Transactionís Mark Time. SNAs in the class MP return a value equal to the absolute system clock minus the value of a Transaction Parameter.

Special Restriction

 A, if specified, must be positive.

Related SNAs

 MPEntnum - Transit time, Parameter. Current absolute system clock value minus value in Parameter Entnum.

 M1 - Transit time. M1 returns the absolute clock minus the "mark" time of the Transaction.

Refuse Mode

A Transaction is never refused entry to a MARK Block.

Related Windows

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

MATCH

A pair of MATCH Blocks cause Transactions to wait for each other.

MATCH A

Operand

A - Block name or number. Conjugate MATCH Block to be tested for a matching (same Assembly Set) Transaction. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

A_Is_Done MATCH B_Is_Done

B_Is_Done MATCH A_Is_Done

This example shows two conjugate MATCH Blocks. They would normally be placed apart in the simulation, and one would eventually receive a Transaction in the same Assembly Set. If each MATCH Block were placed after a set of Blocks representing some process, the pair of related Transactions would proceed past the MATCH Blocks only when both Transactions had completed their respective processes.

 

Action

When a Transaction enters a MATCH Block, Operand A is evaluated numerically, truncated, and the conjugate MATCH Block is found. If there is no such Block, an Error Stop occurs.

If the conjugate MATCH Block contains a Transaction (on its Match Chain) of the same Assembly Set as the Active Transaction, the related Transaction is removed from the Match Chain. If it is not currently preempted at any Facility Entity, it is placed on the Current Events Chain behind its priority peers. Similarly, if the Active Transaction is not currently preempted at any Facility it is placed on the CEC, but ahead of its peers.

If either matching Transaction is currently preempted at a Facility, it is not permitted to leave its MATCH Block until all preemptions have been cleared on its behalf.

If, when the Active Transaction enters the MATCH Block, no matching Transaction is found, it comes to rest on the Match Chain of the MATCH Block.

Special Restrictions

 Operand A must be the location of a MATCH Block in the simulation.

 Transactions which are currently preempted are not permitted to leave MATCH Blocks.

Refuse Mode

A Transaction is never refused entry to a MATCH Block.

Related Blocks

 ADOPT - Set the Assembly Set of the Active Transaction.

 ASSEMBLE - Wait for and destroy Assembly Set members.

 GATHER - Wait for Assembly Set members.

 SPLIT - Create Transactions in the same Assembly Set.

Related SNAs

 A1 - Assembly Set. Return the Assembly Set of the Active Transaction.

 MBEntnum - Match at Block. MBEntnum returns a 1 if there is a Transaction at Block Entnum which is in the same Assembly Set as the Active Transaction. MBEntnum returns a 0 otherwise.

Related Windows

 Blocks Window - Online view of Block dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

MSAVEVALUE

An MSAVEVALUE Block updates an element of a Matrix Entity.

MSAVEVALUE A,B,C,D

Operands

A - Matrix Entity name or number, with optional + or -. Required. the operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter, followed by +, -, or Null.

 B - Row number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

C - Column number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

D - Value to be stored, added, or subtracted. Required. The operand must be Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Examples

MSAVEVALUE Sales+,Part23,Cust77,6.234

When a Transaction enters the MSAVEVALUE Block in this example, the element, of the Matrix Entity named Sales, with row equal to the value of Part23 and the column equal to the value of Cust77 is increased by 6.234. Normally, the row and column names would have appeared earlier in EQU Statements.

MSAVEVALUE Parts,Part23,Description,"Zippo lighter"

In this example, a string is assigned to a Matrix element. The Matrix Entity must be defined elsewhere in the Model, or interactively, by a MATRIX Command that defines the Parts Matrix Entity.

 

Action

When a Transaction enters a MSAVEVALUE Block, Operand A is evaluated numerically and the Matrix Entity with that number or name is found. If no such Matrix Entity is found, an Error Stop occurs. Matrix Entities must be defined in MATRIX Commands.

Operands B and C are evaluated numerically to find the proper element in the Matrix Entity. If such an element does not exist, an Error Stop occurs.

Operand D is evaluated and used in the update operation. If Operand A has a + suffix, the operation will be addition to the numerical equivalent of Operand D; if -, it will be subtraction. If Operand A has no suffix, the matrix entity element will be assigned a new value equal to D.

A matrix is defined in a MATRIX Command. It can have up to 6 dimensions. However, only the first two dimensions can be accessed in an MSAVEVALUE Block. In this case, all missing coordinates are presumed to be equal to 1.

PLUS Procedures can access all elements of any matrix. If you need to use matrices of more than 2 dimensions, you will have to create one or more PLUS Procedures to access them. Matrices defined in a MATRIX Command have global scope and are known to all PLUS Procedures. In addition, temporary matrices with local scope can be created for the duration of a PLUS Procedure invocation. This is discussed further in Chapter 8.

Refuse Mode

A Transaction is never refused entry to an MSAVEVALUE Block.

Special Restriction

 MSAVEVALUE Blocks can only access the first cross section of a higher dimensional matrix. Indices of the third and higher dimensions are given the value 1. PLUS assignment statements can be used to access and modify all elements.

Related SNA

 MXEntnum(m,n) - Matrix element value. The value in row m, column n of matrix Entnum is returned. The row and column values can only be Name, PosInteger, or P class SNA

Related Windows

 Expressions Window - Online view of values of expressions.

 Matrix Window - Online view of the dynamics of a Matrix cross-section.

 Plot Window - Online view of a plot of up to 8 expressions.

 

OPEN

An OPEN Block initializes a Data Stream.

OPEN A,B,C

Operands

A - Data Stream descriptor. Required. The operand must be Name, PosInteger, String, ParenthesizedExpression, SNA or SNA*Parameter.

B - Data Stream number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter. Default is 1.

C - Alternate Destination Block name or number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

OPEN ("MYFILE.TXT"),2,Error_Block

In this example, the OPEN Block creates type of Data Stream known as an I/O Stream, and gives it number 2 for identification. If an error occurs during the OPEN, an error code is stored internally and the Active Transaction proceeds to the Block labeled Error_Block.

Action

An OPEN Block causes a Data Stream to be created, and sets the Current Line Position to 1.

A Data Stream is a sequence of text lines used by a GPSS World simulation. Each Data Stream is identified by a unique number. There are 3 types of Data Stream:

1. Input/Output (I/O) Streams,

2. In-Memory Streams, and

3. Pipe Streams.

Operand A is evaluated as a string. If it is a null string, an In-Memory Stream is created. If it is a pipe name, such as "\pipe\mypipe", a Pipe Stream is created. Otherwise an I/O Stream is created, and Operand A is presumed to be a file specification. If a path is not included in the file specification, it is assumed that the Projectís Report directory is to be used. Projects are discussed in Chapter 1 of this manual.

If Operand B is used, it is evaluated numerically and used as the Data Stream number, for later reference by READ, WRITE, and CLOSE Blocks. The default is 1.

If Operand C is used, any error occurring during the OPEN causes the Active Transaction to proceed to the Block with that number.

In any case, if an error is detected, the error code is stored internally. A CLOSE Block can be used to retrieve the Error Code.

Chapter 4 (4.16) contains a full discussion of Data Streams, including the Error Code descriptions..

Blocking Condition

The simulation is blocked while the Data Stream is initialized.

Refuse Mode

A Transaction is never refused entry to a CLOSE Block.

Related Blocks

 CLOSE - Shut down a Data Stream.

 READ - Retrieve a text line from a Data Stream.

 WRITE - Send a text line to a Data Stream.

 SEEK - Set the Current Line Position of a Data Stream.

 

PLUS

A PLUS Block evaluates an expression and, optionally, places the result into a Parameter.

PLUS A,B

Operands

A - Expression. Required. The operand must be Name, Number, String, ParenthesizedExpression, SNA or SNA*Parameter.

B - Parameter number. Parameter to receive result. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

PLUS (normal(2,100,2)+100.26),Result_Parm

Action

When a Transaction enters a PLUS Block, Operand A is evaluated normally.

If Operand B is specified, it is evaluated numerically, truncated, and used to identify a Parameter of the Active Transaction. If no such Parameter exists, it is created. Then, the result from the evaluation of Operand A is placed into it.

PLUS Procedures without an explicit return value return integer 0.

Refuse Mode

A Transaction is never refused entry to a PLUS Block.

Related Windows

 Expressions Window - Online view of values of expressions.

 Plot Window - Online view of a plot of up to 8 expressions.

 

PREEMPT

A PREEMPT Block displaces a Transaction from ownership of a Facility Entity.

PREEMPT A,B,C,D,E

Operands

A - Facility name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

B - Priority Mode. PR, for Priority Mode, or Interrupt Mode, if omitted. Optional. The operand must be PR or Null.

C - Block name or number. New destination for Transaction presently owning the Facility. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Parameter number. Parameter of preempted Transaction to receive residual time if preempted Transaction is removed from FEC. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

E - REmove Mode. Removes preempted Transaction from contention for the Facility. Optional. The operand must be RE, or Null. If RE, you must specify a destination in Operand C.

 

Examples

PREEMPT Teller1

This is the simplest way to use the PREEMPT Block. When a Transaction enters this PREEMPT Block, it is given ownership of the Facility Entity unless it (the Facility) is currently preempted. If a Transaction must be displaced from ownership of the Facility, it is not permitted to reside on the FEC and its movement in the simulation is restricted.

 

PREEMPT Teller1,,Teller2,101,RE

In this example, the PREEMPT Block operates in Interrupt Mode because the B Operand is omitted. This means that a Transaction can enter the Block and own the Facility if the Facility is not already owned by a preempting Transaction. Transaction priorities are ignored. When a Transaction is preempted, any remaining time in an ADVANCE Block is recorded in Parameter 101 of the preempted Transaction. The preempted Transaction is removed from contention for the Facility and sent to the Block labeled Teller2. An error will result if such a Transaction later tries to RELEASE or RETURN the Facility named Teller1, without owning it again.

 

PREEMPT Teller1,PR,Teller2

In this example, the PREEMPT operates in Priority Mode. This means that a Transaction can enter the Block and own the Facility Entity if the Facility is not already owned by a Transaction of equal or higher priority. Any preempted Transaction is not removed from contention for the Facility. This means that such a Transaction can no longer exist on the FEC or leave ASSEMBLE, GATHER, or MATCH Blocks. Under these restrictions, preempted Transactions may continue to circulate in the simulation, and in this case are sent to the Block location Teller2. Such Transactions remain in contention for the Facility named Teller1, and normally will regain ownership of it. A preempted Transaction may RETURN or RELEASE a Facility even if it does not own it. This removes the Transaction from contention for the Facility by removing it from the Interrupt Chain of the Facility.

 

Action

A PREEMPT Block behaves like a SEIZE Block when the Facility is idle. Otherwise, the PREEMPT Block operates in either Priority Mode or Interrupt Mode. This is determined by Operand B.

In Priority Mode, only a higher priority Transaction can displace the Transaction which owns the Facility. If a would-be preemptor is of insufficient priority, it is placed on the Delay Chain of the Facility in priority order.

In Interrupt Mode, if the Facility is already preempted, the Active Transaction is placed on the Pending Chain. Transactions on the Pending Chain are given ownership of the Facility in preference to preempted Transactions or to Transactions on the Delay Chain.

Operands C to E are concerned with what to do with the current owner of the Facility which is about to become preempted. Preempted Transactions are not permitted to exist on the FEC. Preempted Transactions which have unfinished time in an ADVANCE Block may be replaced on the FEC automatically by omitting the C and E operands. Alternately, if you choose to replace the Transaction on the FEC yourself, to resume the unfinished time, you must use Operand D and eventually send the preempted Transaction to an ADVANCE Block.

A preempted Transaction may be removed from contention for the Facility (i.e. removed from all chains of the Facility) by using the RE option in the E Operand. The RE option removes the restrictions placed on preempted Transactions due to preemption at this Facility, and makes any subsequent attempt to RELEASE or RETURN the Facility an Error Stop condition.

A preempted Transaction cannot exist on the FEC. A more detailed discussion of preemption is in Section 9.4. Any newly preempted Transaction in an ADVANCE Block which is on the FEC is removed from the FEC and the residual time duration is saved. If the D Operand is used, the residual time is also saved in a Transaction Parameter. If no such Parameter exists, one is created. The residual time is used to reschedule the Transaction on the FEC when it regains ownership of all Facilities for which it contends. Alternately, you may give a preempted Transaction a new Block to attempt to enter by using the C Operand.

A preempted Transaction remains in contention for a Facility even if it was displaced by the C Operand, unless RE is used in Operand E. If a preempted Transaction, which is still in contention for a Facility, attempts to enter a TERMINATE Block an Error Stop occurs. Such Transactions must enter a RELEASE or RETURN Block before they are permitted to TERMINATE. Alternately, if you intend to TERMINATE the preempted Transaction you could use the RE option to make sure it doesnít inadvertently regain ownership before termination. such a Transaction could not RELEASE or RETURN the Facility.

When a Transaction is displaced by using the C Operand, it is given a new Block destination and is dequeued from:

 FEC

 PENDING (INTERRUPT-MODE PREEMPT) CHAINS

 DELAY (MAJOR PRIORITY) CHAINS

 USER CHAINS

 RETRY CHAINS

and not dequeued from:

 CEC

 INTERRUPT (PREEMPTED) CHAINS

 GROUP CHAINS

When a Transaction is displaced from its present context, by using an alternate destination, it is removed from blocking conditions, but preemptions at other Facilities are not cleared.

When the C Operand is not used, a preempted Transaction taken off the FEC will be returned to it automatically. Preempted Transactions which have not been displaced using the C Operand are expected eventually to enter a RETURN or RELEASE Block in order to give up ownership of the Facility. If such a Transaction arrives at the RETURN or RELEASE before regaining ownership of the Facility, the Transaction is removed from contention for the Facility. No error condition occurs.

A Transaction can be preempted from any number of Facilities and continue to circulate in the simulation. However, it is subject to two restrictions:

 It will be refused entry to ADVANCE Blocks with positive time arguments.

 It will not be allowed to leave an ASSEMBLE, GATHER, or MATCH Block until all its preemptions have been cleared.

A Facility can be preempted any number of times. However, once a Transaction has been preempted, it cannot attempt to seize the Facility from which it has been preempted. A Transaction can be preempted from any number of Facilities.

Special Restrictions

 If E is RE, C must be used.

 A Transaction may not preempt itself.

Refuse Mode

A Transaction is refused entry to a PREEMPT Block if, in Interrupt Mode, the Facility is currently preempted. Such Transactions are placed at the end of the Facilityís Pending Chain.

A Transaction is refused entry to a PREEMPT Block if, in Priority Mode, the Facility is currently owned by a Transaction of priority equal to or greater than that of the Active Transaction. The Active Transaction is placed in priority order on the Facilityís Delay Chain.

A Transaction is refused entry to a PREEMPT Block if the Facility is in the unavailable state. Such Transactions are placed on the Facilityís Delay Chain, in priority order, FIFO within priority.

Related Blocks

 DISPLACE - Move any Transaction.

 FAVAIL - Place Facility in the available state.

 FUNAVAIL - Place Facility in the unavailable state.

 RELEASE - Give up ownership and remove contention for a Facility.

 RETURN - Give up ownership and remove contention for a Facility.

 SEIZE - Acquire or wait for ownership of a Facility.

Related SNAs

 FEntnum - Facility busy. If Facility Entnum is currently busy, FEntnum returns 1. Otherwise FEntnum returns 0.

 FCEntnum - Facility capture count. The number of times Facility Entnum has become owned by a Transaction.

 FIEntnum - Facility Entnum interrupted. If Facility Entnum is currently preempted, FIEntnum returns 1. Otherwise FIEntnum returns 0.

 FREntnum - Facility utilization. The fraction of time Facility Entnum has been busy. FREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 FTEntnum  - Average Facility holding time. The average time Facility Entnum is owned by a capturing Transaction.

 FVEntnum - Facility in available state. FV Entnum returns 1 if Facility Entnum is in the available state, 0 otherwise.

Related Windows

 Facilities Window - Online view of Facility Entity dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

PRIORITY

A PRIORITY Block sets the priority of the Active Transaction.

PRIORITY A,B

Operands

A - New priority value. Required. The operand must be Name, integer, String, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Buffer option. Places Active Transaction behind priority peers on CEC. Optional. The operand must be BU or Null.

 

Example

PRIORITY 10

In this example any entering Transaction is made to have a priority of 10.

 

Action

When a Transaction enters a PRIORITY Block, Operand A is evaluated numerically, truncated, and assigned to the priority of the Active Transaction.

The Transaction is scheduled for the Next Sequential Block and is placed on the CEC according to its new priority. If the BU option was used in Operand B, the Transaction is placed behind its priority peers on the CEC. Otherwise, it is placed in front of its priority peers.

Transaction priorities are integers. When a Transaction is created without an explicit priority, it is given a priority of 0, by default. GPSS World is most efficient when priorities used in the simulation are contiguous. For example, use 0, 1, 2, instead of -200, 0, 23.

Refuse Mode

A Transaction is never refused entry to a PRIORITY Block.

Related SNA

 PR - Transaction priority. The value of the priority of the Active Transaction.

Related Windows

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

QUEUE

A QUEUE Block updates Queue Entity statistics to reflect an increase in content.

QUEUE A,B

Operands

A - Queue Entity name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Number of units by which to increase the content of the Queue Entity. Default value is 1. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

QUEUE WaitingLine

In this example the content of the Queue Entity named WaitingLine is increased by one and the associated statistics accumulators are updated.

 

Action

When a Transaction enters a QUEUE Block, Operand A is evaluated, truncated, and used to find the Queue Entity with that number. The Queue Entity is created if necessary.

Operand B specifies the value to be used to increase the content of the Queue Entity. If B was specified, Operand B is evaluated, truncated, and used as the increment. If B was not specified, the value of 1 is used.

Finally, the statistics accumulated on behalf of the Queue Entity are updated.

Special Restriction

 B, if specified, must be positive.

Refuse Mode

A Transaction is never refused entry to a QUEUE Block.

Related SNAs

 QEntnum - Current queue content. The current count value of Queue Entity Entnum.

 QAEntnum - Average queue content. The time weighted average count for Queue Entity Entnum.

 QCEntnum - Total queue entries. The sum of all queue entry counts for Queue Entity Entnum.

 QMEntnum - Maximum queue content. The maximum count (high water mark) of Queue Entity Entnum.

 QTEntnum - Average queue residence time. The time weighted average of the count for Queue Entity Entnum.

 QXEntnum - Average queue residence time excluding zero entries. The time weighted average of the count for Queue Entity Entnum not counting entries with a zero residence time.

 QZEntnum - Queue zero entry count. The number of entries of Queue Entity Entnum with a zero residence time.

Related Window

 Queues Window - Online view of Queue Entity dynamics.

 

READ

A READ Block retrieves a text line from a Data Stream.

READ A,B,C

Operands

A - Transaction Parameter. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

B - Data Stream number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter. Default is 1.

C - Alternate Destination Block name or number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

READ Text_Parm,1,Done

In this example, the READ Block retrieves a text line from Data Stream number 1 and places a copy in the Transaction Parameter Text_Parm. If no such Parameter exists, it is created. If an error occurs the Active Transaction proceeds to the Block labeled Done, otherwise it proceeds to the Next Sequential Block.

Action

When a Transaction enters a READ Block, Operand A is evaluated numerically, truncated, and used to identify the Transaction Parameter which will receive the text line. If a text line is received successfully and no Parameter exists for the Active Transaction, one is created.

If Operand B is used, it is evaluated numerically, truncated, and used as the Data Stream Entity number. This must be a positive integer. If Operand B is not used, Data Stream number 1 is assumed.

If Operand C is used, any error occurring during the READ causes the Active Transaction to proceed to the Block with that number.

In any case, if an error is detected, the error code is stored internally. A CLOSE Block can be used to retrieve the Error. Chapter 4 (4.16) contains a full discussion of Data Streams, including the Error Code descriptions.

If the Data Stream is a Pipe Stream, the text line is read from the named pipe and returned to the Transaction Parameter. The simulation is blocked while this occurs.

If the Data Stream is not a Pipe Stream, the text line is determined by the Current Line Position, a 1-relative line index associated with the Data Stream. In this case, the line indicated by the Current Line Position, even if the line is a null string, is returned to the Transaction Parameter as a result of the READ. Then, the Current Line Position is incremented, i.e. move to the next line number. If there is no line to be read, no data is returned and the Active Transaction is sent to the Alternate Destination Block without any error code being stored.

Reads can be computationally expensive. You can speed processing by using a large amount of data on a small number of text lines.

Further Discussion

Chapter 4 (4.16) contains a full discussion of Data Streams under the Section entitled, Data Streams.

Refuse Mode

A Transaction is never refused entry to a READ Block.

Blocking Condition

The simulation is blocked while READ retrieves the text line.

Related Blocks

 OPEN - Create a Data Stream.

 CLOSE - Shut down a Data Stream.

 WRITE - Send a text line to a Data Stream.

 SEEK - Set the Current Line Position of a Data Stream.

 

RELEASE

A RELEASE Block releases ownership of a Facility, or removes a preempted Transaction from contention for a Facility.

RELEASE A

Operand

A - Facility number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

RELEASE Teller1

In this example, when a Transaction which owns the Facility Entity named Teller1 enters the RELEASE Block, it gives up ownership to the Facility.

 

Action

When a Transaction enters a RELEASE Block it removes itself from contention for the Facility. This can happen in two ways.

If the Active Transaction owns the Facility, it gives up ownership and proceeds to the Next Sequential Block.

If the Active Transaction has been preempted from ownership of the Facility, it is removed from the Interrupt Chain of the Facility. Ownership is not affected, because some other Transaction is the owner. If the Active Transaction is presently clear of all preemptions, it may now move normally in the simulation.

In any case, the Active Transaction is removed from ownership of or contention for the Facility and attempts to enter the Next Sequential Block. If it neither owns, nor is preempted at the Facility, an Error Stop occurs.

If the Active Transaction gives up ownership of the Facility, the next owner is taken from the Pending Chain, the Interrupt Chain, and finally the Delay Chain. If there are now Interrupt Mode PREEMPTs pending at this Facility, the first is given ownership of the Facility. Otherwise, ownership is returned to the most recently preempted Transaction. If both the Pending Chain (waiting Interrupt Mode PREEMPTs) and the Interrupt Chain (preempted Transactions) are empty, the highest priority Transaction on the normal Delay Chain is given ownership. If there are no Transactions waiting, the Facility becomes idle.

When a new owner is chosen from the Delay Chain or the Pending Chain, it enters the SEIZE or PREEMPT Block immediately, and then is scheduled by placing it on the CEC behind its priority peers. After this entry, the current Active Transaction in the RELEASE Block continues its movement.

Special Restriction

 An entering Transaction must own, or currently be preempted at, the Facility. Otherwise an Error Stop occurs.

Refuse Mode

A RELEASE Block never refuses entry to a Transaction.

Related SNAs

 FEntnum - Facility busy. If Facility Entnum is currently busy, FEntnum returns 1. Otherwise FEntnum returns 0.

 FCEntnum - Facility capture count. The number of times Facility Entnum has become owned by a Transaction.

 FIEntnum - Facility Entnum interrupted. If Facility Entnum is currently preempted, FIEntnum returns 1. Otherwise FIEntnum returns 0.

 FREntnum - Facility utilization. The fraction of time Facility Entnum has been busy. FREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 FTEntnum - Average Facility holding time. The average time Facility Entnum is owned by a capturing Transaction.

 FVEntnum - Facility in available state. FV Entnum returns 1 if Facility Entnum is in the available state, 0 otherwise.

Related Window

 Facilities Window - Online view of Facility Entity dynamics.

 

REMOVE

A REMOVE Block removes members from a Numeric Group or a Transaction Group.

REMOVE O A,B,C,D,E,F

Operands

O - Conditional operator. Relationship of D to E for removal to occur. These choices are explained below. Optional. The operator must be Null, E, G, GE, L, LE, MAX, MIN, or NE.

A - Group number. Group from which a member or members will be removed. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Removal limit. The maximum number of Transactions to be removed. Optional. The operand must be ALL, Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

C - Numeric value. Numeric value to be removed from a Numeric Group. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, SNA or SNA*Parameter.

D - Test value. PR or Parameter number. The member attribute which determines whether each Group member Transaction should be removed, or PR to use the Transaction priority for the determination. It is evaluated with respect to the Transaction Group member. Optional. The operand must be PR or Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

E - Reference value. The value against which the D Operand is compared. The reference value is evaluated with respect to the Active Transaction. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, SNA or SNA*Parameter.

F - Block number. The alternate destination for the entering Transaction. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

Example

REMOVE Inventory

This is the simplest way to use the REMOVE Block. The Transaction entering the REMOVE Block is tested for membership in the Transaction Group named Inventory. If the Transaction is a member it is removed from the Group.

 

REMOVE G 3,10,,300,11.6,Jump_Block

In this example, Transaction Group 3 is scanned for Transactions which have a value in their Parameter 300 which is greater than 11.6. The first 10 Transactions which meet the test are removed from the Transaction Group. If 10 Transactions cannot be found which pass the test, the entering Transaction attempts to enter the Block labeled Jump_Block. Otherwise, it proceeds to the Next Sequential Block.

 

Action

A REMOVE Block excludes numeric values from membership in a Numeric Group, or Transactions from membership in a Transaction Group. Transactions are not displaced from their context. However, there is one exception. The Transaction entering the REMOVE Block may be redirected according to the F Operand.

A REMOVE Block operates in Numeric Mode if Operand C is used. In Numeric Mode, operands A and C are evaluated numerically and the number specified by C is tested for membership in the numeric Group specified by A, which is truncated. If the result from Operand C is a member of the Numeric Group, it is removed from the Group. If the numeric value was not a member of the numeric Group and the F Operand is used, the entering Transaction proceeds to the Block specified by F. Otherwise, the entering Transaction proceeds to the next sequential Block. Only operands A, C, and F can be used in Numeric Mode. There is some loss of efficiency when non-integers are used in Numeric Groups.

A REMOVE Block operates in Transaction Mode if Operand C is not used. In Transaction Mode, there are several options available to select the Transaction(s) to be removed from the Transaction Group. If you do not specify operands B, D, or E, then only the Transaction entering the REMOVE Block is removed. This mode of operation is called self removal. Otherwise, a "group scan" is performed.

In a group scan, you may test each Transaction for removal by using the conditional operator and/or operands D and E. Also you may limit the number of Transactions to be removed by the B Operand.

Operand D always refers to the Transaction Group member under test. Notice that any SNA may be used in Operand D. Any SNA which requires a Transaction for its evaluation uses the current Transaction Group member under test. The result returned by any SNA other than PR is used as a Parameter number whose value is returned as the final result.

In a group scan you may use a conditional operator to specify the relationship between the Transaction attribute (Operand D) and the reference value (Operand E) which will initiate a removal of the Transaction. Both are evaluated numerically. The default for the conditional operator is E for equality. If you use no conditional operator, but you use Operand D and Operand E, the values must be equal for the Transaction to be removed from the Transaction Group. If MIN or MAX is used as the conditional operator, all Transactions with the greatest or least attribute (Operand D) are removed, up to the limit count (Operand B).

The B Operand cuts off the group scan when it equals the number of Transactions that have been removed. The default is ALL. If there is no attribute test, that is, if D is not specified, Transactions are removed until the removal count equals B or until the Group is empty.

The F Operand is used in both Numeric Mode and Transaction Mode. It indicates an alternate destination to be taken by the entering Transaction when an exception condition occurs. The F Operand is used for the destination Block under the following conditions:

 In Numeric Mode, if the numeric value (C Operand) was not a member of the Group.

 In Self Removal Mode, if the Transaction entering the REMOVE Block was not a member of the Transaction Group.

 In Group Scan Mode, if no Transaction is removed.

 In Group Scan Mode, if the removal count specified by B cannot be reached.

If the F Operand is not used, the entering Transaction always goes to the Next Sequential Block.

Conditional Operators

The conditional operator may be E, G, GE, L, LE, MAX, MIN, or NE. If no conditional operator is used, E (equality) is assumed. When the condition is true, the Transaction being tested is removed from the Group. The conditions are defined as follows:

 E - The Transaction attribute specified by Operand D must be equal to the reference value specified by Operand E for the Transaction to be removed from the Group.

 G - The Transaction attribute specified by Operand D must be greater than the reference value specified by Operand E for the Transaction to be removed from the Group.

 GE - The Transaction attribute specified by Operand D must be greater than or equal to the reference value specified by Operand E for the Transaction to be removed from the Group.

 L - The Transaction attribute specified by Operand D must be less than the reference value specified by Operand E for the Transaction to be removed from the Group.

 LE - The Transaction attribute specified by Operand D must be less than or equal to the reference value specified by Operand E for the Transaction to be removed from the Group.

 MAX - The Transaction attribute specified by Operand D must be equal to the largest such attribute of all Transactions in the Group for the Transaction to be removed from the Group.

 MIN - The Transaction attribute specified by Operand D must be equal to the smallest such attribute of all Transactions in the Group for the Transaction to be removed from the Group.

 NE - The Transaction attribute specified by Operand D must be unequal to the reference value specified by Operand E for the Transaction to be removed from the Group.

If no conditional operator is used in Group Scan Mode, E is assumed.

Special Restrictions

 If a Numeric Group is referenced, you must not use a conditional operator.

 If a Numeric Group is referenced, you must not use Operand B, D, or E.

 If Operand D is used, then you must use Operand E or else you must use the conditional operator MIN or MAX.

 If Operand E is used, you must use Operand D.

 If MIN or MAX is used for the conditional operator, Operand D must be used and Operand E must not be used.

Refuse Mode

A Transaction is never refused entry to a REMOVE Block.

Related Blocks

Transactions and numbers are added to Groups by JOIN Blocks. Transactions in Groups can be referenced by ALTER, EXAMINE, REMOVE, and SCAN Blocks. Numbers in Numeric Groups can be referenced by EXAMINE Blocks.

Related SNAs

 GNEntnum - Numeric Group count. GNEntnum returns the membership count of Numeric Group Entnum.

 GTEntnum - Transaction Group count. GTEntnum returns the membership count of Transaction Group Entnum.

Related Windows

 Numeric Groups Snapshot - Picture of the state of the Numeric Groups in the simulation.

 Transaction Groups Snapshot - Picture of the state of the Transaction Groups in the simulation.

 

RETURN

A RETURN Block releases ownership of a Facility, or removes a preempted Transaction from contention for a Facility.

RETURN A

Operand

A - Facility number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

Example

RETURN Teller1

In this example, when a Transaction which owns the Facility named Teller1 enters the RETURN Block, it gives up ownership of the Facility.

 

Action

When a Transaction enters a RETURN Block it removes itself from contention for the Facility. This can happen in two ways.

If the Active Transaction owns the Facility Entity, it gives up ownership and proceeds to the Next Sequential Block.

If the Active Transaction has been preempted from ownership of the Facility, it is removed from the Interrupt Chain of the Facility. Ownership is not affected, because some other Transaction is the owner. If the Active Transaction is presently clear of all preemptions, it may now move normally in the simulation.

In any case, the Active Transaction is removed from ownership of or contention for the Facility and attempts to enter the Next Sequential Block. If it neither owns, nor is preempted at the Facility, an Error Stop occurs.

If the Active Transaction gives up ownership of the Facility, the next owner is taken from the Pending Chain, the Interrupt Chain, and finally the Delay Chain. If there are now Interrupt Mode PREEMPTs pending at this Facility, the first is given ownership of the Facility. Otherwise, ownership is returned to the most recently preempted Transaction. If both the Pending Chain (waiting Interrupt Mode PREEMPTs) and the Interrupt Chain (preempted Transactions) are empty, the highest priority Transaction on the normal Delay Chain is given ownership. If there are no Transactions waiting, the Facility becomes idle.

When a new owner is chosen from the Delay Chain or the Pending Chain, it enters the SEIZE or PREEMPT Block immediately, and then is scheduled by placing it on the CEC behind its priority peers. After this entry, the current Active Transaction in the RETURN Block continues its movement.

Special Restriction

 An entering Transaction must own, or currently be preempted at, the Facility. Otherwise an Error Stop occurs.

Refuse Mode

A RETURN Block never refuses entry to a Transaction.

Related SNAs

 FEntnum - Facility busy. If Facility Entnum is currently busy, FEntnum returns 1. Otherwise FEntnum returns 0.

 FCEntnum - Facility capture count. The number of times Facility Entnum has become owned by a Transaction.

 FIEntnum - Facility Entnum interrupted. If Facility Entnum is currently preempted, FIEntnum returns 1. Otherwise FIEntnum returns 0.

 FREntnum - Facility utilization. The fraction of time Facility Entnum has been busy. FREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 FTEntnum  - Average Facility holding time. The average time Facility Entnum is owned by a capturing Transaction.

 FVEntnum - Facility in available state. FV Entnum returns 1 if Facility Entnum is in the available state, 0 otherwise.

Related Window

 Facilities Window - Online view of Facility Entity dynamics.

 

SAVAIL

A SAVAIL Block ensures that a Storage Entity is in the available state.

SAVAIL A

Operand

A - Storage name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

SAVAIL MotorPool

In this example, when a Transaction enters the SAVAIL Block, the Storage Entity MotorPool is assured to be in the available state.

 

Action

An SAVAIL Block ensures that a Storage Entity is in the available state. If any Transactions are waiting on the Delay Chain of the Storage, they are given a chance to have their storage requests satisfied by the Storage Entity according to the first-fit-with-skip discipline. Those Transactions whose storage requests cannot be satisfied remain on the Delay Chain of the Storage Entity.

If the Storage Entity is already in the available state, the SAVAIL Block has no effect.

Refuse Mode

A Transaction is never refused entry to a SAVAIL Block.

Related Command

A Storage Entity must be defined in a STORAGE Command before it can be updated by an SAVAIL Block. The STORAGE Command must exist in the model, or must be sent to the Simulation Object interactively, before a Transaction can enter the SAVAIL Block. Any attempt to do so before the Storage Entity is defined, cases an Error Stop.

A Storage Entity can be redefined by an interactive STORAGE Command.

Related SNAs

 REntnum - Unused storage capacity. The storage content (or "token" spaces) available for use by entering Transactions at Storage Entity Entnum.

 SEntnum - Storage in use. SEntnum returns the amount of storage content (or "token" spaces) currently in use by entering Transactions at Storage Entity Entnum.

 SAEntnum - Average storage in use. SAEntnum returns the time weighted average of storage capacity (or "token" spaces) in use at Storage Entity Entnum.

 SCEntnum - Storage use count. Total number of storage units that have been entered in (or "token" spaces that have been used at) Storage Entity Entnum.

 SEEntnum - Storage empty. SEEntnum returns 1 if Storage Entity Entnum is completely unused, 0 otherwise.

 SFEntnum - Storage full. SFEntnum returns 1 if Storage Entity Entnum is completely used, 0 otherwise.

 SREntnum - Storage utilization. The fraction of total usage represented by the average storage in use at Storage Entity Entnum. SREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 SMEntnum - Maximum storage in use at Storage Entity Entnum. The "high water mark".

 STEntnum - Average holding time per unit at Storage Entity Entnum.

 SVEntnum - Storage in available state. SVEntnum returns 1 if Storage Entity Entnum is in the available state, 0 otherwise.

Related Window

 Storages Window - Online view of Storage Entity dynamics.

 

SAVEVALUE

A SAVEVALUE Block changes the value of a Savevalue Entity.

SAVEVALUE A,B

Operands

A - Savevalue Entity number. Required. May be followed by + or - to indicate addition or subtraction to existing value. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter, followed by +, -, or Null.

B - The value to be stored, added, or subtracted. Required. The operand must be Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Examples

SAVEVALUE Account,99.95

In this example, the Savevalue Entity named Account takes on the value 99.95.

SAVEVALUE The_Bard,"A rose by any other name ..."

In this example, the Savevalue Entity named The_Bard is assigned a string. If the Savevalue Entity does not exist, it is created.

Action

An SAVEVALUE Block is used to assign, increment, or decrement the value of a Savevalue Entity.

The A Operand is evaluated numerically, truncated, and used as the Savevalue Entity number.

Operand B is evaluated and used to determine the new value for the Savevalue Entity. If Operand A is followed by +, then the numeric equivalent of Operand B is added to the numeric equivalent of the old value. If Operand A is followed by -, then the numeric equivalent of Operand B is subtracted from the numeric equivalent of the old value. If Operand A is not followed by a sign, the old value of the SAVEVALUE is replaced by Operand B.

Refuse Mode

A Transaction is never refused entry to a SAVEVALUE Block.

Related SNA

 XEntnum - Savevalue. The value of Savevalue Entnum is returned.

Related Windows

 Expressions Window - Online view of values of expressions.

 Plot Window - Online view of a plot of up to 8 expressions.

 Savevalues Window - Online view of Savevalue Entity dynamics.

 

SCAN

A SCAN Block passes information from a Transaction Group member to the Active Transaction.

SCAN O A,B,C,D,E,F

Operands

O - Conditional operator. Relationship of B to C for the Transaction Group member to be chosen. These choices are explained below. Optional. The operator must be Null, E, G, GE, L, LE, MAX, MIN, or NE.

A - Transaction Group number. Group whose members will be scanned. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Test value. PR or Parameter number. The member attribute which determines whether the Group member Transaction should be selected. It is evaluated with respect to the Transaction Group member. Optional. The operand must be PR or Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Reference value. The value against which the B Operand is compared. The default is 0. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Retrieved value. PR or Parameter number. The member attribute which is to be assigned to a Parameter of the Active Transaction. It is evaluated with respect to the Transaction Group member. Required. The operand must be PR, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

E - Receiving Parameter number. The Parameter number of the entering Transaction which will receive the value retrieved from Operand D. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

F - Alternate Block number. The alternate destination for the entering Transaction. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Examples

SCAN MAX Inventory,P$Price,,P$PartNumber,100

In this example, all Transactions in the Transaction Group Inventory are examined in order to find the Parameter named Price with the greatest value. The first Transaction with a maximal Price Parameter value is then selected for evaluation of the D Operand. The value of the PartNumber Parameter of the selected Transaction Group member is assigned to Parameter number 100 of the Active Transaction. If the Transaction Group is empty, no action occurs.

 

SCAN E Lot11,PartNum,127,Price,Price,Phone

In this example, when a Transaction enters the SCAN Block, the Transaction Group named Lot11 is scanned for the first Transaction which has a value of 127 in its Parameter named PartNum If such a Transaction is found, the value in its Parameter named Price is transferred to the corresponding Parameter of the Transaction entering the SCAN Block. The entering Transaction then proceeds to the Next Sequential Block. If no such Transaction Group member is found, the entering Transaction proceeds to the Block labeled Phone. Operands D and E need not specify the same Transaction Parameter.

 

Action

A SCAN Block finds the first Transaction in a Group which passes all tests, and stores one of its attributes in a Parameter of the Active Transaction. If no such Parameter exists for the Active Transaction, one is created. If an appropriate Transaction Group member cannot be found, no value is stored.

The Transaction Group member may be chosen on the basis of a test of one of its attributes. This is done by using operands B, C, and/or a conditional operator. If no such test is used, the first Transaction in the Group, if any, is selected.

When a Transaction Group member is found to satisfy a test, its attribute, which is specified by Operand D, is copied into the Parameter of the Active Transaction, specified by the E Operand. In this case, the Active Transaction always proceeds to the Next Sequential Block.

If no Transaction is found to satisfy the requirements, the Active Transaction may optionally be directed to the Block specified by the F Operand. Otherwise, it proceeds to the Next Sequential Block.

If you use operands B, C, or a conditional operator, the first Transaction Group member to pass the test is selected. Operand B specifies which attribute of the member Transactions is to be tested. It may be compared to the minimum or the maximum of all such Group member attributes by using MIN or MAX as the conditional operator. The first Transaction in the Transaction Group which has the maximum or minimum attribute is selected. If you use MIN or MAX, you must not use Operand C.

You may compare the Group member attribute to Operand C, with or without a conditional operator. In this case, the conditional operator must not be MIN or MAX. The default for Operand C is 0.

Operands B and D always refer to the Transaction Group member under test. Notice that any SNA may be used. Any SNA which requires a Transaction for its evaluation uses the current Transaction Group member under test. The result returned by any SNA, other than PR, is used as a Parameter number, whose value is returned as the final result.

The default for the conditional operator is E for equality. If you use no conditional operator, but you use Operand B and Operand C, the values must be equal for the member Transaction attribute to be selected.

The F Operand indicates an alternate destination Block to be taken by the entering Transaction when no Transaction is found which satisfies the conditions specified. If F is not used, the entering Transaction always proceeds to the Next Sequential Block.

Conditional Operators

The conditional operator may be E, G, GE, L, LE, MAX, MIN, or NE. If no conditional operator is used, E (equality) is assumed. When the condition is true, the Transaction being tested is selected. The conditions are defined as follows:

 E - The member Transaction attribute specified by Operand B must be equal to the reference value specified by Operand C for the member Transaction to be selected.

 G - The member Transaction attribute specified by Operand B must be greater than the reference value specified by Operand C for the member Transaction to be selected.

 GE - The member Transaction attribute specified by Operand B must be greater than or equal to the reference value specified by Operand C for the member Transaction to be selected.

 L - The member Transaction attribute specified by Operand B must be less than the reference value specified by Operand C for the member Transaction to be selected.

 LE - The member Transaction attribute specified by Operand B must be less than or equal to the reference value specified by Operand C for the member Transaction to be selected.

 MAX - The member Transaction attribute specified by Operand B must be equal to the greatest such attribute of all Transactions in the Group for the member Transaction to be selected.

 MIN - The member Transaction attribute specified by Operand B must be equal to the smallest such attribute of all Transactions in the Group for the member Transaction to be selected.

 NE - The member Transaction attribute specified by Operand B must be unequal to the reference value specified by Operand C for the member Transaction to be selected.

Special Restrictions

 If Operand C is used, you must use Operand B.

 If MIN or MAX is used for the conditional operator, Operand C must not be used.

Refuse Mode

A Transaction is never refused entry to a SCAN Block.

Related Blocks

Transactions and numbers are added to Groups by JOIN Blocks. Transactions in Groups can be referenced by ALTER, EXAMINE, REMOVE, and SCAN Blocks.

Related SNA

 GTEntnum - Transaction Group count. GTEntnum returns the membership count of Transaction Group Entnum.

Related Windows

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 Transaction Groups Snapshot - Picture of the state of the Transaction Groups in the simulation.

 

SEEK

A SEEK Block sets the Current Line Position of a Data Stream.

SEEK A,B

Operands

A - New Current Line Position. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

B - Data Stream Entity. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter.

 

Example

SEEK 20,Data_Base

In this example, the SEEK Block changes the Current Line Pointer of the Data Stream Data_Base to 20.

Action

A Data Stream is a sequence of text lines used by a GPSS World simulation. Each Data Stream is identified by a unique number. Chapter 4 (4.16) contains a full discussion of Data Streams, including the error code descriptions under the Section entitled Data Streams.

Each Data Stream has a Current Line Position. This is a 1-relative index to the next line position to be read or written. When a Transaction enters a SEEK Block, Operand A is evaluated numerically and used as next Current Line Position.

If Operand B is used, it is evaluated numerically and used as the Data Stream Entity number. It must be a positive integer. If Operand B is not specified, the SEEK is applied to Data Stream number 1.

If an error is detected, the error code is stored internally. A CLOSE Block can be used later to retrieve the Error Code.

Refuse Mode

A Transaction is never refused entry to a SEEK Block.

Related Blocks

 OPEN - Create a Data Stream.

 CLOSE - Shut down a Data Stream.

 READ - Retrieve a text line from a Data Stream.

 WRITE - Send a text line to a Data Stream.

 

SEIZE

When the Active Transaction attempts to enter a SEIZE Block, it waits for or acquires ownership of a Facility Entity.

SEIZE A

Operand

A - Facility name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

SEIZE Teller1

In this example, when a Transaction attempts to enter the SEIZE Block, the state of the Facility named Teller1 is tested. If it is idle, ownership is given to the Active Transaction, which is allowed to enter the SEIZE Block and proceed to the Next Sequential Block (NSB). If the Facility is busy (owned), the Active Transaction comes to rest on the Delay Chain of the Facility.

 

Action

A SEIZE Block enables a Transaction to acquire ownership of a Facility. If the Facility is idle (not owned), the Transaction immediately acquires ownership of it, enters the SEIZE Block, and attempts to enter the next Block. If the Facility is already owned, the Transaction comes to rest, last within its priority, on the Delay Chain of the Facility and does not enter the SEIZE Block.

Refuse Mode

A Transaction is refused entry to a SEIZE Block if it cannot immediately receive ownership of the Facility Entity.

The Active Transaction is refused entry to the SEIZE Block if the Facility entity is in the unavailable state.

When a Transaction is refused entry, its Delay Indicator is set and remains so until the Transaction enters a "Simultaneous" Mode TRANSFER Block. Simultaneous Mode TRANSFER Blocks are rarely used because a BOOLEAN VARIABLE can more efficiently control the coordination of the state of a number of resources when used in a TEST Block.

Related SNAs

 FEntnum - Facility busy. If Facility Entnum is currently busy, FEntnum returns 1. Otherwise FEntnum returns 0.

 FCEntnum - Facility capture count. The number of times Facility Entnum has become owned by a Transaction.

 FIEntnum - Facility Entnum interrupted. If Facility Entnum is currently preempted, FIEntnum returns 1. Otherwise FIEntnum returns 0.

 FREntnum - Facility utilization. The fraction of time Facility Entnum has been busy. FREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 FTEntnum - Average Facility holding time. The average time Facility Entnum is owned by a capturing Transaction.

 FVEntnum - Facility in available state. FV Entnum returns 1 if Facility Entnum is in the available state, 0 otherwise.

Related Window

 Facilities Window - Online view of Facility Entity dynamics.

 

SELECT

A SELECT Block chooses an entity and places its entity number in a Parameter of the Active Transaction.

SELECT O A,B,C,D,E,F

Operands

O - Conditional operator or logical operator. These choices are explained below. Required. The operator must be FNV, FV, I, LS, LR, NI, NU, SE, SF, SNE, SNF, SNV, SV, U, E, G, GE, L, LE, MIN, MAX, or NE.

A - Parameter name or number to receive the number of the selected entity. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter

B - Lower entity number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Upper entity number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Reference value for E Operand when in Conditional Mode. Optional. The operand must be Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter. Not used with MAX or MIN.

E - SNA class name. Entity attribute specifier for Conditional Mode tests. Required only for Conditional Mode. The type of SNA implies the entity type. You do not specify the entity number in Operand E. This is done automatically as the entity number range is searched. You may use any entity SNA class. Optional. The operand must be Null or entitySNAclass.

F - Alternate Block number. The destination Block if no entity is selected. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

Examples

SELECT SNF Not_Full,Bin1,Bin3

In this example, the entity number of the first Storage Entity that has room whose entity numbers fall between Bin1 and Bin3 will be stored in the Transaction Parameter named Not_Full. If the Parameter does not exist, it will be created. It is always wise to test prior to entry into a SELECT Block that a successful selection is possible. If it is not possible, a 0 would be put in the Parameter and in this case, entry into an ENTER Block would cause an Error Stop since no entity can have an entity number of 0. You can also use an alternate exit if no entity is found to meet the desired criteria.

 

If the range of entities to be searched have been defined with alphanumeric names as above, you must first use EQU Statements to assign contiguous numbers to the range of names. The EQU Statements must occur prior to the original entity definitions.

 

 10 Bin1 EQU 1

 20 Bin2 EQU 2

 30 Bin3 EQU 3

 40 Bin1 STORAGE 11

 50 Bin2 STORAGE 1000

 60 Bin3 STORAGE 150

.

.

100 SELECT SNF 3,Bin1,Bin3,,,No_Room

 

Here, we have taken the example above and given an alternate destination to Transactions that find all Storage Entities to be full. If you do not test first for a successful selection using a TEST Block and a BOOLEAN VARIABLE, you should have an alternate destination should the selection be unsuccessful.

SELECT E Empty1,Queue1,Queue9,0,Q

In this example, the SELECT Block operates in Conditional Mode. Each Queue Entity with entity number between those of Queue1 and Queue9, inclusively, is tested. The first Queue Entity whose current content is 0 is selected. EMPTY1 is the name of the Parameter of the entering Transaction to receive the entity number of the first "empty" Queue Entity in the specified range.

 

Action

When the SELECT Block is entered, the entity specified by Operand B is tested. If the entity does not exist and does not require a separate Command for its definition, a new entity is created. Thereafter, each entity in the range indicated by operands B and C is tested. An SNA is built automatically for each entity. The SNA class used to build the SNA is taken from Operand E or is specified by the logical operator.

A SELECT Block operates in either Logical Mode or in Conditional Mode, depending on whether a logical operator or a conditional operator is used.

When a logical operator is used (defined below), operands A, B, and C are used. The condition specified by the logical operator is tested for the entities whose numbers fall between B and C. The entity number of the first entity found in that condition is placed in the Parameter of the entering Transaction whose number is given by Operand A. The entity type is implied by the logical operator. If no entity is found, 0 is placed in the Parameter of the Active Transaction. If the Parameter does not exist, it is created.

When a conditional operator is used, operands A, B, C, E, and usually D are used. Operands A, B, C, are used to specify the target Parameter, and the range of entity numbers, as above. But now the conditional operator specifies the relationship between operands D and E that must hold for the entity to be selected. Both are evaluated numerically.

In Conditional Mode, the SNA class is combined with the entity specifier in order to build an SNA. The entity type implied by each SNA class is given in Section 3.4. The complete SNA is built from this class and the number of the entity being tested. Each such SNA is evaluated for each entity and compared to the reference value in Operand D. Operand D is evaluated with respect to the entering Transaction and is the reference value for comparison to Operand E, which specifies the class of SNA (and therefore the entity type) to be evaluated. The conditional operator specifies the relation that Operand E, evaluated at each entity, must bear to Operand D, evaluated on behalf of the entering Transaction, in order for the entity to be selected. If MIN or MAX is used as the conditional operator, Operand D is ignored.

In either mode, the F Operand may be used to direct the entering Transaction to a new Block in the event that no entity can be selected. If F is not used, the entering Transaction will always proceed to the next sequential Block. If F is used, and no entity is selected, the Active Transaction proceeds to the Block specified by F, with its Parameter, specified by Operand A, set to 0.

Logical Operators

Either a conditional operator or a logical operator is required. The logical operator may be FNV, FV, I, LS, LR, NI, NU, SE, SF, SNE, SNF, SNV, SV, or U. When the logical operator is true, the entity being tested is selected. The conditions are defined as follows:

 FNV - The Facility Entity must be unavailable in order to be selected.

 FV - The Facility Entity must be available in order to be selected.

 I - The Facility Entity must be currently interrupted (preempted) in order to be selected.

 LS - The Logicswitch Entity must be set in order to be selected.

 LR - The Logicswitch Entity must be reset in order to be selected.

 NI - The Facility Entity must NOT be currently interrupted (preempted) in order to be selected.

 NU - The Facility Entity must not be in use in order to be selected.

 SE - The Storage Entity must be empty in order to be selected.

 SF - The Storage Entity must be full in order to be selected.

 SNE - The Storage Entity must NOT be empty in order to be selected.

 SNF - The Storage Entity must NOT be full in order to be selected.

 SNV - The Storage Entity must NOT be available in order to be selected.

 SV - The Storage Entity must be available in order to be selected.

 U - The Facility Entity must be in use in order to be selected.

Conditional Operators

Either a conditional operator or a logical operator is required. The conditional operator may be E, G, GE, L, LE, MAX, MIN, or NE. The conditions are defined as follows:

 E - The value of the automatic SNA must be equal to the reference value specified by Operand D for the entity to be selected.

 G - The value of the automatic SNA must be greater than the reference value specified by Operand D for the entity to be selected.

 GE - The value of the automatic SNA must be greater than or equal to the reference value specified by Operand D for the entity to be selected.

 L - The value of the automatic SNA must be less than the reference value specified by Operand D for the entity to be selected.

 LE - The value of the automatic SNA must be less than or equal to the reference value specified by Operand D for the entity to be selected.

 MAX - The value of the automatic SNA must be equal to the greatest of all such SNAs, for the entity to be selected.

 MIN - The value of the automatic SNA must be equal to the least of all such SNAs, for the entity to be selected.

 NE - The value of the automatic SNA must be unequal to the reference value specified by Operand E for the entity to be selected.

Special Restrictions

 Either a conditional operator or a logical operator is required.

 Evaluated entity numbers must be positive integers.

 D and E are required if O is a conditional operator. Other than MIN or MAX.

 When evaluated, C must be greater than or equal to B.

Refuse Mode

A Transaction is never refused entry to a SELECT Block.

Related Windows

 Facilities Window - Online view of Facility Entity dynamics.

 Logicswitches Window - Online view of Logicswitch Entity dynamics.

 Storages Window - Online view of Storage Entity dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 

SPLIT

A SPLIT Block creates Transactions in the same Assembly Set as the Active Transaction.

SPLIT A,B,C

Operands

A - Count. Number of related Transactions to be created. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Block number. Destination for new Transactions. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Parameter number. Parameter to receive serial number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Examples

SPLIT 1

This is the simplest way to use the SPLIT Block. A new copy of the parent Transaction is created which will follow the parent Transaction to the next Block. The new Transaction has the same priority, Parameter values, and Mark Time as the parent.

SPLIT 3,P20,20

In this example, each time the SPLIT Block is entered, 3 new Transactions are created. Each Transaction has the same priority, Mark Time, and Parameter values as the parent Transaction, with the exception of Parameter number 20.

Each offspring Transaction will have a serial number in its Parameter number 20 based on the value in Parameter number 20 of the parent Transaction. The parentís Parameter value 20 is first incremented by 1 (in case it is 0), and then the serial number of each offspring is calculated following that value sequentially.

The destination Block found in Operand B is evaluated with respect to each newly created Transaction. If Parameter 20 of the parent Transaction contains a Block number, say, n, then the first offspring will go to Block n+2, the second to n+3 and the third to n+4.

The parent Transaction will proceed to the Next Sequential Block following the SPLIT Block.

The above example is unique because Parameter 20 is used in both the B and C operands. Therefore, the serial number is used to determine the destination Block location.

The B and C operands can be used for separate purposes, B containing a single destination of the offspring Transactions and C, a serial number which might be used to direct the individual Transactions at some location further on in the simulation.

SPLIT 3,Pro,17

In this example, each time the split Block is entered, 3 new Transactions are created. The parent Transaction goes to the Next Sequential Block, the offspring to a Block labeled Pro. Parameter 17 will receive the serialization. If the parent Transactionís Parameter is not predefined, it will be created and initialized to 0. In this example, the parent Transaction with a value of 0 in the Parameter 17, (the Parameter to be used for serialization) will, after passing through the SPLIT Block, have a 1 in Parameter 17 and the offspring will have 2, 3, and 4 in Parameter 17.

 

Action

A SPLIT Block creates new Transactions which share the attributes of their parent. Each offspring Transaction has the same priority and Mark Time of the parent, and is in the same Assembly Set. If the Trace Indicator is set in the parent Transaction, it is turned on in the offspring Transaction.

The new Transactions may be sent to an alternate destination, by using a Block number for Operand B. The new Block number is evaluated for each new Transaction.

The optional C Operand specifies the Parameter number of the newly created Transactions to receive a serial number. The numbering starts at the value of the corresponding Parameter in the parent Transaction, plus 1. For example, if 3 copies are to be created with a serial number in Parameter 120, and the entering Transaction has 15 in its Parameter 120, then the new Transactions will have 16, 17, and 18, respectively, in their Parameters numbered 120. If the parent Transaction has no such Parameter, it is created and the numbering starts at 1.

By using both B and C operands it is possible to send each new Transaction to a different destination as shown in the second example above.

The parent Transaction and all the offspring Transactions all belong to the same set of Transactions called an Assembly Set. All Transactions belong to exactly one Assembly Set, which can be changed by entry into an ADOPT Block. Members of the same Assembly Set are said to be "related". The relationships of Transactions may be tested and used in ASSEMBLE, GATHER, MATCH, and GATE Blocks for synchronization and other purposes.

Special Restriction

 A, B, and C, if specified, must be positive.

Refuse Mode

A Transaction is never refused entry to a SPLIT Block.

Related Blocks

 ADOPT - Set the Assembly Set of the Active Transaction.

 ASSEMBLE - Wait for and destroy Assembly Set members.

 GATHER - Wait for Assembly Set members.

 MATCH - Wait for Assembly Set member.

Related SNAs

 A1 - Assembly Set. Return the Assembly Set of the Active Transaction.

 MBEntnum - Match at Block. MBEntnum returns a 1 if there is a Transaction at Block Entnum which is in the same Assembly Set as the Active Transaction. MBEntnum returns a 0 otherwise.

Related Windows

 Blocks Window - Online view of Block dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

SUNAVAIL

A SUNAVAIL Block ensures that a Storage Entity is in the unavailable state.

SUNAVAIL A

Operand

A - Storage name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, SNA*Parameter.

 

Example

SUNAVAIL MotorPool

In this simple example, the Storage Entity named MotorPool is made unavailable when a Transaction enters this Block.

Action

An SUNAVAIL Block ensures that a Storage Entity is unavailable. This means that all Transactions requesting storage will be placed on the Delay Chain of the Storage Entity. No Transaction is permitted to enter any ENTER Block if the Storage Entity is in the unavailable state.

If the Storage Entity is already in the unavailable state, the SUNAVAIL Block has no effect.

Special Restriction

 Operand A must be the name or number of a predefined Storage Entity.

Refuse Mode

A Transaction is never refused entry to a SUNAVAIL Block.

Related Command

A Storage Entity must be defined in a STORAGE Command before it can be updated by an SUNAVAIL Block. The STORAGE Command must exist in the model, or must be sent to the Simulation Object interactively, before a Transaction can enter the SUNAVAIL Block. Any attempt to do so before the Storage Entity is defined, cases an Error Stop.

A Storage Entity can be redefined by an interactive STORAGE Command.

Related SNAs

 REntnum  - Unused storage capacity. The storage content (or "token" spaces) available for use by entering Transactions at Storage Entity Entnum.

 SEntnum - Storage in use. SEntnum returns the amount of storage content (or "token" spaces) currently in use by entering Transactions at Storage Entity Entnum.

 SAEntnum - Average storage in use. SAEntnum returns the time weighted average of storage capacity (or "token" spaces) in use at Storage Entity Entnum.

 SCEntnum - Storage use count. Total number of storage units that have been entered in (or "token" spaces that have been used at) Storage Entity Entnum.

 SEEntnum - Storage empty. SEEntnum returns 1 if Storage Entity Entnum is completely unused, 0 otherwise.

 SFentnum - Storage full. SFentnum returns 1 if Storage Entity Entnum is completely used, 0 otherwise.

 SREntnum - Storage utilization. The fraction of total usage represented by the average storage in use at Storage Entity Entnum. SREntnum is expressed in parts-per-thousand and therefore returns an real value 0-1000, inclusively.

 SMEntnum - Maximum storage in use at Storage Entity Entnum. The "high water mark".

 STEntnum - Average holding time per unit at Storage Entity Entnum.

 SVEntnum - Storage in available state. SVEntnum returns 1 if Storage Entity Entnum is in the available state, 0 otherwise.

Related Window

 Storages Window - Online view of Storage Entity dynamics.

 

TABULATE

A TABULATE Block triggers the collection of a data item in a Table Entity.

TABULATE A,B

Operands

A - Table Entity name or number. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Weighting factor. Optional. The operand must be Null, Name, Number, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

TABULATE Sales

When a Transaction enters this TABULATE Block, the Table Entity named Sales is found. Sales must have been defined in a TABLE Command. Then the statistics associated with the table are updated with no weighting.

Action

When a Transaction enters a TABULATE Block, Operand A is evaluated and used to find a Table Entity. If there is no such entity an Error Stop occurs.

The Table Entity is then updated according to the operands in the TABLE Statement. If the B Operand is used, it is evaluated and used as a weighting factor. Otherwise the factor is taken to be 1.

A further discussion of the statistics gathered by table entities may be found in Section 4.10 and Chapter12.

Special Restrictions

 A must be positive.

 B, if specified, must be positive.

 A must be the name or number of a predefined TABLE entity.

Refuse Mode

A Transaction is never refused entry to a TABULATE Block.

Related Command

A Table Entity must be defined in a TABLE Command before it can be updated by a TABULATE Block. The TABLE Command must exist in the model, or must be sent to the Simulation Object interactively, before a Transaction can enter the TABULATE Block. Any attempt to do so before the Table Entity is defined, cases an Error Stop.

A Table Entity can be redefined by an interactive TABLE Command.

Related SNAs

 TBEntnum - Non weighted average of entries in Table Entity Entnum.

 TCEntnum - Count of non weighted table entries in Table Entity Entnum.

 TDEntnum - Standard deviation of non weighted table entries in Table Entity Entnum.

Related Window

 Table Window - Online view of Table Entity dynamics.

 

TERMINATE

A TERMINATE Block removes the Active Transaction from the simulation and optionally reduces the Termination Count.

TERMINATE A

Operand

A - Termination Count decrement. Default is 0. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

TERMINATE 1

In this example, when a Transaction enters the TERMINATE Block it is removed from the simulation. Also, the Termination Count of the simulation, which is set by a START Command is decremented by 1.

Action

When a Transaction enters a TERMINATE Block, Operand A is evaluated, truncated, and used to decrement the Termination Count of the simulation. If Operand A was not specified, the Termination Count is not changed.

The Active Transaction is then removed from the simulation, and a new Active Transaction is chosen.

The Termination Count of the simulation is set by a prior START Command. When the termination count reaches 0, the simulation ends, and unless suppressed by Operand B of the START Command, the optional standard report is written.

Special Restriction

 A, if specified, must be positive.

Refuse Mode

A Transaction is never refused entry to a TERMINATE Block.

Related SNA

 TG1 - Termination Count of the simulation. This value is initialized by a START Command and indicates completion of the simulation when it becomes less than or equal to 0.

 

TEST

A TEST Block compares values, normally SNAs, and controls the destination of the Active Transaction based on the result of the comparison.

TEST O A,B,C

Operands

O - Relational operator. Relationship of Operand A to Operand B for a successful test. Required. The operator must be E, G, GE, L, LE, or NE.

A - Test value. Required. The operand must be Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Reference value. Required. The operand must be Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Destination Block number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Action

A TEST Block operates in either "Refuse Mode" or "Alternate Exit Mode". In either case, operands A and B are evaluated numerically, and compared.

If Operand C is not used, the TEST Block operates in Refuse Mode. When a Transaction attempts to enter a Refuse Mode TEST Block, and the test is unsuccessful, the Transaction is blocked, i.e. not allowed to enter the TEST Block, until the test is repeated and is successful. When the test is successful, the Active Transaction enters the TEST Block and then proceeds to the Next Sequential Block.

Blocked Transactions are placed on the Retry Chains of all entities involved in the comparison. When the state of any of these entities changes, the blocked Transaction is reactivated, the test specified by the TEST block is retried, and if successful, the Transaction is permitted to enter the TEST Block. However, the integration of User Variables does not cause blocked Transactions to be reactivated. You should use the thresholds in an INTEGRATE Command if you need to be notified about the level of one or more continuous variables. This is discussed further in Chapter 1, in the Section entitled Continuous Variables.

If Operand C is used, the TEST Block operates in Alternate Exit Mode. When a Transaction attempts to enter such a TEST Block, and the test is unsuccessful, the Transaction enters the TEST Block, is scheduled for the alternate destination Block specified by the C Operand, and is placed on the Current Events Chain in front of its priority peers. If the test is successful, the Active Transaction enters the TEST Block and then proceeds to the Next Sequential Block.

Example

TEST G C1,70000

In this example of a "Refuse Mode" TEST Block, the Active Transaction enters the TEST Block if the relative system clock value is greater than 70000. Otherwise, the Transaction is blocked until the test is true.

 

TEST G Q$Teller1_Line,Q$Teller2_Line,Teller1

In this example of an "Alternate Exit Mode" TEST Block, the Active Transaction always enters the TEST Block. If the content of the queue entity named Teller1_Line is greater than the content of the queue entity named Teller2_Line the Transaction proceeds to the NSB. Otherwise, the Active Transaction is scheduled to enter the Block at the location named TELLER1.

 

Relational Operator

The relational operator is required. It may be E, G, GE, L, LE, or NE.

The successful tests are defined as follows:

 E - The value of Operand A must be equal to the value of Operand B.

 G - The value of Operand A must be greater than the value of Operand B.

 GE - The value of Operand A must be greater than or equal to the value of Operand B.

 L - The value of Operand A must be less than the value of Operand B.

 LE - The value of Operand A must be less than or equal to the value of Operand B.

 NE - The value of Operand A must be unequal to the value of Operand B.

Special Restrictions

 C must be the location of a Block in the simulation.

 TEST Blocks are extremely powerful, however, unsuccessful testing can cause large amounts of computer time to be used. You may need to arrange your simulation to reduce the frequency of unsuccessful tests. This can be done by placing Transactions with no chance of a successful test on a User Chain using LINK and UNLINK Blocks.

Refuse Mode

A TEST Block operating in Refuse Mode will refuse entry to a Transaction when the test fails. The refused Transaction will be blocked until the test is successful.

When a Transaction is refused entry, its Delay Indicator is set and remains so until the Transaction enters a "Simultaneous" Mode TRANSFER Block. Simultaneous Mode TRANSFER Blocks are rarely used because a BOOLEAN VARIABLE can more efficiently control the coordination of the state of a number of resources when used in a TEST Block.

Related Windows

 Blocks Window - Online view of Block dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

TRACE

A TRACE Block turns on the Trace Indicator of the Active Transaction.

TRACE

Operands

None.

 

Example

TRACE

In this example, the Trace Indicator of the Active Transaction will be set and stay on until an UNTRACE Block is entered.

Action

When a Transaction enters a TRACE Block, its Trace Indicator is turned on. This causes a trace message to be sent to all Journal Windows every time the Transaction enters a new Block.

Refuse Mode

A Transaction is never refused entry to a TRACE Block.

Related Windows

∑ Journal Window - Record session events.

 Blocks Window - Online view of Block dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

TRANSFER

A TRANSFER Block causes the Active Transaction to jump to a new Block location.

TRANSFER A,B,C,D

Operands

A - Transfer Block mode. Described below. Optional. The operand must be BOTH, ALL, PICK, FN, P, SBR, SIM, fraction, Name, PosInteger, ParenthesizedExpression, SNA, SNA*Parameter, or Null.

B - Block number or location. Parameter name or number when in P Mode. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Block number or location. Increment value in FN or P Mode. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Block number increment for ALL Mode. Default is 1. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Action

A TRANSFER Block may operate in one of 9 "modes", each with different properties. When a Transaction enters a TRANSFER Block, Operand A is used to determine the mode of operation of the Block. The meaning of operands B and C depend on the mode. When you do not specify an operand which corresponds to a Block location, the next sequential Block after the TRANSFER Block is used.

Unconditional Mode

When the A Operand is omitted, the TRANSFER Block operates in "Unconditional Mode". In Unconditional Mode, the Active Transaction always jumps to the location specified by the B Operand.

TRANSFER ,New_Place

When a Transaction enters this TRANSFER Block, it is immediately scheduled for the Block at location New_Place.

 

Fractional Mode

When the A Operand is not a keyword, the TRANSFER Block operates in "Fractional Mode". In Fractional Mode, the Active Transaction jumps to the location specified by the C Operand with a probability given by Operand A. If Operand A is a nonnegative integer, it is interpreted as parts-per-thousand and converted to a fractional probability. The alternate destination is specified in Operand B, or the NSB if Operand B is omitted.

TRANSFER .75,,New_Place

When a Transaction enters this TRANSFER Block, it is proceeds to the location named NEW_PLACE with a probability of .75. The remaining times it proceeds to the Next Sequential Block. You can select which random number generator number is to be used as the source of the random number. This is set in the "Random" page of the Model Settings Notebook.

CHOOSE Edit / Settings

then select the Random page. Then fill in the desired random number stream entity number in the entry box marked "TRANSFER". The installation default is to use random number stream number 1.

 

Both Mode

When the A Operand is BOTH, the TRANSFER Block operates in "Both Mode". In Both Mode, the Block specified by Operand B is tested. If it refuses to admit the Active Transaction, the Block specified in Operand C is tested. The first Block to admit the Transaction will be the new destination. If neither Block admits the Transaction, it stays in the TRANSFER Block until it can enter one or the other.

TRANSFER BOTH,First_Place,Second_Place

When a Transaction enters this TRANSFER Block, the Block at location First_Place is tested. If the Transaction can enter, it does so. If not, the Block at location Second_Place is tested. The Transaction enters if it can. Otherwise, it remains in the TRANSFER Block until it can leave.

 

All Mode

When the A Operand is ALL, the TRANSFER Block operates in "All Mode". In "All" Mode, the Block specified by Operand B is tested. If this Block refuses to admit the Active Transaction, Blocks are tested in succession until the Block specified by Operand C is passed, unless one of the Blocks tested admits the Transaction prior to reaching the Block specified in Operand C. The location of each succeeding test Block is calculated by adding Operand D to the previous test Block location. If Operand D is not used, every Block between those specified by B and C, inclusive, are tested. If Operand C is not used, only one Block is tested. No Block with a location higher than Operand C is tested. The first Block to admit the Transaction will be the new destination. If no Block admits the Transaction, it stays in the TRANSFER Block until it can enter one.

TRANSFER ALL,First_Place,Last_Place,2

When a Transaction enters this TRANSFER Block, the Block at location First_Place is tested. If the Transaction can enter, it does so. If not, the Blocks at every second higher location are tested. The Transaction enters if it can. If all tested Blocks refuse, the testing ends with the Block at location Last_Place, or with the Block just before it, depending on the separation of First_Place and Last_Place. If no Block accepts, the Transaction remains in the TRANSFER Block until it can leave.

Pick Mode

When the A Operand is PICK, the TRANSFER Block operates in "Pick" Mode. In Pick Mode, a destination is chosen randomly.

TRANSFER PICK,First_Place,Last_Place

When a Transaction enters this TRANSFER Block, a location is chosen randomly which is numerically between First_Place and Last_Place, inclusively. The chosen location is the next destination for the Active Transaction. You can select which random number generator number is to be used as the source of the random number. This is set in the "Random" page of the Model Settings Notebook.

CHOOSE Edit / Settings

Then select the Random page. Then fill in the desired random number stream entity number in the entry box marked "TRANSFER". The installation default is to use random number stream number 1.

 

Function Mode

When the A Operand is FN, the TRANSFER Block operates in "Function Mode". In Function Mode, the destination is chosen by evaluating a function entity, specified in B, and adding an optional increment specified in C.

TRANSFER FN,Func1,5

When a Transaction enters this TRANSFER Block, the function entity named FUNC1 is evaluated, and added to 5, to determine the location of the destination.

 

Parameter Mode

When the A Operand is P, the TRANSFER Block operates in "Parameter Mode". In Parameter Mode, the Active Transaction jumps to a location calculated from the sum of a Parameter value and Operand C. If C is not specified, the Parameter value is the location of the new destination.

TRANSFER P,Placemarker,1

When a Transaction enters this TRANSFER Block, it is immediately scheduled for the Block immediately after the location specified in the Transaction Parameter named Placemarker.

 

Subroutine Mode

When the A Operand is SBR, the TRANSFER Block operates in "Subroutine Mode". In Subroutine Mode, the Active Transaction always jumps to the location specified by the B Operand. The location of the transfer Block is placed in the Parameter specified in Operand C.

TRANSFER SBR,New_Place,Placemarker

When a Transaction enters this TRANSFER Block, it is immediately scheduled for the Block at location New_Place. The location of the TRANSFER Block is placed in the Parameter named Placemarker. If there is no such Parameter, it is created.

To return from the subroutine, use a TRANSFER Block in Parameter Mode as shown above.

Simultaneous Mode

When the A Operand is SIM, the TRANSFER Block operates in "Simultaneous Mode". In Simultaneous Mode, the Active Transaction jumps to one of two locations depending on the Delay Indicator of the Transaction. If the Delay Indicator is set, the Transaction jumps to the location specified by the C Operand and the Delay Indicator is reset (turned off). If the Delay Indicator is reset (off), the Transaction jumps to the location specified by the B Operand.

The Delay Indicator of a Transaction is set when the Transaction is refused by a Block. The Delay Indicator remains set until the Transaction enters a Simultaneous Mode TRANSFER Block.

TRANSFER SIM,Nodelay_Place,Delay_Place

When a Transaction enters this TRANSFER Block, it is immediately scheduled for the Block at location DELAY_PLACE if its Delay Indicator is set, or NODELAY_PLACE if it is reset. After the transfer, the Delay Indicator is always reset.

 

TRANSFER SIM is rarely used. It is much more efficient to us a BOOLEAN VARIABLE in a Refuse Mode TEST Block when you wish to coordinate the state of a number of entities. TRANSFER SIM was originally developed before BOOLEAN VARIABLES had been added to the GPSS language.

Special Restrictions

 In All Mode, Operand C must be greater than Operand B., and if D is used (C-B) must be an even multiple of D.

 All calculated Transaction destinations must be valid Block locations.

 In Both Mode or All Mode it is possible to waste a lot of computer time on unsuccessful testing. You may want to place Transactions on a User Chain until the test is likely to be successful. This can be done by using LINK and UNLINK Blocks.

Refuse Mode

A Transaction is never refused entry by a TRANSFER Block. If a Transaction becomes blocked by refusal of destination Blocks, it remains in the TRANSFER Block.

Related Windows

 Blocks Window - Online view of Block dynamics.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

UNLINK

An UNLINK Block removes Transactions from the User Chain of a Userchain Entity.

UNLINK O A,B,C,D,E,F

Operands

O - Relational operator. Relationship of D to E for removal to occur. These choices are explained below. Optional. The operator must be Null, E, G, GE, L, LE or NE.

A - User Chain number. User Chain from which one or more Transactions will be removed. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

B - Block number. The destination Block for removed Transactions. Required. The operand must be Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

C - Removal limit. The maximum number of Transactions to be removed. If not specified, ALL is used. Optional. The operand must be ALL, Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Test value. The member Transaction Parameter name or number to be tested, a Boolean variable to be tested, or BACK to remove from the tail of the chain. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, SNA*Parameter or BACK.

E - Reference value. The value against which the D Operand is compared. Optional. The operand must be Null, Name, Number, String, ParenthesizedExpression, SNA, or SNA*Parameter. Operand E is not used if Operand D is a Boolean Variable or BACK.

F - Block number. The alternate destination for the entering Transaction. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

 

Example

UNLINK OnHold,Reentry,1

This is the simplest way to use the UNLINK Block. The first Transaction at the head of the Userchain Entity named OnHold, if any, is taken off the chain and is directed to the Block labeled Reentry. It is put on the CEC behind Transactions of the same priority. The Transaction entering the UNLINK Block proceeds to the Next Sequential Block.

 

Action

An UNLINK Block removes Transactions from a User Chain and directs them to a new Block. Transactions can be selected for removal, and a limit can be imposed on the number of Transactions removed. If there are no Transactions on the chain when the UNLINK Block is entered, the Link Indicator of the User Chain is reset. Also, the Transaction entering the UNLINK Block may be redirected according to the optional F Operand.

You may limit the number of Transactions to be removed from the User Chain by specifying the C Operand. If Operand C is omitted, ALL is assumed.

You may test each Transaction for removal by using the relational operator and/or operands D and E, both of which are evaluated numerically.

Operands D and E and the conditional operator are optional. When they are omitted, all Transactions are removed from the front of the chain, until the chain is exhausted or the limit count (Operand C) is reached.

You can use one of 3 options for Operand D. Operand D can be a Boolean variable, a Parameter number, or the word BACK. If Operand D is a Boolean variable, it is evaluated with respect to the chained Transaction, and if the result is nonzero, the chained Transaction is removed. If Operand D is BACK, Transactions are removed from the rear of the User Chain until the limit count is reached. Otherwise, the operand is evaluated with respect to the User Chain member Transaction and used as a Parameter number, whose value is returned from the User Chain member as the final result. This final value is compared to the result of evaluating Operand E.

If D specifies a Parameter and E is not used, a Parameter of the User Chain Transaction is compared to the same Parameter of the Active Transaction. If they are equal, the chained Transaction is removed from the chain.

Operand E is used if and only if the relational operator is used. In this case, Operand D is required as well. The User Chain is scanned from the front. Each Transaction, up to the limit count (Operand C), is removed if Operand D bears the same relationship to Operand E as is specified by the relational operator. If Operand E is a Transaction related SNA, it is evaluated with respect to the Active Transaction.

You may use the relational operator to specify the relationship between the Transaction attribute (Operand D) and the reference value (Operand E) which will initiate a removal of the Transaction. The default for the relational operator is E for equality. If you use no relational operator, but you use Operand D and Operand E, the values must be equal for the Transaction to be removed from the chain.

The F Operand is used to specify an alternate destination to be taken by the entering Transaction when the limit count (Operand C) cannot be reached, or when no Transactions can be removed from the User Chain. If the F Operand is not used, the entering Transaction always goes to the Next Sequential Block.

Userchain Entities have a self-contained gate called a Link Indicator. When it is off (reset), LINK Blocks which have a C Operand will not place an entering Transaction on the User Chain. The "gate" to the User Chain is "closed" when the Link Indicator is off (reset).

The Link Indicator is manipulated by both LINK and UNLINK Blocks. It is turned off when an UNLINK Block finds the User Chain empty. This condition may represent a case where the next Transaction to arrive should not wait (on the User Chain).

The Link Indicator represents the busy condition of a hypothetical resource. You can use LINK and UNLINK Blocks to handle the queuing on such a resource. A further discussion of the Link Indicator may be found in the description of LINK Blocks in this chapter.

Relational Operators

The relational operator may be E, G, GE, L, LE, or NE. If no relational operator is used, E (equality) is assumed. When the relationship is true and the limit condition has not been reached, the Transaction being tested is removed from the User Chain. The relationships are defined as follows:

 E - The Transaction attribute specified by Operand D must be equal to the reference value specified by Operand E for the Transaction to be removed from the chain.

 G - The Transaction attribute specified by Operand D must be greater than the reference value specified by Operand E for the Transaction to be removed from the chain.

 GE - The Transaction attribute specified by Operand D must be greater than or equal to the reference value specified by Operand E for the Transaction to be removed from the chain.

 L - The Transaction attribute specified by Operand D must be less than the reference value specified by Operand E for the Transaction to be removed from the chain.

 LE - The Transaction attribute specified by Operand D must be less than or equal to the reference value specified by Operand E for the Transaction to be removed from the chain.

 NE - The Transaction attribute specified by Operand D must be unequal to the reference value specified by Operand E for the Transaction to be removed from the chain.

Special Restrictions

 A, B, C, and F, if specified, must be positive.

 B and F, if specified, must be Block locations in the simulation.

 If Operand D is used but is neither a BV class SNA or BACK, and if Operand E is not used, the Parameter of the Userchain Transaction is compared to the corresponding Parameter of the Active Transaction.

 If Operand D is BACK or a Boolean variable, then you must use neither Operand E or a relational operator.

 If you use a relational operator, you must use operands D and E. D must be used, but must not be a Boolean variable and must not be BACK.

 If you use Operand E you must use Operand D.

 Operand D cannot be the literal constant 0.

 

Refuse Mode

A Transaction is never refused entry to an UNLINK Block.

Related SNAs

 CAEntnum - Average Userchain content. The time weighted average number of chained Transactions for Userchain Entnum.

 CCEntnum - Total Userchain entries. The count of all Transactions chained to Userchain Entnum.

 CHEntnum  - Current Userchain content. The current number of Transactions chained to Userchain Entnum.

 CMEntnum - Maximum Userchain content. The maximum number of Transactions chained to Userchain Entnum. The "high water mark".

 CTEntnum - Average Userchain residence time. The average duration of Transactions at Userchain Entnum.

Related Window

 Userchains Snapshot - Picture of the state of the Userchains in the simulation.

 

UNTRACE

An UNTRACE Block turns off the Trace Indicator of the Active Transaction.

UNTRACE

Operands

None

 

Example

UNTRACE

In this example, all Transactions passing through an UNTRACE Block will have their Trace Indicators unset. These Transactions will no longer produce trace messages as they move from Block to Block.

 

Action

When a Transaction enters a UNTRACE Block its Trace Indicator is turned off. Thereafter, no Block entry traces will be recorded on behalf of the Transaction unless it enters a TRACE Block.

Trace messages are sent to all open Journal Windows.

Refuse Mode

A Transaction is never refused entry to an UNTRACE Block.

Related Windows

 Journal Window - Record session events.

 Transaction Snapshot - Picture of the state of a Transaction in the simulation.

 CEC Snapshot - Picture of the state of the Current Events Chain in the simulation.

 FEC Snapshot - Picture of the state of the Future Events Chain in the simulation.

 

WRITE

A WRITE Block passes a text line to a Data Stream.

WRITE A,B,C,D

Operands

A - Text Line. Required. Evaluated as a string. The operand must be Name, Number, String, ParenthesizedExpression, SNA or SNA*Parameter.

B - Data Stream number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA or SNA*Parameter. Default is 1.

C - Alternate Destination Block name or number. Optional. The operand must be Null, Name, PosInteger, ParenthesizedExpression, SNA, or SNA*Parameter.

D - Insert Mode. Optional. The operand must be Null, ON or OFF. The default is ON.

 

Example

WRITE "New Line 20",1,Done

In this example, the WRITE Block send a text line to Data Stream number 1. If an error occurs, the Active Transaction proceeds to the Block labeled Done. Otherwise it moves to the Next Sequential Block. In this case, if the Data Stream is an I/O Stream or an In-Memory Stream, the WRITE is processed in Insert Mode.

Action

When a Transaction enters a WRITE Block, Operand A is evaluated as a string. Numeric values are converted to an ASCII string equivalent. Then the identity of the Data Stream is determined from Operand B.

If Operand B is used, it is evaluated numerically, truncated, and used as the Data Stream Entity number. This must be a positive integer. If Operand B is not used, Data Stream number 1 is assumed.

If Operand C is used, any error occurring during the WRITE causes the Active Transaction to proceed to the Block with that number.

Operand D sets the write mode, as discussed below.

In any case, if an error is detected, the error code is stored internally. A CLOSE Block can be used to retrieve the error. Chapter 4 (4.16) contains a full discussion of Data Streams, including the error code descriptions.

Write Modes

A WRITE to a Data Stream is operated in either Insert Mode or Replace Mode. The Current Line Position is used slightly differently in these two modes. The write mode is set by Operand D. If it is not used, or is ON, the WRITE is processed in Insert Mode. If it is OFF, the WRITE is processed in Replace Mode.

Insert Mode

This is the default mode for WRITE Blocks.

Action:

1. Move all text lines at, or after, the Current Line Position down one position.

2. If the Current Line Position is after the last text line, set it to just after the last text line in the Data Stream.

3. Place a copy of the new text line at the Current Line Position.

4. Increment the Current Line Position.

Replace Mode

Action:

1. If the Current Line Position is after the last text line, fill any intervening line positions with null text lines.

2. Delete any text line at the Current Line Position.

3. Place a copy of the new text line at the Current Line Position.

4. Increment the Current Line Position.

Further Discussion

Chapter 4 (4.16) contains a full discussion of Data Streams under the Section entitled, Data Streams.

Refuse Mode

A Transaction is never refused entry to a WRITE Block.

Related Blocks

 OPEN - Create a Data Stream.

 CLOSE - Shut down a Data Stream.

 READ - Retrieve a text line from a Data Stream.

 SEEK - Set the Current Line Position of a Data Stream.

 

  [Table of Contents]