Next: ASSEMBLE assembles messages in Up: No Title Previous: No Title

INSTRUCTIONS

GLIDER instructions are structured instructions characterized by a name, a list of parameters, that may be variable in length, and in many cases an associated simple or structured instruction. This last may contain certain GLIDER instructions and procedures. In this sense they are like structured instructions of general purpose languages. GLIDER instructions execute complex procedures and are translated into many basic instructions and procedure calls. They are used to create and copy messages, to manage the movements of messages, to examine and change the entry and internal lists of the nodes, to write or read files, to make graphics, etc.

In this chapter, the following conventions and definitions are used:

names of the elements of the language are put within < >. Example: <variable> means the name of a variable.
elements that can be omitted are within / /.
if an element of the language is between | it means that there are other alternatives for the element. The other alternatives are also between | and only one of them must be used. Example:
| LAST | FIRST |
in a syntactical description, means that one of the two: the word LAST, or the word FIRST, must appear.
<integer value> is an integer variable taking only positive values or a positive integer.
Examples: 3, 334, J ( J was defined as INTEGER, LONGINT, WORD or BYTE and must have a positive value).
<node> means the name of a node. If the node is multiple the name must include the index within [ ].
Examples: Machine, Carrier[3], Take are examples of node names.They must have been declared as nodes in the program (see chapters 4 and 5). The node Carrier must have been declared as a multiple node.
<list of <elements> > means a list of the items indicated by elements separated by commas.
Examples:
<list of <integer values> > may be a list as: J, 3 ,350, h.
<list of <nodes> > may be: Machine, Carrier[j], Inspect. where Machine, Carrier and Inspect were defined as nodes elsewhere. Carrier was defined as a multiple node.
the lists of messages are denoted in the program by :
| EL | IL|_<node> / (<name of predecessor node>)/
The node name of a multiple node must include the index between [ ].
If the node is of D type and has many predecessors and, for that reason, it has many EL, the name of the node must include the name of the predecessor node.
Example: EL_Machine, IL_Carrier[2], EL_Take(Queue3) are examples of list names.
The first one is the entry list of the node Machine. The second one is the internal list of the node Carrier. EL_Take(Queue3) is the EL of the node Take, that has many ELs. It indicates the name of the EL for the messages that come from the node Queue3.
<list> in the syntactical description represents the name of an IL (internal list) or EL (entry list) of messages of a node.
<associated instruction> is a <Pascal instruction> simple or structured, that is included as part of a GLIDER instruction. The associated instruction may include GLIDER functions and procedures and the GLIDER instructions that are allowed in each case. It may also be a unique GLIDER instruction or a list of GLIDER instructions and procedures between the separators BEGIN ... END.
Example:
```
                      SCAN(EL_Machine) BEGIN j := UNIF(1, 4);
                      IF a < 5 THEN SENDTO(Carrier[j])
                      END;
```
SCAN is a GLIDER instruction (see 6.21) used to scan a list of messages (in this case the EL of the node Machine). The associated instruction between BEGIN ... END is executed for each scanned message. The variable j of the message is set to the value given by the random GLIDER function UNIF. If the value of a is less than 5 the message is taken out of the EL and sent to the EL of the node Carrier[j]. Here, the associate instruction is a Pascal compound instruction (between BEGIN ... END) which contains an assignative instruction and an IF instruction containing a GLIDER instruction SENDTO.
<field> is the name of a simple or indexed variable that was declared as a field of a message.
<PASCAL instruction> is a PASCAL instruction structured or simple.
<simple PASCAL instruction> is an assignative instruction:
<variable> := <expression>; or a call to a procedure or a input or output instruction or a GOTO instruction.
<structured PASCAL instruction> is a PASCAL instruction of the type IF, CASE, WHILE, FOR, REPEAT or a compound instruction (set of instructions delimited by BEGIN ... END ). Where a simple PASCAL instruction is allowable, it is possible also to put a GLIDER instruction or a GLIDER procedure.
Example:
```
  WHILE <logical expression> DO
   BEGIN
    <GLIDER instruction>;
    IF <logical expression> THEN <GLIDER instruction>
                            ELSE <GLIDER procedure>;
   END;
```
There are restrictions, that depend on the type of node and of the GLIDER instruction, in which the GLIDER instruction or procedure is used.
Example: In the associated instruction of a GLIDER instruction SCAN it is not allowed to use another SCAN instruction. Within an associated instruction, GLIDER instructions with associated instructions are, in general, forbidden, except in the case of the associated instruction of a RELEASE and STATE instructions.
<nest of constants> is a set of simple INTEGER, REAL, CHAR or STRING constants in a nest as it is used in PASCAL to give values to indexed constants: The whole set is included within ( ); its elements are constants or successions corresponding to the successive values of the first index. Each succession is included within ( ). Each ( ) is formed by constants or successions corresponding to the successive values of the second index, etc. Successions and values are separated by commas.
Example: the array M of 3 indexes of dimension 2x3x3 formed by the two matrices of 3x3:
```
            4  5  0      1  0  1
            7  6  2      3  3  8
            1  4  3      9  6  9
```
in which the first index, that indicates the matrix, the second the line and the third the column, is represented by:
```
  (((4, 5, 0), (7, 6, 2), (1, 4, 3) ) , ( (1, 0, 1), (3, 3, 8), (9, 6, 9)))
```
The element M[2, 2, 3] has the value 8.

 <assignative instruction>, <expression>, <real expression>,
 <integer expression>, <logical expression>, <real variable>,
 <integer variable>, <boolean variable>, <character variable>

are defined as in PASCAL.

GLIDER functions may be used in the same way as PASCAL functions.
Some of the instructions and procedures (see Chapters 6 and 7) may be used in any node. They are called common instructions and procedures. They are:
ACT, BEGINSCAN, BLOCK, ASSI, CLRSTAT, DEACT, DEBLOCK, DBUPDATE, DOEVENT, DONODE, ENDSIMUL, EXTFEL, EXTR, FILE, FREE, GRAPH, INTI, IT, LOAD, MENU, NT, OUTG, PAUSE, PUTFEL, REL, REPORT, SCAN, SORT, STAT,STOPSCAN, TAB, TITLE, TRACE, TRANS, TSIM, UNLOAD, UNTRACE, UPDATE, USE.
BEGINSCAN and STOPSCAN are included here, because they can be used in any nodes as part of the associate instruction of SCAN.
<structured GLIDER instructions> are the following (a brief comment about the function is indicated) :
1. ASSEMBLE assembles various messages in a representative message.
2. ASSI assigns values to arrays and multiple nodes.
3. COPY makes copies of a message.
4. CREATE creates a message.
5. DBUPDATE updates a DBASE table.
6. DEASSEMBLE disassembles messages put together by an ASSEMBLE.
7. DOEVENT makes the associated instruction executed only one time each event.
8. DONODE makes the associated instruction executed only one time and only if the event starts in the node.
9. EXTR extracts a message from a list.
10. FILE writes values in a file.
11. GRAPH draws graphics during a run.
12. INTI allows interactive changes of data values.
13. IT schedules a new activation of the node after an Interval Time ahead the actual time.
14. LOAD imports the content of a DBASE IV table to an array.
15. NT schedules a new activation of the node at a future time.
16. OUTG writes variable and array values with titles.
17. PREEMPTION allows a message displace another message from the IL of a R type node and to put itself in that IL.
18. REL makes a message to go out of the IL of a R type node.
19. RELEASE manages the message released in a R type node.
20. REPORT allows to write an output report in a file.
21. SCAN examines a list of messages allowing changes and extractions.
22. SELECT selects messages from the different EL of a D type node.
23. SENDTO sends messages in process to lists.
24. STATE allows to change status variables and control activations of a G type node.
25. STAY indicates the time of staying of a message in the IL of a R type node and gives that value to a variable STAY.
26. SYNCHRONIZE retains a certain number of messages in the EL to release them together at the same time.
27. TSIM sets the duration of the simulation run and gives that value to a variable TSIM.
28. TITLE allows to put titles to the experiments.
29. UNLOAD releases the memory of an array used to import a DBASE IV table.
30. USE allows to define the quantity of resource to be used by a message in a R type node and puts this value in a variable USE.

In the following the syntax and function of each one of these instructions are described. A sign ; is put after each instruction. This separator may be omitted before an END or ELSE separator.

Next: ASSEMBLE assembles messages in Up: No Title Previous: No Title

domingo c
Mon Mar 20 17:36:19 PST 2000