Using the Process Ring Simulator

Table of Contents

Overview

The simulator allows you to design a program and single step through it, displaying pictorially the processes and pipes and their relationship.

The program can send data through the pipes and trace the operation of the program.

The simulator is a Java program that uses the JELI package. Many of the parts of the simulator use this standard interface.

System and User Requirements

System requirements:

• Computer with a Java runtime environment, version 1.1 or later.
  Java 1.4.2 or later is recommended.
• You need the following files to run the simulator:
  • Ring.jar
  • Jeli.jar
  • ringconfig
  • ChainOfProcesses
  • FanOfProcesses
  • RingOfProcesses
  • TreeOfProcesses
  • runring.bat (for Windows) or runring for UNIX or Mac OSX

User requirements:

• Familiarity with running a program in a command line environment
• Some knowledge of the fork and pipe functions

If you are only interested in this simulator, you can download a zip file ring.zip that contains all of the files that you need.

Running in a non-Windows environment:
If you installed the simulator by copying the files from a CD, the scripts may not have the correct permissions to run. The convert and runring files should be executable.
The ASCII files distributed with this distribution are in the Windows format in which lines end in a carriage return followed by a line feed. It may be more convenient to have the carriage returns removed. If you are running under UNIX, Linux, or Mac OSX, it may be more convenient to have the carriage returns removed. You can remove all of the carriage returns from these files by executing the convert script.

Starting the Simulator

If you do a custom installation, you can put the jar files anywhere you want. Modify the runring.bat (Windows) or runring (Unix, Linux, Mac OSX) file so that the JARDIR1 or JARDIR2 variables points to the location of the jar files.

If the simulator does not start, make sure you have the Java runtime executables in your path. In a command window, execute:
java -version
and make sure this displays a version later than 1.0.

Basic Operation

Figure 1: The main simulator window.

The figure shows one process with arrows representing standard input and standard output.

Push the green Run Until Done button on the right side of the window and the program will step through its execution. After a few seconds the program will terminate and the screen will look like Figure 2. The rectangles represent pipes.

Figure 2: The main simulator window.

This figure illustrates why this is called the Process Ring Simulator. The processes can communicate by sending messages in a ring,writing to standard output and reading from standard input.

To exit the simulator, push the pink Quit button that is in the upper right corner of the the yellow ring diagram.

To start the program from the beginning, find the Reset button in the second column of buttons under the diagram.

Figure 1 shows a diagram of the simulator window when the simulator first starts up, or after the Reset button has been pushed. The large yellow area in the upper left part of the window is used for a diagram of the processes.

Each process is represented by a circle with its process ID in the center. The first process ID is always 100 and as processes are created by executing fork calls, the process IDs are incremented, assuming no other processes are created in the system. Arrows out of the process represent file descriptors that can be used for output. Arrows into the process represent file descriptors that can be used for input. By default, standard error is not displayed since it clutters the diagram.

When a pipe call is executed, a rectangle representing the pipe is displayed with two new file descriptors connected to the process. A dup2 call moves the file descriptor arrows appropriately and the fork call creates a new process. When processes and pipes are created, they are positioned so that when the standard program is run, the processes and pipes will appear in a ring. The processes and pipes can be moved around on the screen by dragging them with the mouse. The pipes can be rotated by dragging close to the corner of the pipe rectangle. The numbers that represent the file descriptors can also be dragged.

To the right of the diagram is the program window. This is a Jeli Text Display which shows the program being executed. The arrow that starts out at the top is above the instruction to be executed next. The process ID of the active process is shown in the Execute: pid button at the top of this window. Clicking on this button will cycle through the active processes. Just below the program window are 5 labels showing the name of the program (if it has one, the default program being called Ring of Processes) and the values of the local program variables. These include the integers childpid and i, the fd and fd1 arrays and the contents of the buffer, buf.

Below the diagram and the program are 6 columns of buttons for controlling the simulation.

There are two basic ways of running the program.

The green Run Until Done button on the rightmost column of buttons will start the program running and automatically step through the program at a given rate. The rate can be modified using the light green slider labeled Delay that is located below the button. The delay is in milliseconds and represent the amount of time the simulator pauses after each step is displayed. The limiting factor on the speed of execution is the time it takes to redisplay after each step. The slider is a standard Jeli slider. When the Run Until Done button is pushed, it changed to a Stop Running button which can be used to stop the execution. In this mode of operation, the scheduling of the processes is controlled by the third column of buttons as described later.

The green Execute button executes one line of code. This can be used to single-stop through the program. After each instruction is executed, you may push the Execute: pid button at the top of the program to change which process will be executed next.

Simple Program Modifications

The Change Program button uses a Jeli Popup List to present a list of loadable programs. The standard programs normally distributed with the simulator include the ring, a process fan, and a process chain. Choosing one of these resets the program to the chosen one. It is possible to have your own programs listed here. Each program listed corresponds to one line in the configuration file ringconfig. Adding lines to this file allows you to choose additional programs. Programs can be created using a standard text editor or by the simulator. Information on the format is in the section Creating Programs.

The break button allows you to cycle through possibilities for breaking out of the main for loop of the program. The table below gives the relationship between the Break button and the code that is used:

The Reset button starts the program from the beginning again.

Scheduling

The After fork: button controls which process executes after a fork. The possibilities are parent, child, either, and random. Either means that either the child or parent will execute and the choice is made randomly with equal probability. Random means that any ready process can execute and the choice will be made among the ready processes with equal probability.

The Choose Process button controls which process will execute next when the running process loses the CPU. A process can lose the CPU by having its quantum expire, by blocking on a wait for child call, by blocking on a read from a pipe, or by terminating. The choices are FCFS (the process that entered the ready queue first is chosen), Next (the ready process with the next highest PID is chosen) and Random (a random ready process is chosen). The Scheduling button controls the process scheduling algorithm. The default is no preempt in which a process runs until it blocks or terminates. When RR is chosen, round robin scheduling is used and a slider appears below the scheduling button allowing am integer quantum to be set. The quantum represents the number of instructions to be executed before the process loses the CPU. When Random is chosen, a slider appears below the scheduling button allowing a probability to be set. This represents the probability that a process will lose the CPU after executing an instruction.

To the right of the Scheduling button is the Print button. The default is Print Atomic in which the output of fprintf is assumed to be atomic. If Print Not Atomic is chosen, a probability slider appears which gives the probability of losing the CPU after each character of the fprintf is output.

Displaying Information

There are several ways to display information about the state and history of the simulation. Most of these are controlled by the Display Info button at the top of the 5th column of buttons. Clicking on this brings up a Jeli Popup List to list some items that can be displayed. Some of these items may be disabled if the corresponding information is not available.

The list of display options includes:

• Display Output to show the output generated by the fprintf instructions. Each process has a color associated with it and the output of each process is shown in the color of that process. The output can be displayed entirely in black by pushing the Color button at the bottom of this frame. This changes the button to a Black and White button. Pushing it again will change the display back to color. The processes in the main diagram can also be displayed in color by pushing the pick Black button that is in the lower right corner of the diagram window.
• Display Process Info shows information about all processes including the process ID, the original parent process ID (the ID of the process that created it), the actual parent process ID as reported by getpid() (that may be the ID of the init process) and the current process state. The state will be one of: Running, Ready, Waiting for child, Read Blocked, Semaphore Blocked, Zombie, or Done.
• Display History will display a list of all instructions executed. Each instruction is preceded by the process ID of the process executing the instruction.
• Display Gantt Chart displays a Gantt chart showing the state history of each of the processes.
• Variables displays the values of the variables for each process.
• Semaphores displays each semaphore and either its value or the list of waiting processes.
• Frames displays all of the frames created by the Frame button.
• Commentary displays the commentary for the current programs if these is one.

You can show information about a particular process by clicking on the circle representing that process in the yellow display window. This pops up two windows, one showing the history (instructions executed) of that process and one showing the current values of the variables for that process.

In addition, a frame containing information about a given pipe can be displayed by clicking on the pipe in the diagram. Two Jeli Text Displays appear, the upper one containing the current contents of the pipe and the lower containing a history of everything that has been read from the pipe.

Program Format

<instructions>
for (i=1;i<nprocs;i++) {
    <instructions>
    if (childpid = fork()) {
         <instructions>
    }
    else {
         <instructions>
    }
    <instructions>
    <optional conditional break instruction>
}
<instructions>

The program assumes the following data:

int i;
int childpid;
int fd[2];
int fd1[2];
char buf[BUFSIZE];

A subset of the supported instructions that can be added on the fly from inside the simulator is given below:

pipe(fd);
pipe(fd1);
dup2(fd[0],0);
dup2(fd[1],1);
dup2(fd1[0],3);
dup2(fd1[1],4);
close(0);
close(1);
close(fd[0]);
close(fd[1]);
close(fd1[0]);
close(fd1[1]);
wait(null);
fprintf(stderr,"This is Process %d with parent %d\n",getpid(),getppid());
sprintf(buf,xxx);
sprintf(buf+strlen(buf),xxx);
fprintf(stderr,"%s",buf);
write(1,buf,strlen(buf)+1);
read(0,buf,BUFSIZE);
read(0,buf+strlen(buf).BUFSIZE);

i
nprocs
childpid
getpid()
getppid()

• The buffer, buf is of unlimited size and the instructions guarantee that it will always contain a string.
• Pipes are of unlimited size and writes to a pipe are atomic.
• Reads from a pipe are atomic and a read will read everything in the pipe.
• A read from a pipe will block only if the pipe is empty and there are processes that have the pipe open for writing.
• A write to a pipe will always write the full amount requested unless there are no processes that can read from the pipe. In this case a SIGPIPE signal is simulated and the process terminates.
• The program does not check return values of system calls and so no error checking is done. If an error occurs such as a dup2 with improper argument or a write to a closed or never opened file descriptor, the operation is ignored.
• No operations are performed on standard error except with the fprintf instructions. A write, close, or dup2 on standard error will produce undetermined results.

Changing The Program

The first button in the third column is the Mode button. It starts with Mode: Execute which allows for the running of the program. Clicking on this button changes it to Mode: Program and 6 new buttons appear below it. The first two buttons can be used to move the pointer up and down. The pointer is shown as an arrow in the program window in the upper right part of the main display. The next two buttons can be used to add a new instruction to the program after the pointer or to delete the instruction after the pointer.

The Add Instruction pops up a menu listing the possible instructions to add. The Delete Instruction button is active only when there is a valid instruction after the pointer. Some instructions cannot be deleted such as the for loop, the if (childpid=fork()) and the else.

The next button allows most instructions to be modified by conditionals such as if (i==1) or if (i!=1). These are most relevant after the for loop because at this point only the original parent has i=1.

To run the modified program, click on the Mode button again to return to execute mode.

The current program can be saved using the yellow Save Program button in the first column of buttons. This saves the program using the file name given in the button below. You can change the name of the file to be used by clicking on this Name: button which is a Jeli Value Button.

By adding a program line to the ringconfig file, these programs can be accessible to later runs of the simulator.

Creating Programs

This section describes the original ring interface. Information about the enhanced interface can be found here.

A program file can be created using the simulator with the Save Program button discussed above. The ringconfig file should contain a program line for each file that can be chosen from the Change Program menu. These files can be created or modified using a standard text editor. When such a file is read into the simulator, it encodes each line of the file using an internal format representing the type of instruction represented by that line. It is not necessary for each line to be a faithful representation of the corresponding instruction. In fact, the simulator looks for key phrases in the instruction to determine which of the allowed instructions it is.

If you want to create a program using a text editor rather than from the simulator, the simulator may not interpret it exactly as you intend. It is best to start with a simulator-created program similar to the one you want and modify it. Loading it into the simulator and saving it will put it into a correct format and tell you how the simulator interpreted your input. Look at the results and make sure that the program generated is the one you want. You can use the following information as a guideline for creating your program.

The format of a program file is as follows:
<pseudocode lines each beginning with #>
<instructions>
<a for loop instruction>
<instructions>
<an if(childpid = fork) instruction>
<instructions>
<an end group instruction>
<an else instruction>
<instructions>
<an end group instruction>
<instructions>
<an optional break instruction>
<an end group instruction>
<instructions>

• Any line starting with a # will be interpreted as a line of pseudocode.
• Lines beginning with if ( or if( first have their conditionals removed. However, if (childpid") == -1, if (!childpid") == -1) and instructions containing fork are treated in a special manner.
• Any line containing =random( is interpreted as assigning a variable to a random number.
• Any other line containing the name of a variable is a fork instruction if the line also contains fork(), an assignment statement if it contains =, and increment if it contains ++ or a decrement if it contains --. An assignment statement can have either a variable or a numeric constant on the right side.
• Any line containing a wait(null) is a wait (for child) instruction.
• Any other line containing wait( is a semaphore wait instruction and must have the name of a valid semaphore after the wait.
• Any line containing signal( followed by the name of a semaphore is a semaphore signal instruction.
• Any line containing the string for and not containing the string fork will be interpreted as a for loop instruction.
• Any line containing the string fork will be interpreted as the if (childpid=fork) { instruction.
• Any line containing a closed brace (}) will be interpreted as an end group instruction.
• Any line containing else will be interpreted as the else { instruction.
• Any line containing (childpid) will be interpreted as the instruction: if (childpid) { instruction.
• Any line containing (!childpid) will be interpreted as the instruction: if (!childpid) { instruction.
• An optional break instruction consists of one of the following:
  • a line containing the string break
  • A line containing (childpid) followed by a line containing the string break will be interpreted as
    if (childpid) break;
  • A line containing (!childpid) followed by a line containing the string break will be interpreted as
    if (!childpid) break;
• Any instruction line can start with either if(i==1) or if(i!=1).

• A line containing sprintf(buf," is interpreted as the sprintf(buf,"xxx",...) instruction.
• A line containing sprintf(buf+strlen(buf)," is interpreted as the sprintf(buf+strlen(buf),"xxx",...) instruction.
• If the "xxx" contains up to 4 %d substrings, it should have the correct number of additional parameters.
• A line containing pipe will be interpreted as the pipe(fd1[]) instruction if the line contains the character 1 anywhere and pipe(fd[]) otherwise.
• A line containing dup2 fill be interpreted as a dup2 instruction. The possibilities are:
  • dup2(n,m) if no fd appears in the line.
  • dup2(fd[n],m) if fd[ appears before the comma.
  • dup2(m,fd[m]) if fd[ appears after the comma.
  • dup2(fd[n],m) if fd1[ appears before the comma.
  • dup2(m,fd[m]) if fd1[ appears after the comma.
  • n and m can be any integer values.
• A line containing close( will be interpreted as:
  • close(n) if no fd appears in the line
  • close(fd[n]) if fd[ appears in the line
  • close(fd1[n]) if fd1[ appears in the line
• A line containing write( will be interpreted as
  • write(n,buf,strlen(buf)+1) if no fd appears in the line
  • write(fd[n],buf,strlen(buf)+1) if fd[ appears in the line
  • write(fd1[n],buf,strlen(buf)+1) if fd1[ appears in the line
• A line containing read( and not strlen will be interpreted as
  • read(n,buf,BUFSIZE) if no fd appears in the line
  • read(fd[n],buf,BUFSIZE) if fd[ appears in the line
  • read(fd1[n],buf,BUFSIZE) if fd1[ appears in the line
• A line containing read( and strlen will be interpreted as
  • read(n,buf+strlen(buf),BUFSIZE) if no fd appears in the line
  • read(fd[n],buf+strlen(buf),BUFSIZE) if fd[ appears in the line
  • read(fd1[n],buf+strlen(buf),BUFSIZE) if fd1[ appears in the line
• A lint containing fprintf(stderr, will be interpreted as print to standard error and an attempt will be made to parse the rest of the command into a format specification and a parameter list.
• Otherwise, a line containing print and buf will be interpreted as fprintf("%s",buf);.

• #int varname defines an integer variable.
• #char varname defines a character variable.
• #shared int varname val defines a shared integer variable initialized to val..
• #shared char varname val defines a shared character variable initialized to val.
• #semaphore varname n defines a semaphore variable initialized to n.

• #FD2 on turns on the display of FD 2.
• #FD2 off turns off the display of FD 2.
• #FD on turns on the display of file descriptor arrows.
• #FD off turns off the display of file descriptor arrows.
• #parent on turns on the display of arrow from parent to child.
• #parent off turns off the display of arrow from parent to child.
• #name programname sets the program name to programname. This is displayed below the program code.
• #nprocs n sets the variable nprocs in the program to the given value.
• #npositions n sets the positions of the processes and pipes int the display so they they form a circle with n of each distributed evenly.
• #fork parent after a fork, the parent continues executing.
• #fork child after a fork, the child continues executing.
• #fork random after a fork, a random process executes next.
• #scheduling FCFS sets FCFS scheduling
• #scheduling RR n sets round robin scheduling with quantum n.
• #scheduling random p sets random scheduling with probability p.
• #info n sets the number of lines for processes in the Process Info frame to n.
• #size small set the display for small processes and pipes.
• #size large set the display for large processes and pipes.
• #label variablename sets the display to label each process by the value of this variable rather than its process ID.
• #prompt s where s is any string. This will cause s to act as the system prompt and sent to standard error when the original process terminates.
• #print atomic set printing to be atomic.
• #print n set printing to be not atomic with probability of losing the CPU after each character printed to be n. The value of n must be between 0.0 and 1.0.
• #noring Causes the program not to have the default ring structure.
• #com { Start a commentary paragraph. The paragraph starts on the next line and continues until there is a line containing only a }. Any number of commentary paragraphs can be entered with additional #com commands.
• #comparskip Causes the commentary to skip lines between paragraphs.
• #comnoparskip Causes the commentary to not skip lines between paragraphs.
• #comparindent n Indent each commentary paragraph by n spaces.

Local Logging

Initially, these buttons are used to control the logging functions before the log file is open or after it is closed. The first button opens the log. When the log file is successfully opened most of the buttons change their function to control the log functions appropriate when logging is in progress.

While the log is closed, the second button toggles between the modes Replace Old Log and Append to Log. In the former case, opening the log file overwrites any file with the same name that already exists. In the latter case, the new log is appended to the old one. The third button can be used to change the name and directory used for storing the log file. Pushing this button pops up a dialogue box in which the user can change the directory and log file names. The names of the files for storing the graph image files created by the simulator can also be changed.

The Show Remote Log button can be used to pop up a browser window containing the log file generated when the log is stored remotely.

After the log is successfully opened, the Open Log button changes to Close Log, the second button changes to Log Comment, and the third button changes to Stop Log.

Close Log terminates logging and closes the log file. Stop Log temporarily stops adding information to the log file but keeps the log file open. When pushed, this button changes to Start Log which resumes the logging.

The Log Comment button pops up a window which allows the user to enter comments into the log file.

The Log Image button puts a copy of the currently displayed diagram in the log file.

Most of the frames that display history information have there own Log buttons which becomes active when the log is open and stores the information displayed in the log file. The program window on the right side of the main simulator window also has a Log button which can put a copy of the program in the log file. The Gantt charts can also be logged.

Configuration

The configuration file contains lines which can be used to set values for various simulator parameters.

The following configuration parameters are supported:

• user username sets the name displayed in the log file to username
• size n sets the size of the diagram to at least n by n pixels.
• directory dirname sets the directory for containing the log file to dirname
• nprocs n sets the value of the nprocs program variable to n.
• rundelay n sets the delay between running steps to n milliseconds.
• program filename causes the simulator to read in the program with the given filename. The name appears in the list under the Change Program menu. There may be several of these lines in the configuration file.
• infosize n sets the initial number of lines for processes in the Process Info frame to n.
• positions n sets the number of positions for processes around the circle to be n.
• small sets the diagram to use small processes and pipes.
• large sets the diagram to use large processes and pipes.
• showFD true turns on the display of all file descriptor arrows.
• showFD false turns off the display of all file descriptor arrows.
• showFD2 true turns on the display of the standard error file descriptor arrow.
• showFD2 false turns off the display of the standard error file descriptor arrow.
• parent-child true turns on the display of the arrow from parent to child.
• parent-child false turns off the display of the arrow from parent to child.
• nopreempt sets the scheduling to non-preemptive.
• quantum n sets the scheduling so that a process loses the CPU after executing n instructions.
• random p sets the scheduling so that with probability p a process loses the CPU after executing an instruction.
• FCFS sets the scheduling so that the process chosen from the ready queue is the one that arrived first.
• inorder sets the scheduling so that the process chosen from the ready queue is the one with the next larger process ID after the current process.
• outoforder sets the scheduling so that a random process is chosen from the ready queue.
• fork parent allows the parent to continue executing after a fork.
• fork child causes the child process to execute after a fork.
• fork either causes either the parent or child process to execute with equal probability after a fork.
• fork random causes a random process from the ready queue to execute after a fork.
• remoteport n sets the port for remote logging to n. This would not normally be used.
• prompt pmt sets the default prompt output when the original process
• comfont n sets the default size for the commentary font to n.
• comrows n sets the default number of rows for the commentary frame to n.
• comcolumns n sets the default number of columns for the commentary frame to n.

Widget List

Individual Buttons
Button	row	col	Description
Logging Buttons			These 5 multiuse buttons have a light blue background and are located in the first column of buttons. The log file is in HTML format and can be displayed and printed from a standard browser.
Open Log	1	1	Open the log file. After the log is opened, the button changes to a Close Log button.
Close Log	1	1	Close the log file. After the log is closed, the button changes to an Open Log button.
Replace/Append Old Log	2	1	This button is available when the log file is not open. It toggled between the two modes for opening a log file. When in the replace mode, opening the log file will replace an older log file with the same name. When in append mode, the new log information is appended to the old file. This button changes to Log Comment when the log file is opened.
Log Comment	2	1	Pop up a frame allowing you to put a comment into the log file. The frame contains two windows. You can type into the bottom window to enter text to be placed into the log file. Pushing the Log button at the bottom of the frame enters the text into the log file. The upper window displays all comments previously logged. This button is available only when the log file is open. It changes to the Replace/Append Old Log button when the log file is closed.
Change Log Filename	3	1	Pop up a window allowing the user to enter a name for the log file. You can change the name of the log file, the directory for storing the log file, and the name used for storing images created, such as the diagram and Gantt chart. Click on one of the entries to change it. Push return when done editing the entry. The mouse must be inside of the entry while it is being edited (the background becomes cyan). When finished making the changes, push the red Done button. This button is available only when the log file is closed. It changes to the Stop/Start Log button when the log file is opened.
Stop/Start Log	3	1	This button toggle between two modes which allow automatic logging to occur. This simulation does not support automatic logging, so this button should not be used. This button is available only when the log file is open. It changes to the Change Log Filename button when the log file is opened.
Show Remote Log	4	1	This button is only active when remote logging is used. This is only the case when the simulator is run from a browser with the log file placed on a remote web site.
Log Image	5	1	Put a copy of the main diagram into the log file. This may take a while depending on the size of the diagram and the speed of the machine it is running on. This button is only active when the log file is open.
Program Save Buttons			These 2 buttons have a light yellow background and are used for saving a copy of the current program on disk. They are located in the first column of buttons.
Save Program	6	1	Save a copy of the current program in a disk file. The name of the file is set with the Name: button below it. The program is saved in a readable format and can be loaded back into the program the next time it is run by placing a program filename line in the configuration file.
Name: filename	7	1	Show and change the name of the file used for saving the current program. To change the name, click on this button. A cursor will appear at the end of the name. Keep the mouse pointer inside the button (the background becomes cyan) while changing the name. Only the printing character keys and the backspace key can be used. When done, push return and the cursor should disappear. To abort, click on the button with the mouse.
Miscellaneous Buttons			These 6 buttons in the second column generally relate to the program.
Onedirectional	1	2	Replace the current program with a standard one-directional ring program. This program is always available independent of the contents of the configuration file.
Bidirectional	2	2	Replace the current program with a two-directional ring program. This button may be disabled in some versions of the program.
Change Program	3	2	This pops up a window giving giving a list of programs that have been loaded from disk files. Each entry corresponds to a program filename line in the configuration file. At the bottom of the list are two additional choices. Make Persistent keeps the list active even after a choice is made. Cancel aborts changing the program.
Break: which	4	2	Change the last lines in the for loop. These lines determine which process breaks out of the loop. The possibilities are: break: parent (the parent breaks out using if (childpid) break; break: child (the child breaks out using if (!childpid) break; break: both (both parent and child break out of the loop using break; break: neither (neither parent nor child break out of the loop)
Reset	5	2	Reset the program so that it will start from the beginning.
Refresh	1	4	Refresh the display of the diagram. This should automatically occur when necessary, so this button might never have to be used.
Reset Positions	2	4	Reset the positions of the processes and pipes to their standard position for the ring of processes. It uses the current value of nprocs to place the processes and pipes in a circle.
Reset Positions Center	3	4	This is identical to Reset Positions except that the first pipe created is put in the center of the display.
Mode: Execute/Program	1	3	This button toggles between execute mode (in which the program can be run) and program mode (in which the program can be modified). A number of buttons in the third and fourth column change their function in these two modes. In execute mode the buttons control the process scheduling. In program mode they allow modification of individual lines of the program.
Execute Mode Buttons			These buttons are active when the simulator is in execute mode.
After fork: which	2	3	This button controls which process executes after a fork occurs. Pushing the button cycles through 4 possibilities. The possibilities are: parent: the parent continues executing after the fork. The child is ready. child: the child executes after the fork and the parent is ready. either: one of the parent or child is chosen at random to execute and the other is ready. random: both the parent and child become ready and a random ready process is chosen to execute.
Choose Process: how	3	3	This button controls which process executes when the current process loses the CPU. Pushing the button cycles through 3 possibilities. The possibilities are: FCFS: the process that entered the ready queue first is chosen. Next: the process in the ready queue with the next highest process ID after the current process is chosen. Random: a random process is chosen from the ready queue.
Scheduling: which	4	3	This button controls when a process loses the CPU. Pushing the button cycles through 3 possibilities. The possibilities are: nopreempt, RR, and random. RR refers to round robin scheduling and when this is chosen, an additional slider widget appears below this button. The slider controls the quantum. Here the quantum refers to the number of instructions executed before the process is preempted from the CPU. The slider widget consists of three parts. The first part is three buttons controlling the values and range of the slider. Next is a label giving the value of the quantum. Finally there is the slider for changing the quantum value. Random scheduling refers to having the running process lose the CPU with a given probability after executing an instruction. When this is chosen a similar slider appears, this on controlling the probability.
Print Atomic	4	4	This button controls the atomic nature of the fprintf instruction. When the mode is print atomic, this printing is done atomicly so the process will not lose the CPU during printing. Pushing this button changes the mode to print not atomic. A probability widget appears below that controls the probability that a process will lose the CPU after each character is output by the fprintf statement.
Program Mode Buttons			These buttons are active when the simulator is in program mode. In program mode the arrow in the program display points to the instruction below the arrow.
Pointer Up	2	3	Move the pointer up one instruction.
Pointer Down	3	3	Move the pointer down one instruction.
Add Instruction	4	3	Bring up a menu of instructions that can be added below the arrow. Click on one of the instructions to add it. For the sprintf instructions you will be prompted to enter a string. This string may contain up to 4 %d format specifications. For each one you will be prompted for a variable to print.
Delete Instruction	5	3	Delete the instruction below the pointer arrow. This button will be active only if the instruction after the pointer can be deleted.
Change if(...)	6	3	Allows you to change the conditional on the given instruction, either by adding a conditional or removing one.
New Variable	7	3	Allows you to create a new integer variable.
Diagram Modification Buttons			These buttons are located in the 3rd and 4th rows of the 5th column. They control the diagram display.
Show FD:	2	5	This button cycles through three states: not 2: Show file descriptor arrows except for standard error all: Show all file descriptor arrows none: Show no file descriptor arrows
Show: Pipes and Procs Show: All Show: Parent-Child Show: Processes only	3	5	This button cycles through these four states.
size:	6	5	This button toggles between large and small. It controls the size of the circles and rectangles used for the processes and pipes. The small setting is appropriate when more than 6 processes are displayed.
Execute Program Buttons			These buttons in the 6th column have a a green background and are used for running the program.
Run Until Done	1	6	Start running the program and continue until there are no processes ready. When this button is pushed it is changed to a Stop Running button which stops the execution.
Execute	2	6	Execute one instruction of the program.
Delay Slider	3-5	6	Set the delay between executing one instruction to another. The delay is measured in milliseconds.
Miscellaneous Parameter Buttons			These buttons in the 6th column.
nprocs:	5	5	Click on this button to change the value of the nprocs program variable.
positions	6	5	Click on this button to change the number of process positions around the circle containing the processes and pipes.
info size	7	5	Click on this button to change the initial number of process lines displayed int the Process Info frame.

Enhanced Program Structure

A number of additional instructions are available including nested while loops and conditionals.

Any number of integer or character variables can be declared with the #int and #char pseudo instructions. Currently there is no distinction made between integer and character variables. The following instructions can be used with variables. Here, var and var1 refer to the predefined variables (childpid, i) and any variable explicitly declared. In addition, the constant nprocs can be used in places where it is not modified, as in the right side of an assignment or in a write statement. Also, const refers to a numeric constant such as 0 or 17.

Shared variables may be declared using
#shared int varname val or
#shared char varname val. The initial value, val is required for shared variables.

• var = const;
• var = var1;
• var++;
• var--;
• read(0,&var,1);
• write(1,&var,1);
• var=random(x,y);
• var=fork();

The read and write are meant to be only used for character variables. Only the low byte is written and the variable is set to the byte read.

The var=random(x,y) instruction sets the variable to a random integer between x and y inclusive. The x and y can be either variables or constants.

In addition, any variable can be written as a string into buf using the %d specification in an instruction. At most 4 integers can be used in a single sprintf.

Counting semaphores are also supported. Each semaphore must be declared and initialized with a pseudo instruction before any program code. If sem is the name of such a semaphore then the instructions wait(sem) and signal(sem) are supported.

Program Control Any statement (except a while) can be preceded by an arbitrary number of conditionals in one of the following forms:

• if(var==x)
• if(var!=x)
• if(var<x)
• if(var<=x)
• if(var>x)
• if(var>=x)

Blocks can be created by putting an open brace at the beginning of a line. These may be preceded by an arbitrary number of conditionals. Blocks are closed by a closed brace on a line be itself. Any statement except a while(1), including a block, can be preceded by any number of conditionals.

The only looping structure is while(1), but since the following statement can be a conditional break, a while(condition) statement can be simulated.