|
There are two ways to run the Elliott 803 simulator:
Most people will want to use the Graphical interface.
Some further details of how programs are loaded and run are given here:
The graphical interface can be started by running the simulator JAR file or by
running the elliott803.Main program within the JAR.
java -jar elliott803-n.n.n.jar [options] [machine]orjava elliott803.Main [options] [machine]
machine- A previously saved machine image.
-volume volume- The initial loudspeaker volume. This should be a number from 0 to 10, a value of 0 will switch the sound emulation off (which can be useful on slower machines). If not specified the default value is 5.
-look lookandfeel- The name of the Java look-and-feel to use. By default the standard platform look-and-feel will be used. Other look-and-feels that may be available (depending on operating system and Java version) include:
metal,ocean,steel,windows,classic,motif,gtk,macandnimbus.
The graphical interface displays a main window containing several smaller internal windows representing the various hardware and devices that form the Elliott 803 simulation. These windows can be moved around and resized (or minimized) as required. The current layout can be saved as part of a machine image and restored in a later run.
Most interaction will take place with the paper tape reader and tape punch devices and with the system operator's console.
When the simulator starts up it can load a pre-saved machine image containing
the complete core memory contents and the size, position any layout of all
the application windows.
This image can either be provided as a parameter when starting the application
or can be loaded later.
If no image is provided a default window layout will be used.
The simulation control window provides functions not present on a real
803 that are used to perform additional control of the simulation.
The two additional functions provided are for controlling the simulation speed
and for loading and saving machine images.
The CPU Speed section is used to control and display the simulated CPU speed. The speed can be set to Real time which should run at a very close approximation to the speed of a real 803B or, if the checkbox is cleared, it can be set to run as fast as the implementation will allow. Note that sound can only be produced when the speed is set to real time.
The CPU speed number displays the current simulation speed in relation
to real machine - so 1.0 means it is running at the same speed
as a real machine (which should be the case when the Real time option
is selected) and values greater than 1 indicate running faster than a real
machine.
The Machine Image section is used to save the current machine image
or restore a previously saved machine image.
A machine image consists of the complete core memory and may also include the
size, position and layout of all the windows on the screen.
They are typically saved as files with an extension of
".803".
The operator console is the mechanism by which the computer is operated. There are 39 buttons on the left hand side called the Word Generator. These buttons are used to form complete machine words, typically instructions. For convenience the value of the instruction currently formed by the buttons on the word generator is shown at the bottom of the window.
Note: When one of these 39 buttons is pressed it will stay pressed down. You can release the button, and all other buttons in the same group, by pressing the red release button (marked with an R) at the far left of the row.
On the right hand side are the various operation buttons and indicator lights. The Clear Store button sets all storage locations to zero. The Reset button stops any current execution, clears any "busy" condition and returns control to the console.
The three buttons marked Read, Normal and Obey are used in conjunction with the Operate bar to operate the computer. To use them you first select the function required by pressing one of the three buttons then hit the Operate bar to execute it.
The Read function reads the instruction currently set on the word generator buttons to the CPU instruction register, ready to be executed. The Obey function obeys the next instruction then returns to step-by-step mode. The Normal function obeys the next instruction and continues executing instructions normally.
So a typical sequence of operations to cause a jump to the initial instructions at location zero (to load a program from the tape reader) would be:
The Manual Data is used to cause the system to wait (until the Operate bar is pressed) whenever an instruction to read the word generator is executed. If this button is not pressed the word generator value will be read without any pause.
The indicator lights show the following conditions:
The Volume slider controls the level of the sounds produced by the console speaker. Setting the volume to 0 will switch off all sounds.
This window is supposed to look and operate somewhat like the real Elliott 803 operator console.
The CPU window shows the values of some of the important internal registers as execution proceeds. This includes the currently executing instruction and the contents of the accumulator and auxiliary registers. When running in step-by-step mode the CPU window will display the next instruction that is about to be executed.
At the bottom of the window are two debug options:
|
The core store window shows a view of the 8K words of store. It is intended to give a rough idea of where in store work is taking place.
The window shows 128 lines of 64 small blocks, each block representing a single word of store. The block will be white if the word of store contains zero, otherwise it will alternate between light and dark grey whenever a value is written to the storage location.
When running in real time mode the the simulation will operate at a very close approximation to the speed of a real Elliott 803B - this can be quite slow compared to modern machines especially when reading tapes or printing output (the teletype operates at about 10 characters per second).
If real time mode is deselected the simulation will simply run as fast as possible, however the frequent updates to the CPU and Core Store windows that take place as execution proceeds considerably slow down the speed of the emulation. If you want processing to run at a much faster speed one or both of these windows should be minimized.
The output teletype shows the printed output from the computer. The data will scroll up as new lines are output or when the Scroll button is pressed.
To save output from the teletype press the Save... button and set a log file to store the output. New output will be appended to the end of any existing log file. The log file will be closed if the Clear button is pressed and this will also clear any current teletype output.
When selecting a log file you will need to choose an appropriate
tape format for the resulting log file.
The graph plotter displays any plotter output generated. The output is scaled so that the current width of the plotter window represents the full width of a real Calcomp plotter, that is 11 inches.
Pressing the Clear button will clear the plotter output and
reset the pen to the left hand edge.
Take care pressing Clear as the image cannot be recovered without
re-running the program that generated it.
The paper tape readers and paper tape punches are the primary means of input/output for the computer. "Tapes" are held as files on the host PC system and the Load and Save buttons on the tape devices produce a file selection dialog that allows the tape files to be selected.
When selecting a tape file you will need to choose an appropriate tape format for the file.
When reading or writing files using the tape readers and tape punches you need to consider the format of the tape file that is to be read or written. Tapes can be in Elliott format or in System format.
The file selection dialogs contain a panel on the right hand side that allows the correct tape format to be selected. Depending on the action requested the tape format will offer one or more of the following options:
£) will be written as the number
sign (#).On a real 803 machine whenever the CPU executed certain instructions (any instruction from groups 4, 5, 6 or 7) a pulse would be sent to the loudspeaker in the operator console. In general this results in fairly random noise being generated as programs execute, although repeating sequences of instuctions or carefully chosen sets could create recognizable sounds. For example a jump instruction (a group 4 opcode) would produce a pulse, a jump to the location with the jump instruction would result in a tight spin loop with one pulse every 288us - which gives a steady tone of about 3.5kHz. See the music sample program for another example.
The simulation attempts to replicate these sounds using the PC sound card. The volume of sound produced can be controlled using the Volume slider on the Operator Console. Note that for sound to be produced the simulation must be set to be running in real time mode.
To generate accurate sounds a reasonably fast PC is needed.
On a slower machine, particularly with a single core processor, it may be
necessary to minimize the CPU and Core Store windows to improve sound output.
If sound performance still seems break up or stutter, it
is probably best to turn the sound off by setting the volume slider to 0 or
starting the program with the -volume 0 parameter.
If you are patient, careful and very meticulous it is possible to enter a complete program and run it using only the operator's console. If you want to try, here's a very simple two line program that will print a series of 'A's to the teletype:
128: 74 4127 : 74 4097 * Print a letter shift and a letter 'A' 129: 40 128 : 00 0 * Jump to location 128 to repeat
This could be entered and run using the following sequence of operations:
| Word Generator | Operation | Notes |
|---|---|---|
| Reset the computer ready for use | ||
| Reset | The "Step by step" light should now be on. | |
| Load the short program into store | ||
70 0 : 00 0 |
Read, Operate | Put the instruction 70 0 (read the word generator to the accumulator) into the instruction register ready to be obeyed (but not run yet) |
74 4127 : 74 4097 |
Obey, Operate | Obey the previous 70 0 instruction so the accumulator now contains the
instruction 74 4127 : 74 4097
(Hint: 4127 = 4096 + 31, 4097 = 4096 + 1) |
20 128 : 00 0 |
Read, Operate, Obey, Operate | Put the instruction 20 128 (store accumulator to location 128) into the instruction register and obey it. |
70 0 : 00 0 |
Read, Operate | Get the 70 0 instruction ready to be obeyed again |
40 128 : 00 0 |
Obey, Operate | Obey the previous instruction so the accumulator now contains 40 128 : 00 0 |
20 129 : 00 0 |
Read, Operate, Obey, Operate | Put the instruction 20 129 (store accumulator to location 129) into the instruction register and obey it. |
| Run the program | ||
40 128 : 00 0 |
Read, Operate, Normal, Operate | Reads and executes a 40 128 (jump to location 128) instruction and continues
running normally, i.e. fetching and executing instructions from store.
The short program should run and print continuous 'A' characters to the output teletype. |
| Stop the program | ||
| Reset | Output should stop and the system return to "Step by step" mode. | |
Clearly this method of loading and running programs is impractical for any program of any size, so the 803 provides a better solution. Storage locations 0 through to 3 contain hard-wired instructions called the Initial Instructions, these are a bootstrap program that can load binary data from paper tape (in tape reader 1) into consecutive words in store. Since a word is 39 bits and each character on tape is 5 bits, it takes 8 tape characters for each word of store.
For interest, the initial instructions are these:
0: 26 4 : 06 0 1: 22 4 / 16 3 2: 55 5 : 71 0 3: 43 1 : 40 2
They use just one extra word (location 4) of working storage and can load the program into any location in store - the first word read from the tape defines the load address for the rest of the data. You might like to try to figure out how it works!
This means the standard way of loading a program is to put the program tape into the reader and execute a jump to location 0 to invoke the initial instructions.
The simulator can also be run as a command line function, although this is probably less useful for most people.
java elliott803.Run [options] programtape [entryaddress]
programtape- The binary program tape to be loaded by the initial instructions.
entryaddress- The program entry point address to jump to after the tape is loaded. This will be ignored for a self-triggering program tape.
-reader1 inputtape- The tape to load in reader 1 (after program tape is read).
-reader2 inputtape- The tape to load in reader 2.
-punch1 outputtape- The output tape file for punch 1
-punch2 outputtape- The output tape file for punch 2
-teletype outputfile- The output file for teletype, defaults to standard out
-wordgen "instruction"- The value to set on the word generator, formatted as an instruction e.g.
"70 1 : 00 1".-press keynumber- A key to press if the system waits for keyboard input. The top-left key (the Function 1 "40" or sign bit) is keynumber 1, the bottom right key (the Address 2 "1" bit) is keynumber 39. Other typically useful keynumbers are 20 (the B-digit) and 21 (the Function 2 "40" bit).
-ascii- Print using only US-ASCII characters
-dump- Produce a system dump on exit
-trace- Produce a full instruction trace
As an example the sample Character Set program can be run with this command. This will result in the telecode character set being printed to the terminal or command line session.
java elliott803.Run -ascii tapes/samples/charset.tape
An ALGOL source program cannot be directly compiled and run using the command line interface, however it is possible use the graphical interface to compile a program and produce a dump tape of the compiled source and runtime. This dump tape can then be run from the command line.
To produce a dump tape start by loading the ALGOL compiler and compiling your program as described in Running ALGOL Programs. Proceed up to step 3 of the Compiling and Running a Program section. At this point, instead of running the program, press the Reset button and execute a 40 12 instruction from the console. The system will then write the dump tape of the compiled program to Punch 1.
The resulting tape is in a form that can loaded and run directly without
needing the ALGOL compiler, so it can be run using the command line interface.
After loading the tape the system will enter a Data Wait, so a
command line option of -press 21 is needed to cause
it to execute.
As an example the Trigonometric Table ALGOL program has been compiled to a sample dump tape and can be run with this command.
java elliott803.Run -press 21 tapes/samples/trig.dump.tape
The program will end in a spin loop, you will need to press Ctrl-C to end the process.
| Tim Baldwin December 2013 tjb803@tinymail.co.uk |
Return to index
© Tim Baldwin 2009,2013 |