Chi documentation

During the past decades, the ancestors of Chi have been used with success, for the analysis of a variety of (industrial) systems. Based on this experience, the language Chi has been completely redesigned, keeping the strong points of the previous versions, while making it more powerful for advanced users, and easier to access for non-experts.

Its features are:

The elementary data types are Booleans, numbers and strings. The language provides the elementary data types:

Tuple types are used for keeping several (related) kinds of data together in one variable, e.g. the name and the age of a person. A tuple variable consists of a number of fields inside the tuple, where the types of these fields may be different. The number of fields is fixed. One operator, the projection operator denoted by a dot (.), is defined for tuples. It selects a field in the tuple for reading or assigning.

Lists, sets and dictionaries are container types. A variable of this type contains zero or more identical elements. Elements can be added or removed in variables of these types. Variables of a container type are initialized with zero elements.

Sets are unordered collections of elements. Each element value either exists in a set, or it does not exist in a set. Each element value is unique, duplicate elements are silently discarded. A list is an ordered collection of elements, that is, there is a first and a last element (in a non-empty list). A list also allows duplicate element values. Dictionaries are unordered and have no duplicate value, just like sets, but you can associate a value (of a different type) with each element value.

Lists are denoted by a pair of (square) brackets. For example, [7, 8, 3] is a list with three integer elements. Since a list is ordered, [8, 7, 3] is a different list. With empty lists, the computer has to know the type of the elements, e.g. <int>[] is an empty list with integer elements. The prefix <int> is required in this case.

Sets are denoted by a pair of (curly) braces, e.g. {7, 8, 3} is a set with three integer elements. As with lists, for an empty set a prefix is required, for example <string>{} is an empty set with strings. A set is an unordered collection of elements. The set {7, 8, 3} is a set with three integer numbers. Since order of the elements does not matter, the same set can also be written as {8, 3, 7} (or in one of the four other orders). In addition, each element in a set is unique, the set {8, 7, 8, 3} is equal to the set {7, 8, 3}. For readability, elements in a set are normally written in increasing order, for example {3, 7, 8}.

Dictionaries are denoted by a pair of (curly) braces, whereby an element value consists of two parts, a 'key' and a 'value' part. The two parts separated by a colon (:). For example {"jim" : 32, "john" : 34} is a dictionary with two elements. The first element has "jim" as key part and 32 as value part, the second element has "john" as key part and 34 as value part. The key parts of the elements work like a set, they are unordered and duplicates are silently discarded. A value part is associated with its key part. In this example, the key part is the name of a person, while the value part keeps the age of that person. Empty dictionaries are written with a type prefix just like lists and sets, e.g. <string:int>{}.

Container types have some built-in functions in common (Functions are described in Functions):

To structure data the language allows the creation of new types. The definition can only be done at global level, that is, outside any proc, func, model, or xper definition.

Types can be used as alias for elementary data types to increase readability, for example a variable of type item:

Variables of type item are, e.g.:

This definition creates the possibility to speak about an item.

Types also can be used to make combinations of other data types, e.g. a recipe:

A type step is defined by a tuple with two fields, a field with name of type string, denoting the name of the step, and a field with process_time of type real, denoting the duration of the (processing) step. The step definition is used in the type recipe. Type recipe is defined by a tuple with two fields, an id of type int, denoting the identification number, and a field steps of type list step, denoting a list of single steps. Variables of type recipe are, e.g.:

An assignment statement is used to assign values to variables. An example:

This assignment consists of a name of the variable (y), an assignment symbol (=), and an expression (x + 10) yielding a value. For example, when x is 2, the value of the expression is 12. Execution of this statement copies the value to the y variable, immediately after executing the assignment, the value of the y variable is 10 larger than the value of the x variable at this point of the program. The value of the y variable will not change until the next assignment to y, for example, performing the assignment x = 7 has no effect on the value of the y variable.

An example with two assignment statements:

The values of i becomes 2, and the value of j is incremented. Independent assignments can also be combined in a multi-assignment, for example:

The result is the same as the above described example, the first value goes into the first variable, the second value into the second variable, etc.

In an assignment statement, first all expression values are computed before any assignment is actually done. In the following example the values of x and y are swapped:

The if statement is used to express decisions. An example:

If the value of x is negative, assign its negated value to y. Otherwise, do nothing (skip the y = -x assignment statement).

To perform a different statement when the decision fails, an if-statement with an else alternative can be used. It has the following form. An example:

If a is positive, variable c gets the value of a, otherwise it gets the value of b.

In some cases more alternatives must be tested. One way of writing it is by nesting an if-statement in the else alternative of the previous if-statement, like:

This tests i < 0. If it fails, the else is chosen, which contains a second if-statement with the i == 0 test. If that test also fails, the third condition i > 0 and i < 10 is tested, and one of the writeln statements is chosen.

The above can be written more compactly by combining an else-part and the if-statement that follows, into an elif part. Each elif part consists of a boolean expression, and a statement list. Using elif parts results in:

Each alternative starts at the same column, instead of having increasing indentation. The execution of this combined statement is still the same, an alternative is only tested when the conditions of all previous alternatives fail.

Note that the line # i must be greater or equal 10 is a comment to clarify when the alternative is chosen. It is not executed by the simulator. You can write comments either at a line by itself like above, or behind program code. It is often useful to clarify the meaning of variables, give a more detailed explanation of parameters, or add a line of text describing what the purpose of a block of code is from a birds-eye view.

The while statement is used for repetitive execution of the same statements, a so-called loop. A fragment that calculates the sum of 10 integers, 10, 9, 8, ..., 3, 2, 1, is:

Each iteration of a while statement starts with evaluating its condition (i > 0 above). When it holds, the statements inside the while (the sum = sum + i; i = i - 1 assignments) are executed (which adds i to the sum and decrements i). At the end of the statements, the while is executed again by evaluating the condition again. If it still holds, the next iteration of the loop starts by executing the assignment statements again, etc. When the condition fails (i is equal to 0), the while statement ends, and execution continues with the statement following end.

A fragment with an infinite loop is:

The condition in this fragments always holds, resulting in i getting incremented 'forever'. Such loops are very useful to model things you switch on but never off, e.g. processes in a factory.

A fragment to calculate z = x ^ y, where z and x are of type real, and y is of type integer with a non-negative value, showing the use of two while loops, is:

A fragment to calculate the greatest common divisor (GCD) of two integer numbers j and k, showing the use of if and while statements, is:

The symbol != stands for 'differs from' ('not equal').

The while statement is useful for looping until a condition fails. The for statement is used for iterating over a collection of values. A fragment with the calculation of the sum of 10 integers:

The result of the expression range(1, 11) is a list whose items are consecutive integers from 1 (included) up to 11 (excluded): [1, 2, 3, ..., 9, 10].

The following example illustrates the use of the for statement in relation with container-type variables. Another way of calculating the sum of a list of integer numbers:

This statement iterates over the elements of list xs. This is particularly useful when the value of xs may change before the for statement.

In this chapter the most used statements are described. Below are a few other statements that may be useful some times:

The language allows recursive functions as well as higher-order functions. Explaining them in detail is beyond the scope of this tutorial, but these functions are useful for making and maintaining sorted lists. Such a sorted list is useful for easily getting the smallest (or largest) item from a collection, for example the order with the nearest deadline.

To sort a list, the first notion that has to be defined is the desired order, by making a function of the following form:

The function is called predicate function. It takes two values from the list (two integers in this case), and produces a boolean value, indicating whether the parameters are in the right order. In this case, the function returns true when the first parameter is larger or equal than the second parameter, that is, larger values must be before smaller values (for equal values, the order does not matter). This results in a list with decreasing values.

The requirements on any predicate function f are:

(The order between x and z must be stable, even when you compare with an intermediate value y between x and z.)

These requirements hold for functions that test on <= or >= between two values, like above.

If you do not provide a proper predicate function, the result may not be sorted as you expect, or the simulator may abort when it fails to find a proper sorting order.

Data can be read from the command line or from a file by read functions. A read function requires a type value for each parameter to be read. An example:

Two values, an integer value and a string value are read from the command line. On the command line the two values are typed:

Variable i becomes 1, and string s becomes "This is a string". The double quotes are required! Parameter values are separated by a space or a tabular stop. Putting each value on a separate line also works.

Data also can be read from files. An example fragment:

Before a file can be used, the file has to be declared, and the file has to be opened by statement open. Statement open has two parameters, the first parameter denotes the file name (as a string), and the second parameter describes the way the file is used. In this case, the file is opened in a read-only mode, denoted by string "r".

Reading values works in the same way as before, except you cannot add new text in the file while reading it. Instead, the file is processed sequentially from begin to end, with values separated from each other by white space (spaces, tabs, and new-lines). You can read values of different types from the same file, as long as the value in the file matches with the type that you ask. For example, the above Chi program could read the following data from data_file.txt:

After enough values have been read, the file should be closed with the statement close, with one parameter, the variable of the file. If a file is still open after an experiment, the file is closed automatically before the program quits.

When reading from a file, the eof and eol functions can be used to obtain information about the white space around the values.

These functions can be used to customize reading of more complicated values. As an example, you may want to read the same list row value as above, but without having all the comma’s, quotes, parentheses, and brackets of the literal value [("abc", [7,21]), ("def", [8,31,47])]. Instead, imagine having a file clean_data.txt with the following layout:

Each line is one row. It starts with a one-word string, followed by a list of integer numbers. By using the eof and eol functions, you can read this file in the following way:

Each line is processed individually, where eol is used to find out whether the last value of a line has been read. The reading loop terminates when eof returns true.

Note that eol returns whether the current line has no more values. It does not tell you how many lines down the next value is. For example, an empty line inserted between the abc 7 21 line and the def 8 31 47 line is skipped silently. If you want that information, you can use the newlines function instead.

The write statement is used for output of data to the screen of the computer. Data can also be written to a file.

The first argument of write (or the second argument if you write to a file, see below) Is called the format string. It is a template of the text to write, with 'holes' at the point where a data value is to be written.

Behind the format string, the data values to write are listed. The first value is written in the first 'hole', the second value in the second 'hole' and so on. The holes are also called place holders. A place holder starts with % optionally followed by numbers or some punctuation (its meaning is explained below). A place holder ends with a format specifier, a single letter like s or f. An example:

In this example the text i equals 5 is written to the screen by the write statement. The "i equals %s" format string defines what output is written. All 'normal' characters are copied as-is. The %s place holder is not copied. Instead the first data value (in this case i) is inserted.

The s in the place holder is the format specifier. It means 'print as string'. The %s is a general purpose format specifier, it works with almost every type of data. For example:

will output the contents of xs ({1 : 5.3}).

In general, this works nicely, but for numeric values a little more control over the output is often useful. To this end, there are also format specifiers d for integer numbers, and f for real numbers. An example:

This fragment has the effect that the values of i and r are written to the screen as follows:

The value of i is written in d format (as int value), and the value of r is written in f format (as real value). The symbols d and f originate respectively from 'decimal', and 'floating point' numbers. The numbers 4 respectively 8.2 denote that the integer value is written four positions wide (that is, 3 spaces and a 5 character), and that the real value is written eight positions wide, with two characters after the decimal point (that is, 4 spaces and the text 3.14).

A list of format specifiers is given in the following table:

Finally, there are also a few special character sequences called escape sequence which allow to write characters like horizontal tab (which means 'jump to next tab position in the output'), or newline (which means 'go to the next line in the output') in a string. An escape sequence consists of two characters. First a backslash character \, followed by a second character. The escape sequences are presented in the following table:

An example is:

The result looks like:

The value of j is written at the tab position, the output goes to the next line again at the first tab position, and outputs the value of r.

Data can be written to a file, analog to the read function. A file has to be defined first, and opened for writing before the file can be used. An example:

A file, in this case "output_file" is used in write-only mode, denoted by the character "w". Opening a file for writing destroys its old contents (if the file already exists). In the write statement, the first parameter must be the file, and the second parameter must be the format string.

After all data has been written, the file is closed by statement close. If the file is still open after execution of the program, the file is closed automatically.

The language provides constant, discrete and continuous distributions. A discrete distribution is a distribution where only specific values can be drawn, for example throwing a dice gives an integer number. A continuous distribution is a distribution where a value from a continuous range can be drawn, for example assembling a product takes a positive amount of time. The constant distributions are discrete distributions that always return the same value. They are useful during the development of the model (see below).

In this chapter, the mathematical notion of stochastic distribution is used to describe how to model stochastic behavior. Simulating a model with stochastic behavior at a computer is however not stochastic at all. Computer systems are deterministic machines, and have no notion of varying results.

A (pseudo-)random number generator is used to create stochastic results instead. It starts with an initial seed, an integer number (you can give one at the start of the simulation). From this seed, a function creates a stream of 'random' values. When looking at the values there does not seem to be any pattern. It is not truly random however. Using the same seed again gives exactly the same stream of numbers. This is the reason to call the function a pseudo-random number generator (a true random number generator would never produce the exact same stream of numbers). A sample of a distribution uses one or more numbers from the stream to compute its value. The value of the initial seed thus decides the value of all samples drawn in the simulation. By default, a different seed is used each time you run a simulation (leading to slightly different results each time). You can also explicitly state what seed you want to use when running a model, see Compile and simulate. At the end of the simulation, the used initial seed of that simulation is printed for reference purposes.

While doing a stochastic simulation study, performing several experiments with the same initial seed invalidates the results, as it is equivalent to copying the outcome of a single experiment a number of times. On the other hand, when looking for the cause of a bug in the model, performing the exact same experiment is useful as outcomes of previous experiments should match exactly.

The simplest form of processes is a model with one process:

Similar to a model, a process definition is denoted by the keyword proc (proc means process and does not mean procedure!), followed by the name of the process, here P, followed by an empty pair of parentheses (), meaning that the process has no parameters. Process P contains one statement, a write statement to output text to the screen. Model M contains one statement, a run statement to run a process. When simulating this model, the output is:

A run statement constructs a process from the process definition (it instantiates a process definition) for each of its arguments, and they start running. This means that the statements inside each process are executed. The run statement waits until the statements in its created processes are finished, before it ends itself.

To demonstrate, below is an example of a model with two processes:

This model instantiates and runs two processes, P(1) and P(2). The processes are running at the same time. Both processes can perform a write statement. One of them goes first, but there is no way to decide beforehand which one. (It may always be the same choice, it may be different on Wednesday, etc, you just don’t know.) The output of the model is therefore either:

or:

After the two processes have finished their activities, the run statement in the model finishes, and the simulation ends.

An important property of statements is that they are executed atomically. It means that execution of the statement of one process cannot be interrupted by the execution of a statement of another process.

The view of a process being a wrapper around many other processes is supported by allowing to use the run statement inside a process as well. An example:

The model instantiates and runs one process DoubleP. Process DoubleP instantiates and runs two processes P. The relevance becomes clear in models with a lot of processes. The concept of 'a process in a process' is very useful in keeping the model structured.

Some models consist of many identical processes at a single level. The language has an unwind statement to reduce the amount of program text. A model with e.g. ten identical processes, and a different parameter value, is:

An easier way to write this model is by applying the unwind statement inside run with the same effect:

The unwind works like a for statement (see The for statement), except the unwind expands all values at the same time instead of iterating over them one at a time.

The following example shows the sending of an integer value between two processes via a channel. The figure below shows the two processes P and C, connected by channel variable a:

Processes are denoted by circles, and channels are denoted by directed arrows in the figure. The arrow denotes the direction of communication. Process P is the sender or producer, process C is the receiver or consumer.

In this case, the producer sends a finite stream of integer values (5 numbers) to the consumer. The consumer receives these values and writes them to the screen. The model is:

The model instantiates processes P and C. The two processes are connected to each other via channel variable a which is given as actual parameter in the run statement. This value is copied into the local formal parameter a in process P and in formal parameter b inside process C.

Process P can send a value of type int via the actual channel parameter a to process C. In this case P first tries to send the value 0. Process C tries to receive a value of type int via the actual channel parameter a. Both processes can communicate, so the communication occurs and the value 0 is sent to process C. The received value is assigned in process C to variable x. The value of x is printed and the cycle starts again. This model writes the sequence 0, 1, 2, 3, 4 to the screen.

Above, process P constructs the numbers and sends them to process C. However, since it is known that the number sequence starts at 0 and increments by one each time, there is no actual need to transfer a number. Process C could also construct the number by itself after getting a signal (a 'go ahead') from process P. Such signals are called synchronization signals, transfered by means of a synchronization channel. The signal does not carry any data, it just synchronizes a send and a receive between different processes. (Since there is no actual data transfered, the notion of sender and receiver is ambiguous. However, in modeling there is often a notion of 'initiator' process that can be conveniently expressed with sending.)

The following example shows the use of synchronization signals between processes P and C. The connecting channel 'transfers' values of type void. The type void means that 'non-values' are sent and received; the type void is only allowed in combination with channels. The iconic model is given in the previous figure, at the start of this chapter. The model is:

Process P sends a signal (and no value is sent), and process C receives a signal (without a value). The signal is used by process C to write the value of i and to increment variable i. The effect of the model is identical to the previous example: the numbers 0, 1, 2, 3, 4 appear on the screen.

A process can have more than one channel, allowing interaction with several other processes.

The next example shows two channel variables, a and b, and three processes, generator G, server S and exit E. The iconic model is given below:

Process G is connected via channel variable a to process S and process S is connected via channel variable b to process E. The model is:

The model contains two channel variables a and b. The processes are connected to each other in model M. The processes are instantiated and run where the formal parameters are replaced by the actual parameters. Process G sends a stream of integer values 0, 1, 2, 3, 4 to another process via channel a. Process S receives a value via channel a, assigns this value to variable x, doubles the value of the variable, and sends the value of the variable via b to another process. Process E receives a value via channel b, assigns this value to the variable x, and prints this value. The result of the model is given by:

After printing this five lines, process G stops, process S is blocked, as well as process E, the model gets blocked, and the model ends.

Channels send a message (or a signal in case of synchronization channels) from one sender to one receiver. It is however allowed to give the same channel to several sender or receiver processes. The channel selects a sender and a receiver before each communication.

The following example gives an illustration:

Suppose that only G and S0 want to communicate. The channel can select a sender (namely G) and a receiver (process S0), and let both processes communicate with each other. When sender G, and both receivers (S0 and S1), want to communicate, the channel selects a sender (G as it is the only sender available to the channel), and a receiver (either process S0 or process S1), and it lets the selected processes communicate with each other. This selection process is non-deterministic; a choice is made, but it is unknown how the selection takes place and it cannot be influenced. Note that a non-deterministic choice is different from a random choice. In the latter case, there are known probabilities of selecting a process.

Sharing a channel in this way allows to send data to receiving processes where the receiving party is not relevant (either server process will do). This way of communication is different from broadcasting, where both servers receive the same data value. Broadcasting is not supported by the Chi language.

In case of two senders, S0 and S1, and one receiver E the selection process is the same. If one of the two servers S can communicate with exit E, communication between that server and the exit takes place. If both servers can communicate, a non-deterministic choice is made.

Having several senders and several receivers for a single channel is also handled in the same manner. A non-deterministic choice is made for the sending process and a non-deterministic choice is made for the receiving process before each communication.

To communicate with several other processes but without non-determinism, unique channels must be used.

In the text all three conventions are used, depending on the structure of the model.

A buffer usually has a receiving channel and a sending channel, for receiving and sending items. A buffer, buffer B1, is presented in the figure below:

The simplest buffer is a one-place buffer, for buffering precisely one item. A one-place buffer can be defined by:

where a and b are the receiving and sending channels. Item x is buffered in the process. A buffer receives an item, stores the item, and sends the item to the next process, if the next process is willing to receive the item. The buffer is not willing to receive a second item, as long as the first item is still in the buffer.

A two-place buffer can be created, by using the one-place buffer process twice. A two-place buffer is depicted below:

A two-place buffer is defined by:

where two processes B1 buffer maximal two items. If each process B1 contains an item, a third item has to wait in front of process B2. This procedure can be extended to create even larger buffers. Another, more preferable manner however, is to describe a buffer in a single process by using a select statement and a list for storage of the items. Such a buffer is discussed in the next section.

An informal description of the process of a buffer, with an arbitrary number of stored items, is the following:

Next to the sending and receiving of items (to and from the buffer process) is the question of how to order the stored items. A common form is the first-in first-out (fifo) queuing discipline. Items that enter the buffer first (first-in) also leave first (first-out), the order of items is preserved by the buffer process.

In the model of the buffer, an (ordered) list of type item is used for storing the received items. New item x is added at the rear of list xs by the statement:

The first item of the list is sent, and then deleted with:

An alternative solution is to swap the function of the rear and the front, which can be useful some times.

The statement to monitor several channels at the same time is the select statement. The syntax of the select statement, with two alternatives, is:

There has to be at least one alternative in a select statement. The statement waits, until for one of the alternatives the boolean_expression holds and communication using the communication statement is possible. (When there are several such alternatives, one of them is non-deterministically chosen.) For the selected alternative, the communication statement is executed, followed by the statements in the statement_list of the alternative.

The above syntax is the most generic form, the boolean_expression may be omitted when it always holds, or the communication statement may be omitted when there is no need to communicate. The , also disappears then. (Omitting both the boolean expression and the communication statement is not allowed.) Similarly, when the statement_list is empty or just pass, it may be omitted (together with the : in front of it).

The description (in words) of the core of the buffer, from the start of this section, is translated in code, by using a select statement:

In the first alternative, it is stated that, if the buffer is not full, and the buffer can receive an item, an item is received, and that item is added to the rear of the list. In the second alternative, it is stated that, if the buffer contains at least one item, and the buffer can send an item, the first item in the list is sent, and the list is updated. Please keep in mind that both the condition must hold and the communication must be possible at the same moment.

The complete description of the buffer is:

Instead of boolean expression size(xs) > 0, expression not empty(xs) can be used, where empty is a function yielding true if the list is empty, otherwise false. In case the capacity of the buffer is infinite, expression size(xs) < N can be replaced by true, or even omitted (including the comma).

A buffer with infinite capacity can be written as:

A first-in first-out buffer is also called a queue, while a first-in last-out buffer (lifo buffer), is called a stack. A description of a lifo buffer is:

The buffer puts the last received item at the head of the list, and gets the first item from the list. An alternative is to put the last item at the rear of the list, and to get the last item from the list.

In the next example, signals are buffered instead of items. The buffer receives and sends 'empty' items or tokens. Counter variable w of type int denotes the difference between the number of tokens received and the number of tokens sent. If the buffer receives a token, counter w is incremented; if the buffer sends a token, counter w is decremented. If the number of tokens sent is less than the number of tokens received, there are tokens in the buffer, and w > 0. A receiving channel variable a of type void is defined for receiving tokens. A sending channel variable b of type void is defined for sending tokens. The buffer becomes:

Note that variables of type void do not exist. Type void only can be used in combination with channels.

A buffer for items with different priority is described in this section. An item has a high priority or a normal priority. Items with a high priority should leave the buffer first.

An item is a tuple with a field prio, denoting the priority, 0 for high priority, and 1 for normal priority:

For the storage of items, two lists are used: a list for high priority items and a list for normal priority items. The two lists are described by a list with size two:

Variable xs[0] contains the high priority items, xs[1] the normal priority items. The first item in the high priority list is denoted by xs[0][0], etc.

In the model the received items are, on the basis of the value of the prio-field in the item, stored in one of the two lists: one list for 'high' items and one list for 'normal' items. The discipline of the buffer is that items with a high priority leave the buffer first. The model is:

The buffer has two lists xs[0] and xs[1]. Received items x are stored in xs[x.prio] by the statement xs[x.prio] = xs[x.prio] + [x].

If the list high priority items (xs[0]) is not empty, items with high priority are sent. The first element in list xs[0] is element xs[0][0]. If there are no high priority items (list xs[0] is empty), and there are normal priority items (list xs[1] is not empty), the first element of list xs[1], element xs[1][0], is sent.

Note that the order of the alternatives in the select statement does not matter, every alternative is treated in the same way.

The variable time denotes the current time in a model. It is a global variable, it can be used in every model and proc. The time is a variable of type real. Its initial value is 0.0. The variable is updated automatically by the model, it cannot be changed by the user. The unit of the time is however determined by the user, that is, you define how long 1 time unit of simulated time is in the model.

The value of variable time can be retrieved by reading from the time variable:

The meaning of this statement is that the current time is copied to variable t of type real.

A process delays itself to simulate the processing time of an operation with a delay statement. The process postpones or suspends its own actions until the delay ends.

For example, suppose a system has to perform three actions, each action takes 45 seconds. The unit of time in the model is one minute (that is, progress of the modeled time by one time unit means a minute of simulated time has passed). The model looks like:

An action takes 45 seconds, which is 0.75 time units. The delay 0.75 statement represents performing the action, the process is suspended until 0.75 units of time has passed.

The simulation reports:

The three actions are done in 2.25 time units (2.25 minutes).

Adding time to the model allows answering questions about time, often performance questions ('how many products can I make in this situation?'). Two things are needed:

By extending models of the servers with time, time passes while tasks are being performed. Time measurements then give non-zero numbers (servers that can perform actions instantly result in all tasks being done in one moment of time, that is 0 time units have passed between start and finish). Careful analysis of the measurements should yields answers to questions about performance.

In this chapter, adding of passing time in a server and how to embed time measurements in the model is explained. The first case is a small production line with a deterministic server (its task takes a fixed amount of time), while the second case uses stochastic arrivals (the moment of arrival of new items varies), and a stochastic server instead (the duration of the task varies each time). In both cases, the question is what the flow time of an item is (the amount of time that a single item is in the system), and what the throughput of the entire system is (the number of items the production line can manufacture per time unit).

In this section two different types of systems are shown: a serial and a parallel system. In a serial system the servers are positioned after each other, in a parallel system the servers are operating in parallel. Both systems use a stochastic generator, and stochastic servers.

In assembly systems, components are assembled into bigger components. These bigger components are assembled into even bigger components. In this way, products are built, e.g. tables, chairs, computers, or cars. In this section some simple assembly processes are described. These systems illustrate how assembling can be performed: in industry these assembly processes are often more complicated.

An assembly work station for two components is shown below:

The assembly process server S is preceded by buffers. The server receives an item from each buffer B, before starting assembly. The received items are assembled into one new item, a list of its (sub-)items. The description of the assembly server is:

The process takes a list of channels c to receive items from the preceding buffers. The output channel b is used to send the assembled component away to the next process.

First, the assembly process receives an item from both buffers. All buffers are queried at the same time, since it is unknown which buffer has components available. If the first buffer reacts first, and sends an item, it is received with channel c[0] and stored in v[0] in the first alternative. The next step is then to receive the second component from the second buffer, and store it (c[1]?v[1]). The second alternative does the same, but with the channels and stored items swapped.

When both components have been received, the assembled product is sent away.

A generalized assembly work station for n components is depicted below. In the figure, m = n - 1.

The entire work station (the combined buffer processes and the assembly server process) is described by:

The size of the list of channels a is determined during initialization of the workstation. This size is used for the generation of the process buffers, and the accompanying channels.

The assembly server process works in the same way as before, except for a generic n components, it is impossible to write a select statement explicitly. Instead, an unwind is used to unfold the alternatives:

The received components are again in v. Item v[i] is received from channel c[i]. The indices of the channels that have not provided an item are in the list rec. Initially, it contains all channels 0 …​ size(c), that is, range(size(c)). While rec still has a channel index to monitor, the unwind i in rec unfolds all alternatives that are in the list. For example, if rec contains [0, 1, 5], the select unwind i in rec ... end is equivalent to:

After receiving an item, the index of the channel is removed from rec to prevent receiving a second item from the same channel. When all items have been received, the assembly process starts (modeled with a delay, followed by sending the assembled component away with b!v.

In practical situations these assembly processes are performed in a more cascading manner. Two or three components are 'glued' together in one assemble process, followed in the next process by another assembly process.

To model a conveyor, you have to wait until a particular point in time. The Chi language has timers to signal such a time-out. The timer is started by assigning it a value. From that moment, it automatically decrements when time progresses in the model, until it reaches zero. The function ready gives the boolean value true if the timer is ready. The amount of time left can be obtained by reading from the variable. An example:

Initially, time equals 0.0. The first action of process P is to delay the time for 10.0 time units. Now the value of time equals 10.0. Nothing happens to timer t as it was already zero. At time 10 timer t is started with the value 5.0. The output of the program is:

Timer t decrements as time progresses, and it is ready at 10.0 + 5.0 units. A process can have more timers active at the same moment.

A conveyor is schematically depicted in the following figure:

Three items are placed on the conveyor. For simplicity, assume the conveyor is 60.0 meter long and has a speed of 1 meter per second. An item thus stays on the conveyor for 60.0 seconds.

Item 0 has been placed on the conveyor 50.0 seconds ago, and will leave the conveyor 10.0 second from now. In the same way, item 1 will leave 30.0 seconds from now, and 2 leaves after 45.0 seconds. Each item has a yellow sticker with the time that the item leaves the conveyor. Based on this idea, tuple type conv_item has been defined, consisting of a field item, denoting the received item, and a timer field t, with the remaining time until the item leaves the conveyor:

The conveyor always accepts new items from channel a, and adds the item with the yellow sticker to the list. If the conveyor is not empty, and the timer has expired for the first item in the list, it is sent (without sticker) to the next process. The conveyor sends items to a process that is always willing to a receive an item, this implies that the conveyor is never blocked. Blocking implies that the items nevertheless are transported to the end of the conveyor.

In this example, items are placed on a conveyor, where the time of an item on the conveyor varies between items. Items arriving at the conveyor process, get inserted in the list with waiting items, in ascending order of their remaining time on the conveyor. The field tt in the item denotes the traveling time of the item on the conveyor:

The predicate function pred is defined by:

The conveyor process becomes:

The conveyor process works like before, except the new item is inserted in the list according to its remaining time, instead of at the rear of the list.

For systems that have simple cyclic behavior, the simulation can be 'exhaustive', for example:

This simulation sends a single product through the line, prints the flow time, and exits. (All processes end, which makes that the run statement and the model end as well.)

In this case, the answer is even obvious without running the simulation.

For other systems, it is much harder to decide when enough has been simulated. Typically, a process (E in the example below), collects values of the property of interest (for example flow time of products), until it has collected enough samples to draw a conclusion, and compute the resulting value.

After doing so, the problem arises to let all processes know the simulation should be stopped. This can be programmed in the model (such as adding channels to signal termination of the simulation to all processes). A simpler alternative is to use the exit statement, in the following way:

In process E, the average flow time is calculated and given as argument of the exit statement. At the moment this statement is executed, the model and all processes are killed, and the computed value becomes the exit value (the result) of the simulation. The real type before the name E denotes that the process may perform an exit statement returning a real value. The model runs the E process, so it may also give an exit value as result. These types are called exit type. Exit values are printed to the screen by the simulator when it ends the model simulation.

Another option is to use write to output the computed value, and use exit without argument. In that case, the exit value is of type void.

The above works nicely for single model simulations. The model is started one time, and it derives a result for a single scenario.

Often however, you want to perform several model simulations. This can be the exact same scenario when the model has stochastic behavior, or it can be with different parameter values each time (to investigate system behavior under different circumstances). In such cases, you can use an experiment, like below:

The experiment X looks just like a function, except that it has no return statement. It can however 'call' a model like a function. In the example above M(n) starts a simulation with model M and the given value for n. When the model exits by means of the exit statement (this is required!), the computed exit value of the (model) simulation is assigned to variable v. In the experiment, this value can be used for post-processing, or in this case, get printed as result value in a table.

The Scalable Vector Graphics (SVG) file format is a widely used, royalty-free standard for two-dimensional vector graphics, developed by the World Wide Web Consortium (W3C). SVG images consist of three types of objects: vector graphic shapes (rectangles, circles, etc.), raster images, and text. The benefit of vector images formats over raster image formats, is that raster images are created with a fixed size, while vector images contain a description of the image and can be rendered at any size without loss of quality.

SVG image files are stored in an XML-based file format. This means that they can be edited with any text editor. However, it is often more convenient to edit them with a drawing program that supports vector graphics, such as Adobe Illustrator or Inkscape. Most modern web browsers also support display of SVG images.

An SVG file has a tree structure; (graphical) elements are drawn in the same order as they appear in the file. Elements further down in the file are thus drawn on top of earlier elements. Also, each element has a position and size. They may have other properties like a color or a gradient as well. There are also 'administrative' elements, that can group, scale, or rotate parts of the tree. The website of Jakob Jenkov has a very nice SVG Tutorial.

The SVG visualization by the Chi simulator exploits this structure. You access the elements, and literally change the value of their properties or copy part of the tree. The Apache Batik SVG Toolkit used for drawing the SVG image at the screen notices the changes, and updates the displayed image.

By updating the SVG tree every time when the state of the simulation changes, you can display how a system evolves over time as an animated image.

The left darker green rectangle has an id with value buf0, while the right rectangle has an id containing buf1. Through the id, you can access the properties, in this case, the height, for example attr buf0.height = 50. This will set the height property of the SVG element named buf0 to 50.

The SVG visualization is not in the Chi model itself, it is an external entity. You access it by opening a 'file', and writing the commands such as above, as lines of text. The code of the buffer is shown below.

It is a normal finite buffer process, except for three additional lines. The first change is the file f = open("SVG:gbse.svg", "w"); line. It creates a connection to the SVG visualization due to the SVG: prefix of the file name. gbse.svg is the name of the .svg file described above. The 'file' should be opened for writing (since you will be sending commands to it).

The second line is the writeln(f, "attr buf%d.height = %d", num, size(xs) * 50); line, which constructs a line of text to set the height of the darker green rectangle to a value proportional to the number of elements in the buffer. There is however a vertical coordinate trick needed to make it all work.

The third line is the close(f); line at the end of the process. It closes the connection to the SVG visualization.

In SVG, the vertical coordinates run from the top of the screen to the bottom. If you just draw a rectangle, its base position (x,y) is at the top-left corner, with width going to the right of the screen, and height towards the bottom. In other words, if you change the height of a simple SVG rectangle by a program like the buffer process, the rectangle will grow downwards instead of upwards!

To make it grow upwards instead, you can

The server process code looks as follows (ignore all the writeln lines for now).

The server runs forever, starting with sampling how long it will be up (event = time + sample up). Until it has reached that time (while event > time:), it cycles through getting a product, processing it for uptime time units, and sending the product out again. After a few cycles, it has reached the event time, goes down, and waits for repair (delay sample down;). Once the machine is repaired it starts again. Visualization of the servers is discussed below.

A server is to be visualized with a circle that changes color depending on what the server is doing. Yellow means it is waiting for a product, green means processing, magenta means it is waiting to pass the finished product to the next station, and red means the machine is down. After repairing, it will continue processing.

As with the buffer process, the SVG visualization first opens a file connection to the visualizer and the SVG file with the file f = open("SVG:gbse.svg", "w"); line. The filename of the .svg file must be the same as with the buffer process (the visualizer can only show one SVG file at a time).

To display server state in the SVG visualization, we need a circle (called arc in SVG) named s_0 and s_1 (for server 0 and server 1), positioned behind its buffer. If there are not too many servers, and their number is fixed, one could simply add those arcs to the SVG file and be done with it. However, if you have a lot of servers, or you don’t know in advance how many you will have, you cannot add them beforehand, you need to construct the SVG elements 'on the fly'.

For showing the server states, arcs named s_0 and s_1 are required in SVG, which are created by copying and moving an SVG element. In this case, a server is represented by just one SVG element, so you can copy and move that one element. In general however, you want to copy several elements at the same time (for example you might want to copy graphical elements to display a work station, a server with its buffer).

SVG has group elements, where you can put any number of (graphical) elements inside. When you copy a group, you copy its entire contents. The gbse.svg file as a group called server, containing an arc element called s. The server group is copied and moved, which causes the arc element to be copied and moved as well.

Inside an SVG file, each element must have a unique id, that is, each element must have a unique name. When making a copy, the copied elements must thus also be given a new name. The entire operation is performed with sending a copy [node], [prefix], [suffix] command to the SVG visualizer. It takes the element named [node], and makes a full copy of it (all elements inside it are also copied). For each copied element the [prefix] is added in front of its id name, and the [suffix] is added behind it.

The writeln(f, "copy server, , _x%d", num); line in the Chi simulation performs the copy operation for the servers. It takes the server group element (which contains an s arc element), and adds nothing in front of the names (there is no text between the first and the second comma). It appends the names with _x0 for the first server, and _x1 for the second server. The result is thus a copy of the server group, called server_x0 or server_x1, containing an arc s_x0 respectively s_x1.

Note that the copy command performs copying, and nothing else. Since the copied element is exactly at the same position as the original, you don’t see copies. This is however fixed by a move command explained next.

You often want to position an SVG element at some point in the display. The simplest way to do that is to change its x and y attributes, much like the height attribute of the buffer rectangle was modified. Another solution is to perform a relative move, using transform/translate.

This works, until you add a transformation element that changes the coordinate system. Sometimes you do this consciously, for example adding a 'flip' transformation to fix the vertical coordinates. At other times the SVG editor may insert one, for example when you rotate or scale some part of the drawing.

The Chi SVG visualizer has a absmove [node] ([xpos], [ypos]) command to handle this case. It computes a transformation to get the top-left corner of the element named [node] at position ([xpos], [ypos]). Keep in mind that the vertical coordinate starts at the top, and goes down.

There are limitations to this command, in some case it may fail (see the reference manual for details about the command). It is recommended to use this command one time on an element to move it to a known base position. Once it is at a known position, change the x and y coordinates of a child element (to avoid disturbing the base position), to move relative to that base position. Another solution is to perform a relative move, using transform/translate.

In the Chi simulation, the writeln(f, "absmove s_x%d (%d, 325)", num, num*420+150); line moves the copied s_x0 and s_x1 arcs to the right position in the display.

With the arcs in the right position in the display, the servers can display their activities by changing the color of the fill attribute.

With enumerations, you create a new enumeration type containing a number of names (called enumeration values). The syntax is given below.

The enumeration definitions start with the keyword enum, followed by a sequence of definitions separated with a ,. Each definition associates an enumeration type name with a set of enumeration value names. For example:

The enumeration type names act as normal types, and the enumeration values are its values. The values have to be unique words.

For example, you can create a variable, and compare values like:

Note that enumeration values have no order, you cannot increment or decrement variables with an enumeration type, and you can only compare values with equality and inequality.

Type definitions allow you to assign a name to a type. By using a name instead of the type itself, readability of the program increases.

A type definition starts with the keyword type, followed by a number of 'assignments' that associate a type name with a type, separated with a ,. For further details about type names and types, see Types.

An example:

Here a lot type name is introduced that is implemented with a real number, and a batch type name is created, which is a list of lot.

These type names can be used at every place where you can use a type, for example in variable declarations:

Note that you cannot define use a type name in its own definition.

Constant definitions allow you to give a name to a fixed value to enhance readability. It also makes it easier to change a value between different experiments. For example, if you have a constant named speed, and you want to investigate how its value affects performance, you only have to change value in the constant definition, instead of finding and changing numbers in the entire program.

The syntax of constant definitions is as follows.

An example:

Here, a speed real value is defined, and recipes value, a dictionary of string to numbers. The constant names can be used at every point where you can use an expression. See the Expressions section for details about expressions.

Note that you cannot use a constant name in its own definition.

A process is an entity that shows behavior over time. A process definition is a template for such a process. It is defined as follows.

The definition starts with the keyword proc optionally followed by an exit type. The name of the process definition, and its formal parameters concludes the header. In the body, the behavior is described using statements.

Formal parameters are further explained in Formal parameters, statements are explained in the Statements section.

For example:

In the example, a process definition with the name P is defined, without parameters, that outputs a line of text when starting, and another line of text 15 time units later (and then finishes execution).

Creating and running a process is done with Sub-process statements (start or run) from another process or from a model.

If a process definition has no exit type specified, it may not use the exit statement, nor may it start other processes that have an exit type (see also Sub-process statements). Process definitions that have an exit type may use the exit statement directly (see Exit statement for details on the statement), and it may start other processes without exit type, or with the same exit type.

Since values returned by the exit statement may get printed onto the output, you may only use exit types that are printable. These are all the 'normal' data values, from simple booleans to lists, sets, and dictionaries of data values, but not channels, files, etc.

A model behaves like a process, the only difference is that a model is run as first process. It is the 'starting point' of a simulation. As such, a model can only take data values which you can write down as literal value. For example, giving it a channel or a process instance is not allowed.

Like the process, a model also has a definition. It is defined below.

The syntax is exactly the same as process definitions explained in Process definitions, except it starts with a model keyword instead. A model can be started directly in the simulator (see Software operation), or as part of an experiment, explained in Simulating several scenarios, and Experiment definitions. If the model definition has no exit type, it may not use the exit statement directly, nor may it start other processes that have an exit type. If an exit type is specified, the model may use the exit statement to end the model simulation (see Sub-process statements for details), and it may start other processes, either without exit type, or with a matching exit type.

In programs, computations are executed to make decisions. These computations can be long and complex. A function definition attaches a name to a computation, so it can be moved to a separate place in the file.

Another common pattern is that the same computation is needed at several places in the program. Rather than duplicating it (which creates consistency problems when updating the computation), write it in a function definition, and call it by name when needed.

The syntax of a function definition is as follows.

In the syntax, the only thing that changes compared with the syntax in Process definitions or Model definitions is the additional Type node that defines the type resulting from the computation.

However, since a function represents a computation (that is, calculation of an output value from input values) rather than having behavior over time, the Body part has additional restrictions.

An experiment can execute one or more model simulations, collect their exit values, and combine them into a experiment result. Its syntax is shown below.

An experiment definition has some function-like restrictions, like not being able to use sub-process statements, no communication, and no use of time. On the other hand, it does not return a value, and it can start model simulations that have a non-void exit type (Void type discusses the void type).

The definition is very similar to other definitions. It starts with an xper keyword, followed by the name of the definition. The name can be used to start an experiment with the simulator (see Software operation for details on starting the simulator). If formal parameters are specified with the experiment definition (see Formal parameters below), the experiment can be parameterized with values. Like models, an experiment can only take data values which you can write down as literal value. For example, giving it a channel or a process instance is not allowed.

The body of an experiment is just like the body of a Function definitions (no interaction with processes or time). Unlike a function, an experiment never returns a value with the Return statement.

The primary goal of an xper is to allow you to run one or more model simulations that give an exit value. For this purpose, you can 'call' a model like a function, for example:

The model above is very short to keep the example compact. In practice it will be larger, start several concurrent processes, and do a lengthy simulation before it decides what the answer should be. The experiment X makes ten calls to the model. Each call causes the model to be run, until the model or one of its processes executes the exit statement. At that point, the model and all its processes are killed, and the value supplied with the exit statement becomes the return value of the model call, adding it to total. After the ten model simulations, the experiment outputs the average value of all model simulations.

Note that the called model (or one of its started processes) must end with the exit statement, it is an error when the model ends by finishing its last model statement.

Definitions above often take values as parameter to allow customizing their behavior during execution. The definition of those parameters are called formal parameters. The syntax of formal parameters is shown below.

As you can see, they are just variable declarations (explained in the Local variables section), except you may not add an initial value, since their values are obtained during use of the definition.

To a definition, the formal parameters act like variables. You may use them just like other variables.

An example, where int x, y; string rel are the formal parameters of process definition P:

The formal parameters introduce additional variables in the process, that can be just like any other variable. Here, they are just printed to the screen. Elsewhere in the program, the definition gets used (instantiated), and a value is supplied for the additional variables. Such values are called actual parameters.

Local variables are introduced in a process or function using the following syntax.

Variable definitions start with a Type node (its syntax if explained in Types), followed by a sequence of variable names where each variable may be initialized with a value by means of the = Expression path. If no value is assigned, the variable gets the default value of the type. Use a semicolon to terminate the sequence of new variables.

Next, another set of variables may be defined by going back to the start of the diagram, and giving another Type node, or the diagram can be ended, and the statements of the process or function can be given.

An assignment statement assigns one or more values to the local variables. Its syntax is as follows.

The assignment statement computes the value of every Expression at the right. If there is one expression, its value is also the value to assign. If there are more expressions, a tuple value is constructed, combining all values into one tuple (see Tuple expression for a discussion of tuple values).

At the left, a number of Addressable blocks define where the computed value is assigned to.

An Addressable is a variable. If the variable has a tuple type (see Tuple type) a field of the tuple may be assigned only using Path 1. Similarly, if the variable is a list (see List type) or a dictionary (see Dictionary type) assignment is done to one element by using Path 2. The Expression here is evaluated before any assignment by this statement is performed. Since selected elements may also have a type that allows selection, element selection can be repeated.

After processing the element selections at the left, it is known where values are assigned to. If there is exactly one addressable at the left, its type must match with the type of the value at the right (which may be a constructed tuple value as explained above). The value gets copied into the variable (or in its element if one is selected). If there are several addressable values at the left, the number of values must be equal to the length of the tuple from the expression(s) at the right, and each field of the right tuple must pair-wise match with the type of the addressed element at the left. In the latter case, all assignments are done at the same moment.

For a few examples, a number of variable declarations are needed:

The variable declarations introduce integer variables x and y, a real number variable r, a list of 10 integers xs, a tuple t with two fields, and a function variable f.

For reasons of clarity, initialization of the variables has been omitted. Also, expressions at the right are simple values. However, you may use all allowed expression operations explained in the next chapter (Expressions) to obtain a value to assign. The first assignments show assignment of values to variables where there is one explicit value for every assigned variable:

The first assignment statement assigns 3 to x. The second assignment assigns the return value of the function call f(y) to tuple t. The third assignment assigns 4 to x and 5 to y at the same time. The fourth assignment assigns the value of x+x to the first element of the list xs, and the value of r to the v field of tuple t.

The next assignments show combining or splitting of tuples:

The first assignment assigns a new value to every field of tuple t (t.v gets the value of r, while t.w gets the value of y). This is called packing, it 'packs' the sequence of values into one tuple. The opposite operation is demonstrated in the second assignment. The value of each field of t is assigned to a separate variable. The types of the variables at the left have to pair-wise match with the field types of the tuple at the right. This assignment is called unpacking, it 'unpacks' a tuple value into its separate elements. The third assignment does the same as the second assignment, the difference is that the value at the right is obtained from a function call. The origin of the value is however irrelevant to the assignment statement.

To demonstrate the order of evaluation, the following assignment, under the assumption that variable x holds value 3:

The assignment first computes all values at the right. Since there are more than one expression, they are combined into a tuple:

Next, the addressable values are calculated:

Finally the values are assigned, x gets a new value 7, while the third element of xs gets the value of expression x+2.

The expressions at the right as well as the expressions to select elements in lists and dictionaries are always evaluated using values from before the assignment.

It is forbidden to assign the same variable or selected element more than once:

The iterative statements are shown below.

The Chi language has two statements for repeatedly executing a body (a sequence of statements), a while statement and a for statement. The former is the generic iterative statement, the latter simplifies the common case of iterating over a collection of values.

The break and continue statements change the flow of control in the iterative statements.

The choice statement, also known as 'if statement', selects one alternative from a list based on the current value of a boolean expression. The alternatives are tried in turn, until a boolean expression one an alternative yields true. The statements of that alternative are executed, and the choice statement ends. The choice statement also ends when all boolean expressions yield false. The boolean expression of the else alternative always holds.

The syntax of the choice statement is as follows.

Processing starts with evaluating the BooleanExpression behind the if. If it evaluates to true, the statements behind it are executed, and the choice statement ends.

If the boolean expression behind the if does not hold, the sequence elif alternatives is tried. Starting from the first one, each boolean expression is evaluated. If it holds, the statements of that alternative are performed, and the choice statement ends. If the boolean expression does not hold, the next elif alternative is tried.

When there are no elif alternatives or when all boolean expressions of the elif alternatives do not hold, and there is an else alternative, the statements behind the else are executed and the choice statement ends. If there is no else alternative, the choice statement ends without choosing any alternative.

An example with just one alternative:

which tests for x == 1. If it holds, x = 2 is performed, else no alternative is chosen.

An longer example with several alternatives:

This choice statement first tests whether x is equal to 1. If it is, the y = 5 statement is executed, and the choice statement finishes. If the first test fails, the test x == 2 is computed. If it holds, the statements y = 6; x = 6 are performed, and the choice statement ends. If the second test also fails, the y = 7 statement is performed.

The essential points of this statement are:

The second point also implies that for an alternative to be chosen, the boolean expressions of all previous alternatives have to yield false.

In the above example, while executing the y = 7 alternative, you know that x is neither 1 nor 2.

The sub-process statements deal with creating and managing of new processes. The statement may only be used in Process definitions and Model definitions.

The RunStartStatement block creates new processes (see Run and start statements for details), while the FinishStatement waits for a process to end (further explanation at Finish statement).

Communication with another process is the only means to forward information from one process to another processes, making it the primary means to create co-operating processes in the modeled system. The statement may only be used in Process definitions and Model definitions.

All communication is point-to-point (from one sender to one receiver) and synchronous (send and receive occur together). A communication often exchanges a message (a value), but communication without exchange of data is also possible (like waving 'hi' to someone else, the information being sent is 'I am here', but that information is already implied by the communication itself). The latter form of communication is called synchronization.

Send and receive does not specify the remote process directly, instead a channel is used (see Channel type and Channel expressions sections for more informations about channels and how to create them). Using a channel increases flexibility, the same channel can be used by several processes (allowing communication with one of them). Channels can also be created and exchanged during execution, for even more flexibility.

Setting up a communication channel between two processes is often done in the following way:

In a parent process, two channels are created, a synchronization channel sync, and a communication channel with data called dch. The channel values are given to processes P and Q through their formal parameters.

The communication statements are as follows.

The elementary communication statements for sending and receiving at a single channel are the Send statement and the Receive statement. The Select statement is used for monitoring several channels and conditions at the same time, until at least one of them becomes available.

Finally, there are a number of other useful statements.

The Delay statement waits for the given amount of time units, the Write statement outputs text to the screen or a file, the Close statement closes a file, the Return statement returns a value from a function. the Exit statement ends the execution of all processes, and the Pass statement does nothing.

The number of operators in expressions is quite large. Also, each node has an associated type, and the allowed operators depend heavily on the types of the sub-expressions. To make expressions easier to access, they have been split. If possible the (result) type is leading, but in some cases (like the ReadExpression for example) this is not feasible.

Enumeration values may be used as literal value in an expression.

See Enumeration definitions for a discussion about enumeration definitions and enumeration values.

There are two binary operators for enumeration values.

Two enumeration values from the same enumeration definition E can be compared against each other for equality (or in-equality). Example:

The literal values for the boolean data type are as follows.

The values true and false are also the only available values of the boolean data type.

The not operation is the only boolean unary operator.

The and, the or, and the equality tests are available for boolean values.

The syntax of an integer literal number is (at character level) as follows.

An integer number is either 0, or a sequence of decimal digits, starting with a non-zero digit.

There are two unary operators on integer numbers.

With the unary - operation, the sign of the operand gets toggled. The + unary operation simply copies its argument.

There are many binary operations for integer numbers, see the table below.

The divide operator / and the power operator ^ always gives a real result, integer division is performed with div. The operation always rounds down, that is a div b == floor(a / b) for all integer values a and b. The mod operation returns the remainder from the div, that is a mod b == a - b * (a div b). The table below gives examples. For clarity, the sign of the numbers is explicitly added everywhere.

The Chi simulator uses 32 bit integer variables, which means that only values from -2,147,483,647 to 2,147,483,647 (with an inclusive upper bound) can be used. Using a value outside the valid range will yield invalid results. Sometimes such values are detected and reported.

Real numbers are an important means to express values in the contiguous domain. The type of a real number expression is a real type, see Real type for more information about the type. The syntax of real number values is as follows.

There are two ways to construct real numbers, by writing a literal real number, or by using time which returns the current time in the model.

The syntax of a literal real number (at character level) is as follows.

A literal real number starts with one or more digits, and then either a dot or an exponent. In the former case, an exponent is allowed as well. Examples:

A real number always has either a dot character, or an exponent notation in the number.

Many of the integer operations can also be performed on real numbers. The unary operators are the same, except for the type of the argument.

With the unary - operation, the sign of the operand gets toggled. The + unary operation simply copies its argument.

The binary operators on real numbers is almost the same as the binary operators on integer numbers. Only the div and mod operations are not here.

With these operations, one of the operands has to be a real number value, while the other operand can be either an integer value or a real number value.

The standard library functions for real numbers contain a lot of math functions. They can be found in Real number functions.

The Chi simulator uses 64-bit IEEE 754 floating point numbers to represent real number values. Using a value outside the valid range of this format will yield invalid results. Sometimes such values are detected and reported.

Strings are sequences of characters. Their most frequent use is to construct text to output to the screen. A string literal is defined as follows.

A string literal starts with a quote character ", and ends with another quote character. In between, you may have a sequence of characters. Most characters can be written literally (eg write a a to get an 'a' in the string). The exceptions are a backslash \, a quote ", a TAB, and a NL (newline) character. For those characters, write a backslash, followed by \, ", t, or n respectively. (A TAB character moves the cursor to the next multiple of 8 positions at a line, a NL moves the cursor to the start of the next line.)

Strings have the following binary expressions.

The concatenation operator joins two strings ("a" + "bc" gives "abc").

The element access and slicing operators use numeric indices to denote a character in the string. First character has index value 0, second character has index 1, and so on. Negative indices count from the back of the string, for example index value -1 points to the last character of a string. Unlike lists, both the element access and the slicing operators return a string. The former constructs a string with only the indicated character, while the latter constructs a sub-string where the first character is at index low, the second character at index low + step, and so on, until index value high is reached or crossed. That final character is not included in the result (that it, the high boundary is excluded from the result). If low is omitted, it is 0, if high is omitted, it is the length of the string (size( lhs )). If step is omitted, it is 1. A few examples:

In the comparison operations, strings use lexicographical order.

There are also a few standard library functions on strings, see String functions for details.

Note that length of the string is not the same as the number of characters needed for writing the string literal, as shown in the following example.

Lists are very versatile data structures, the Chi language has a large number of operations and functions for them.

The most elementary list expression is a literal list. It has the following syntax.

The first line shows the syntax of an empty list. The Type block denotes the element type of the list, for example <int>[] is an empty list of integer values.

The second line shows how to write a non-empty literal list value. It is a comma-separated sequence of expressions surrounded by square brackets. The type of all expressions must be the same, and this is also the element type of the list.

Some examples:

Variable ys is assigned an empty list with integer element type. Since an empty list is the default value of a variable, xs has the same value. Variable zs is initialized with a list holding three elements.

Two list values are equal when they have the same number of element values, and each value is pair-wise equal.

Lists have no unary operators, the binary operators of lists are shown below.

The element access operator 'lhs [ rhs ] ' indexes with zero-based positions, for example xs[0] retrieves the first element value, xs[1] retrieves the second value, etc. Negative indices count from the back of the list, xs[-1] retrieves the last element of the list (that is, xs[size(xs)-1]), xs[-2] gets the second to last element, ect. It is not allowed to index positions that do not exist. Examples:

The slicing operator 'lhs [ low : high ] ' extracts (sub-)lists from the lhs source. The low and high index expressions may be omitted (and default to 0 respectively size( lhs ) in that case). As with element access, negative indices count from the back of the list. The result is the list of values starting at index low, and up to but not including the index high. If the low value is higher or equal to high, the resulting list is empty. For example:

The slicing operator with the step expression (that is, the expression with the form 'lhs [ low : high : step ] ') can also skip elements (with step values other than 1) and traverse lists from back to front (with negative step values). Omitting the step expression or using 0 as its value, uses the step value 1. This extended form does not count from the back of the list for negative indices, since the high value may need to be negative with a negative step size.

The first element of the result is at 'lhs [low ]'. The second element is at 'lhs [low + step ]', the third element at 'lhs [low + 2 * step ]' and so on. For a positive step value, the index of the last element is the highest value less than high, for a negative step value, the last element is the smallest index bigger than high (that is, boundary high is excluded from the result). The (sub-)list is empty when the first value ('lhs [ low ]') already violates the conditions of the high boundary.

Examples:

With the latter example, note that the -1 end value in xs[2:-1:-1] really means index -1, it is not rewritten!

The concatenation operator + 'glues' two lists together by constructing a new list, copying the value of the lhs list, and appending the values of the rhs:

The subtraction operator - subtracts two lists. It copies the lhs list, and each element in the rhs list is searched in the copy, and the left-most equal value is deleted. Searched values that do not exist are silently ignored. The result of the operation has the same type as the lhs list. Some examples:

The element test operator in tests whether the value lhs exists in list rhs. This operation is expensive to compute, if you need this operation frequently, consider using a set instead. Some examples of the element test operation:

There are also standard library functions for lists, see List functions for details.

Literal sets are written as follows.

The first line shows the syntax of an empty set. The Type block denotes the element type of the set, for example <int>{} is an empty set of integer values.

The second line shows how to write a non-empty literal set value. It is a comma-separated sequence of expressions surrounded by curly brackets. The type of all expressions must be the same, and this is also the element type of the set. The order of the values in the literal is not relevant, and duplicate values are silently discarded. For example:

assigns the set {-31.28, 1.0, 2.5} (any permutation of the values is allowed). By convention, elements are written in increasing order in this document.

Two set values are equal when they have the same number of element values contained, and each value of one set is also in the other set. The order of the elements in a set is not relevant, any permutation is equivalent.

Like lists, sets have no unary operators. They do have binary operators though. The operators are as follows.

The union of two sets means that the lhs elements and the rhs elements are merged into one set (and duplicates are silently discarded). Set difference makes a copy of the lhs set, and removes all elements that are also in the rhs operand. The result of the operation has the same type as the lhs set. Set intersection works the other way around, its result is a set with elements that exist both in lhs and in rhs. Some examples:

The element test of sets tests whether the value lhs is an element in the set rhs. This operation is very fast. The sub-set test does the same for every element value in the lhs operand. It returns true is every value of the left set is also in the right set. A few examples:

There are also standard library functions for sets, see Set functions for details.

Literal dictionaries are written using the syntax shown below.

An empty dictionary needs the key and value type prefix, for example <string:int>{} is an empty dictionary with strings as key, and integer numbers as value. Literal values of such a dictionary are:

The key-value pairs can be put in any order. Also, the key value must be unique. Two dictionaries are equal when they have the same number of keys, each key in one dictionary is also in the other dictionary, and the value associated with each key also match pair-wise.

The binary operators of dictionaries are as follows.

The element access operator accesses the value of a key. Querying the value of a non-existing key value is not allowed, however when used at the left side of an assignment, it acts as an adding operation. A few examples:

The + operation on dictionaries is an update operation. It copies the lhs dictionary, and assigns each key-value pair of the rhs dictionary to the copy, overwriting values copied from the lhs. For example:

The subtraction operator only takes keys into consideration, that is, it makes a copy of the lhs dictionary, and removes key-value pairs where the key is also in the rhs argument (for subtraction of lists and sets, the elements are used, instead of the keys):

As with list subtraction and set difference, the type of the result is the same as the type of the lhs dictionary.

The element test tests for presence of a key value, and the sub-set operation tests whether all keys of the lhs value are also in the rhs value. Examples:

There are also standard library functions for dictionaries, see Dictionary functions for details.

A tuple expression is a value of a tuple type (explained in Tuple type). A tuple expression literal value is written as shown below.

A literal tuple is a comma separated sequence of expressions of length two or longer, surrounded by a pair of parentheses. The number of expressions and the type of each expression decide the tuple type. For example:

The type named tup is a tuple type with a boolean field and a real field. The expression (true, 3.48) constructs the same tuple type, thus it can be assigned to variable t. Names of the fields are not relevant in this matching, for example variable declaration (and initialization) tuple(bool z; real w) u = t is allowed, since the types of the fields match in a pair-wise manner.

A field of a tuple can be accessed both for read and for assignment by the name of the field:

In the latter case, only the assigned field changes, all other fields keep the same value.

Tuples can also be packed and unpacked. Packing is assignment to all fields, while unpacking is reading of all fields into separate variables:

Packing is very closely related to literal tuples above. The difference is that packing can be done only like above in an assignment to a tuple value, while a literal tuple works everywhere.

Unpacking is very useful when the right side (t in the example) is more complex, for example, the return value of a function call, as in c, q = f();. In such cases you don’t need to construct an intermediate tuple variable.

Packing and unpacking is also used in multi-assignment statements:

The latter works due to the intermediate tuple that is created as part in the assignment.

Variables of type file are created using a variable declaration with a file type, see File type for details about the type.

You cannot write a literal value for a file type (nor can you read or write values of this type), file values are created by means of the open function in the standard library, see File functions.

You can test whether two files are the same with the binary == and != operators.

Values of type file are used for writing output to a file using the Write statement, or for reading values from a file using the read function explained in Read expression. After use, a file should be closed with a close statement explained at Close statement.

The read expression reads a value of a given type from the keyboard or from a file. It has two forms:

You can read values from types that contain data used for calculation, that is values of types bool, int, real, string, list T, set T, and dict(K:V). Types T, K, and V must also be readable types of data (that is, get chosen from the above list of types).

Reading a value takes a text (with the same syntax as Chi literal values of the same type), and converts it into a value that can be manipulated in the Chi model. Values read from the text have to be constant, for example the input time cannot be interpreted as real number with the same value as the current simulation time.

Timers are clocks that count down to 0. They are used to track the amount of time you still have to wait. Timers can be stored in data of type timer (see Timer type for details of the type).

The standard library function ready exists to test whether a timer has expired. See Timer functions for details.

Channels are used to connect processes with each other. See the Channel type for details.

Usually, channels are created by variable declarations, as in:

This creates three channels, one synchronization channel s, and two channels (c, and d) communicating integers.

There is also a channel function to make new channels:

The only binary expressions on channels are equality comparison operations.

where T can be either a normal type, or void. There has to be an overlap between the channel directions (that is, you cannot compare a receive-only channel with a send-only channel).

A distribution represents a stochastic distribution for drawing random numbers. It use a pseudo-random number generator. See Modeling stochastic behavior for a discussion how random numbers are used.

Variables of type distribution (see Distribution type) are initialized by using a distribution function from the standard library, see Distributions for an overview.

There is only one operator for variables with a distribution type, as shown below.

The sample operator draws a random number from a distribution. For example rolling a dice:

A process expression refers to a process definition. It can be used to parameterize the process that is being instantiated, by passing such a value to a run or start statement. (See Run and start statements for details on how to create a new process.) An example:

Formal parameter ab of process P is a process variable that refers to a process taking an integer parameter. The given process definition is instantiated. Since in the model definition, A is given to process P, the output of the above model is A(3).

Process instances represent running processes in the model. Their use is to store a reference to such a running process, to allow testing for finishing.

An instance variable is assigned during a start statement. (See Run and start statements for details on how to start a new process.)

The instance variable is used to test for termination of the instantiated process, or to wait for it:

Wait is a process that waits a while before terminating. In the start statement, instance variable w is set up to refer to instantiated process Wait. After assignment, you can use the variable for testing whether the process has terminated. In the example, the test result is written to the screen, but this could also be used as a guard in a select statement (See Select statement for details).

The other thing that you can do is to wait for termination of the process by means of the finish statement, see also Finish statement.

The syntax of a matrix literal value is as follows.

The literal starts with a [ symbol, and ends with a ] symbol. In between it has at least two comma-separated lists of real number values, separated with a ; symbol.

Each comma-separated list of real number values is a row of the matrix. The number of columns of each row is the same at each row, which means the number of real number values must be the same with each list. As an example:

m is a matrix with two rows and three columns. A comma separates two columns from each other, a semicolon separates two rows.

The syntax demands at least one semicolon in a literal matrix value, which means you cannot write a matrix literal with a single row directly. Instead, write a cast expression that converts a list of real numbers to a matrix with a single row. See Cast expressions for an explanation of cast expressions.

A cast expression converts a value from one type to another. The syntax of a cast expression is as follows.

You write the result type, followed by an expression between parentheses. The value of the expression is converted to the given type. For example:

The conversion from a list to a matrix (the first entry in the table) is a special case in the sense that you also need to specify the size of the resulting matrix, as in:

The expected number of rows and columns given in the first two arguments must be constant. When the conversion is performed, the length of the given list must be the same as the number of columns stated in the second argument.

The number of available conversions is quite limited, below is a table that lists them.