Software's wearisome steps - University of Sydney … · Software's wearisome steps Many people wrote introductions to using members of this family of machines. ... Tony Barry wrote

From SILLIAC – vacuum tube supercomputer by John Deane © 2006

Software's wearisome steps

Many people wrote introductions to using members of this family of machines. Herman Goldstine wrote in 1951 about the IAS Computer:

Clearly, what one does in a computing machine is to represent mechanistically what a human computer performs. If it were not for the deep functions of the human intellect we would never be able to produce a machine. Fortunately, if one looks at what goes on when one does a computation, he finds it is possible to relate or resort to the ordinary vocabulary and transmit it to a computer in a dozen or so different words. [3]

And John Bennett wrote a little later:In the interests of preserving interchangeability of routines, the order code is the same as that of the ILLIAC. Our experience with it has been that our complaints are all minor ones and that it possesses the great advantage possessed by all simple codes - it is very easy to impart to newcomers. [66]

“Problem Poser” forElectronic Brain

A SILLIAC operator prepares problems for the computer on a “Creed” Teleprinter. This ingenious unit punches data on a paper tape, which is then fed into the machine by a photo-electric reader. “Creed” equipment is built by an English associative of Standard Telephones and Cables. STC advertisement [60]By kind permission of Alcatel

John Blatt said to the 1958 Summer School thatThe machine understands only certain simple, elementary instructions, such as “add”, “subtract”, “multiply” and “divide”. Anything more complicated must be broken down to these elementary operations, and the machine must be told, step by wearisome step, how to go through these operations to achieve the desired result. ...

While the Programming Manual warned the reader about what was to follow:The construction of a computer involves a compromise between engineering economies on the one hand and ease and flexibility of use on the other. As a result, the details of the operations of arithmetic are often dictated by engineering design considerations. The following paragraphs describe the peculiarities of the representation of numbers and of the operations of arithmetic in the SILLIAC.

As a young CSIRO astronomer, Eric Hill programmed SILLIAC in the late 1950s. He said

It would take half a day to write two or three instructions - it took that long to work through the legalese of the Programming Manual. [103]


Another CSIRO programmer, Phil Mulhall, was a psychology student using SILLIAC to do statistical analysis in the mid 1960s. Naturally he analysed the programmers:

You could tell who was a serious programmer - their program tapes would glide smoothly through the reader; they programmed in straight sexadecimal. The decimal loader jerked the tape about, it was for wimps. [99]

Tony Barry wrote of his time as a physics student at Sydney;

I wrote programs on Silliac in 1961. Punched cards had not then been moved to computers. It used paper tape. If I went in after midnight I could use the flexowriter ... otherwise I had to use a hand punch to punch out EACH BIT! We also ate gravel for breakfast and slept on barbed wire etc. [149]

Paper tape hand punchACMS collection

Kel Stillman also described his student experiences on SILLIAC:Q: Was it difficult to program SILLIAC?A: Yes it was but we didn't know it then. Difficulty is a relative thing. You had

to program in machine language. The only simplification was you could use relative addresses in decimal numbers. Each Silliac word (there were 1024 of them) could hold two instructions referred to as “left” and “right”.

Q: What was the problem with that?A: Well, the instruction set had to distinguish between left and right orders. If

you inserted an extra instruction into a block of code all the left instructions became right instructions and visa versa. So a number of op-codes had to be changed, and most of the addresses as well. All these changes were made manually. [164]

The place to start the wearisome steps into SILLIAC's peculiarities is

Numbers

Everything that SILLIAC did, it did with numbers. Numbers were not only for calculating but they described the instructions, the store locations, the paper tape character codes, just about everything. Early in the IAS Computer's development it was decided to handle these numbers four bits at a time. It was like an ancestral byte, half the size of the modern one.

One reason was the easy availability of five bit ticker-tape equipment used for telegraphy. Four bits is enough to represent 0 to 9 (actually 0 to 15), while the fifth bit could signal codes to represent other useful things a user might want to do with paper tape, like insert spaces and new-lines so that a tape could be printed legibly. That immediately brought up a problem - the existing codes (like the telegraph’s Baudot code) included the characters 0 to 9 but the associated punched codes bore


no relation to the required values.

Easily fixed. Keytops were moved so that pressing key '9' punched the number 9, AND the printing mechanism was altered so that the code number 9 was printed as character '9'. To fill all four bit positions keys for the numeric values 10 to 15 were needed. The rearrangements needed for 0 to 9 produced a scattering of the other keys, and the numeric values 10 to 15 appeared on keys '+', '-', 'N', 'J', 'F' and 'L'. ie

number: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15letter: 0 1 2 3 4 5 6 7 8 9 + - N J F L

This base 16 scheme was referred to by the Latin for 6 and 10, ie sexadecimal. Just to confuse matters at some stages ‘K’ and ‘S’ were printed instead of ‘+’ and ‘-’. Of course this made mnemonics easier, such as

King or KeenSolomon StudentsNever NeverJived JossFor FatLove Ladies

- thanks to John Butcher - and to John Lambert-Smith

Arithmetic

This was, of course, SILLIAC's reason for existence. Addition and subtraction could be done with integers, but the real work, including multiply and divide, was done with signed, fixed point numbers. In fact, the fixed point was directly after the sign bit, so arithmetic was done with FRACTIONS. Looking at the 40 bits of a word:

Bit 0 Bit 1, 2, 3, ... ... 37, 38, 39Sign bit

20, ↑ “binary” point location. The bits were also referred to as 2-1, 2-2, ... 2-39.

For example, a word with bits 0.11100 ... 00 represented 0 + ½ + ¼ + ⅛ = + ⅞ , and 1.11100 ... 00 represented -1 + ½ + ¼ + ⅛ = – ⅛.

The range of values that could be held was from -1 to just under +1, and it was the programmer's responsibility to scale real-world values to this range and to keep track of what was really represented.

The accumulator’s sign bit was connected to the loudspeaker so a good understanding of the instruction timing (which was not fixed) plus some elementary musical knowledge allowed Mary had a little lamb or even a Chopin march to be


buzzily inflicted on anyone present.

Orders

An order (or machine instruction) for SILLIAC could be represented in sexadecimal as

XYZZZZ where XY was the 8 bit orderZZZZ was usually the store location

Each order was 20 bits long, ie half a word. The left-hand order was executed before the right-hand order (unless there was a jump involved).

Of the 256 possible orders about 150 did something useful but a much smaller set was enough for many problems. In the order code XY, the X indicates the basic function type and Y indicates a fairly consistent variant. A very short list is:

XY Operation ZZZZL5 Load A store locationL4 Add to A location of addendL0 Subtract from A location of subtrahendF5 Load value + 1 store location75 Multiply A location of multiplier, product to AQ66 Divide AQ location of divisor, quotient to Q, remainder to A50 Load Q store location40 Store A store location41 Clear A and store store location to be cleared42 Copy RH address

bitsstore location to have RH address replaced

N0 Store Q store location46 Copy LH address bitsstore location to have LH address replaced3L Indexing location of index value to be added to the address

of the next order when it was executed26 Transfer to LH location of next order pair, do the left hand order22 Transfer to RH location of next order pair, do the right hand order36 Transfer IF A ≥ 0,

LHlocation of next order pair, do LH if A is positive

32 Transfer IF A ≥ 0, RH

location of next order pair, do RH if A is positive

80 Input binary to A number of 4 bit characters to be read × 4 (characters with the 5th bit punched were skipped) eg 028 (= 40 decimal) would fill A with ten numbers


82 Output binary from A

number of 4 bit characters to punch × 4

92 Output character coded character eg 201 → space, 081 → CR/LFFF Stop - fault finish address not used0F Stop - normal finish address not used

A blank SILLIAC coding sheet

Scaling

After getting an understanding of the instructions there was still a major element of SILLIAC programming to master. The arithmetic unit operated on numbers between -1 and +1 (with many decimal places). Real numbers, like 12.34, had to be stored as fractions, so the HARDWARE could handle 0.1234 and the PROGRAM had to “know” that the actual number was 100 times bigger. This scaling of numbers had to be tracked right through a calculation.

If the programmer made a mistake estimating the scaling then a run would fail with


a dreaded ÷ HANGUP (ie too big) error. There were library routines to continually re-scale numbers (ie they provided floating point numbers as provided in the hardware of many later computers) but the software solution was slow and serious programming was run at full speed with careful problem analysis for safe scaling.

Library

Next, the programmer did need to use the software library. The earliest routines were written by David Wheeler, who had developed the software library for Britain's first major computer (EDSAC) then he repeated the effort at the University of Illinois. For SILLIAC a copy of this library was a major strength as it provided many proven routines for the programmer to choose from. The routines were individually introduced in the Programmer's Manual.

Input routines

N1 to N25 could read integers and fractions, real numbers or £-s-d from paper tape.

Output routines

P1 to P30 provided output of integers, fractions, real numbers and text to punched paper tape - with many parameters for precision and formatting. Immediately readable big 'dot matrix' style characters could be punched using P8.

Functional routines

Many arithmetic routines were provided in the 'R', 'S' and 'T' series including: R1 square root, R4 cube root, R2 integral root, T1 sine and cosine, T4 arctangent, S1, S3 logarithm and S2, S4 exponential.

Problem solving routines

This large body of routines included:E2 to E7: Integration, F1 to F5: Solving a set of differential equations, G1, G2, U3 to U5, V1 to V16: Special functions including Bessel,

Legendre, Random numbers, Fourier analysis, H1 to H7, J1, J2: Function roots and minimisation, I1: Interpolation, K1 to K17: Fitting a line by least squares and statistical routines, L1 to L9: Solving a set of simultaneous linear equations, M0 to M25: Matrix manipulation,W1 provided looping control, andW2 was an in-memory sort.

Interpretive routines

The A1 to A8 and B2 routines provided double precision and floating point arithmetic in an automatic coding or interpreted environment. These were not greatly used outside the famous A9. Q1 and Q2 provided a system for manipulation of logical algebra.

Checking routines

C1 to C13 and D1 to D7 were programs which could check for a correct program load into memory, make formatted printouts of selected program areas or make a trace of transfer orders.


SILLIAC did not have an explicit subroutine call instruction, but it did have everything required to build one. This is how the standard library routines were used:

Location Orderk ... previous orders in the main program,

F5 k load A = this location + 1 (ie make 'k+1' in the right of A),k+1 26 m transfer to the subroutine at address m (LH),

... next order in the main program

where the two orders had to straddle a word boundary, even if that required a filler order (eg 39 Null). If the programmer wanted to write a routine that could be called the same way as the library it needed to include:

LocationOrderm 42 n first instruction of the subroutine: copy the RH address bits

of A into the RH address bits of n,... the body of the subroutine,

n ...22 0 the last instruction of the subroutine has the '0' replaced by

'k+1', so it does a transfer to there (RH)(This is the new style of call used from 1958)

Now that the programmer had selected the library routines that the problem required, obtained the full documentation and had written out the entire collection of instructions there was one more hurdle before the first run. A paper tape had to be punched containing the program in a form the machine could use.

Loader

Generally a user was presented with 1024 words of memory set to ZERO - and means had to be provided to transfer the program from paper tape into memory. There were two basic ways to do this.• A bootstrap read a sexadecimal image of memory from tape then ran it. This

was fast and efficient but it did not allow library routines to be used.• The Decimal Order Input routine (library program X1 etc) loaded user programs

formatted with addresses in decimal, it allowed parameters and constants to be entered and it allowed library routines to be relocated, ie loaded anywhere in memory. Of course, it had to be loaded with a bootstrap which was punched on the tape before X1 itself.

Most programmers used X1 or one of its variants:X2 X1 with an integrity sum check.X3 X1 with constant usage optimisation.


X7 Like X2 only for multi segment loading programs. X8 X1 with routine loading optimisation.X12 Like X2 with simplified loading (using “S directives”).X13 X1 with symbolic addresses. X15 Like X1 but with simplified constant entry.

All the input to X1, ie the program, was punched using six operators.

00 YYYY+ Set the load address to decimal YYYY (00 “order” was required).

XX YYYYF Load the order XX with fixed decimal address YYYY. XX YYYYL Load the order XX with relative decimal address YYYY, ie

the most recent load address was added to YYYY.XX YYYY-D Load the order XX with decimal address YYYY relocated by

adding the contents of memory location D = 3,4,5,6,7,8,9,+,-,N,J,F or L (ie 3 to 15).

XX YYYYN Start the program, XX is a transfer order (26 for LH, or 22 for RH order), YYYY is the decimal start location, and the line comes at the end of a program after an RH order.

00 F 00 abcdefghijklJ

This curious pair of pseudo orders is used to insert a one word decimal constant 0.abcdefghijkl with value up to nearly 0.5. Even curiouser, the initial 00 F could be replaced by 40 F to add 0.5, 80 F to subtract 1 or N0 F to subtract 0.5.

with spaces and carriage-return/linefeeds inserted between orders as desired.

A tiny program to print a number could be constructed as

Address Program tape00 3+ set the load address to 3,

3 00 F load a parameter word to set the print width to 10,00 10F00 20+ reset the load address to 20,

20 L5 50F start of program: load location 50 (pi/10) to A,50 L the return-link part of the subroutine call,

21 26 30F transfer to the print subroutine,0F F stop, ie end of program,00 30+ reset the load address to 30,

30 to 43 ... copy the library print routine P6 here,00 50+ reset the load address to 50,

50 00 F load a constant here as 0.314159265358,00 314159265358J26 20N end the load and start the program at 20 (LH).


Locations 0,1,2 and 999 to 1023 were used by the bootstrap and loader.

It was possible to do a partial program load, execute some code, then resume the load. Library routines used these “interludes” for tailoring the loaded code then they re-entered the DOI at 99910, (left side) if an address directive followed, or at 101410, (right side) to continue loading at the address in the accumulator.

Making a Paper Tape

Now the programmer only had to be taught how to use the equipment in the Hand Computing Machine Room:Teletype Perforator, or Creed Page printer (type 54/N4) with punch and tape reader (type 6S/5M)(a Creed 7TR/3 reperforator was for the library)

- to punch or copy a tape(left side of the photo below),

Teletype Transmitter and Teletype Model 28 Receive Only Page Printer

- to list a tape(right, below),

Creed tape comparator - to check a copied tape,Ferranti Photoelectric Reader, Basser Comparator/Reperforator Control Unit and Teletype BRPE High Speed Punch

- to copy and correct a tape

(these were all modified to SILLIAC's character set)

Judy Ogilvie punching a program tape , and printing a tapePhotos by kind permission of the Science Foundation for Physics

Like ILLIAC, SILLIAC had its own character codes and punch and printing equipment was modified to allow the numeric values of the punched pattern for the figures '0' to '9' to be 0 to 9, unlike the standard 5 channel Baudot code. In addition, Space and CRLF had to have the 5th hole punched so they could be used with, but could be easily distinguished from the numeric codes. Remaining codes were reallocated in whatever sequence seemed convenient. Computer operation required additional punched values from 10 to 15, and these appeared with the figure shift characters '+', '-', 'N', 'J', 'F', 'L' which were clearly not chosen to have any mnemonic


association.

Letter Figs S 8 - 4 2 1 Letter Figs S 8 - 4 2 1

A ) o • o o Q 1 • oB ( o • o o R 4 • oC : o o • o o S - o • o oD # o • o T 5 • o oE 3 • o o U 7 • o o oF F o • o o V , o • o oG = o o • o W 2 • oH ' o o • o X / o • o o oI 8 • o Y 6 • o oJ J o • o Z × o o • o oK + o • o Delay Delay o •L L o • o o o CRLF CRLF o • oM . o o • o Letter Letter o • oN N o • o Space Space o o •O 9 o • o Figs Figs o o • o oP 0 • Erase Erase o o • o o o

The special characters were:

Space print a space, Letter shift the printer to letter printing,CRLF carriage return and line feed, Figs shift the printer to figure printing,Delay to allow time for a CRLF to

complete,Erase obliterate any previous printing; to

be ignored on input.

In contrast to the context-sensitive, language-aware programmer's editor of today, Peter Aplin’s High Speed comparer-reperforator was SILLIAC's editor:

Paper tape edit station

The editing station had two Ferranti photo-electric paper tape readers set at desk height, and a high speed punch (in the noise-reducing box at the top right). These were spares for SILLIAC's normal operation. Bins for the paper tapes were placed under the bench. Basser workshop photo from Remo Di Giovanni(thanks to Stephen Jones)by kind permission of theUniversity of Sydney


1. SKIP NONE2. SKIP ERASE3. SKIP HOLE 5

1. COMPARE2. COMP & REPERF3. MAN PUNCH4. REPERFORATE

The paper tape editor control panel

Each device had 5 lights to show the last character read or punched, and buttons to manually set a character (plus a separate button for DELAY, the equivalent of blank tape). As well as the continuous functions the readers (“R1” and “R2”) could be jumped forward one character at a time. Going back was not an option!

The editing functions were

COMPARE Load two tapes then press RUN and the comparer would stop on a difference.

COMPARE & REPERFORATE

Compare two tapes and punch a third until a difference is found.

MANUAL PUNCH First SELECT LEFT or RIGHT (which could have been altered) then press 1 SHOT.

REPERFORATE First SELECT LEFT or RIGHT then press RUN to copy a tape, the tapes should then be COMPAREd!

[86, 155]The STOP button was explained among the warnings:

When comparing, the tape readers operate at their full speed of 200 characters per second, and this is quite fast enough for the operator to have difficulty in controlling the tapes if his technique is poor. ... Any attempt to fight tapes into the bins while the equipment is running will probably end in disaster. ... watch the tapes feeding into the readers, and hold a finger close to the stop-button so as to stop the process immediately any snarling of tape is observed.


Of course disasters were not unknown, and anyhow tapes sometimes had to be joined together, with special sticky black splicing tape .

The function conspicuously absent is REPERFORATE UNTIL STRING FOUND - ie there was no search function, the human had to provide the necessary processing, and had to learn to read the punched holes.

Then the program could be taken to SILLIAC for a test run! Generally this involved placing the paper tape plus its identification and instructions in the job queue. John Lambert-Smith described the queue as “a piece of heavy string with pegs to hold paper bags” [178], but Judy Rowe recalled the next stage as

an oval track, with little roller wheels running continuously round in a groove on the inside lower edge, and from each wheel was suspended a metal clamp. The researcher would put his operating instructions and any program and/or data tapes in a large (often used and reused) manila envelope and clamp it to the track and we processed the envelopes pretty much in the order received. [179]

The punched output tape would be returned and printed in the programmers’ lab. After that frequently disappointing activity the cycle of tests, corrections and retries started.

Start of a program paper tape

Debugging

Checking a computer program is a process of “seeing” what it does and comparing that with what it should do. On SILLIAC this seeing had to be a somewhat indirect process as John Bennett pointed out in 1957:

the monitor tube displaying the contents of any one C.R.T. store is useful only as an indicator of the extent of a “loop” ... apart from a neon display of the current instruction number and the current instruction pair, the programmer has nothing to peep at, and so peeping is an even more fruitless pursuit here than it is with most computers.

Their approach was to use software, iepost-mortem routines and diagnostic routines. As the name implies, the first group is used when the program has “died”, i.e. come to a stop on an illegal order combination. The second group is used to diagnose the ills of a patient who, though ailing, is still “alive”. [170]

Post-mortem procedures all required loading and running a small program to poke


around in the dregs of memory, these could• print sections of the store in sexadecimal or numeric form,• compare the contents of memory to the original program tape and print

differences,• search for transfer orders with a given destination address range and print them.

Diagnostic routines had to be loaded with the suspect program to• record all transfers in a buffer (which could be printed by a post-mortem

routine),• periodically print critical information.

Brief descriptions of these are given in the software library appendix at p. under “D” for diagnostics and “X” for post-mortem programs (along with program loaders).

Jobs were submitted to SILLIAC with detailed instructions for the operator, and classified as either “code check” or “production”. While debugging jobs were only allowed a limited run time (up to 10 minutes) it was usually possible to get two runs a day. This allowed plenty of time to think about how to find out what went wrong in the next trial.

If this looked like too much trouble there was the popular simplified coding scheme provided by the A9 interpreter.

A9

The Programming Manual said The coding scheme A9 ... has been prepared to enable programs to be written by coders with little or no knowledge of SILLIAC. It is also a convenient scheme for even experienced programmers when programming time is the major consideration, and computing time of secondary importance.

It still had to use the sexadecimal character set 0 to 9 and +,-,N,J,F,L (plus one special character “#” and any spaces and newlines the user liked) but the number of possible arrangements was fewer. AND, A9's major strength was that it was documented in ONE page (shown below).

The other great strength of A9 was its ability to use real numbers like '123.45'. Even so they had to be entered as a signed fraction and signed, two digit, exponent of 10. For example, 123.45 ( = 0.12345 × 103) was entered as +12345+03 .

The example shown previously could be done using A9 with


85 N+314159+0089 6F8J -F

Load pi/10 into A.Print to 6 digits.Stop.

That's the whole tape (well, A9 itself was a separate tape, but it would stay loaded for multiple runs).

INSTRUCTION CODES FOR PROGRAM A9

I. ARITHMETIC x = the number in register n

0 ≤ n ≤ 162. Addresses of the form n-N may be replaced by N followed by the actual number. 85 n-N Put x in A . 84 n-N Add x to A . 81 n-N Put -x in A . 80 n-N Subtract x from A . 87 n-N Multiply by x . 86 n-N Divide by x . 8N n-N Subtract |x| from |A|. 8- n-N Store A in register n. 8+ nF Put n in A . 8+ mF Where m=400-r,

put -r in A where r ≤ 200.

V. SPECIAL 8J -F Stop the program. 26 16N Stop reading the program

and start obeying it. 24 16N Stop reading the program.

Stop the machine. Start with the black switch toobey the program.

*bL nF Replace gb,cb by gb+n,cb.*8L nF Replace gb,cb by n,cb

(where b is the last index register used).

II. FUNCTIONS8J -6 Square root8J -- Cube root8J -8 Exponential8J -9 Natural Logarithm8J -7 Sine8J -+ Arc Tangent

III. INPUT AND OUTPUT88 F Read a number into A .89 nF Print A to n digits 1 ≤ n ≤ 98F nF Print future numbers in

n columns.

IV. BREAK SEQUENCE 0 ≤ b ≤ 782 #nL Goto instruction tagged with

#nL if A positive.92 #nL Goto instruction tagged with

#nL.90 #nL Stop. Goto instruction

tagged with #nL when started with black switch.

8+ F Set A to zero (positive)b+ nF Loop b to be repeated n

timesb2 #nL Repeat loop b by going to

instruction tagged with #nL

A9's documentation included “The unstarred sections ... have been written with the neophyte in mind.” The first starred section described the two instructions marked above (which modify loop controls) and further dangerous sections described operating A9 itself, and how to debug an A9 program. The debug option printed the address of each instruction executed and its effect on the accumulator. This “should be sufficient to show the user where his program has left the intended course”.

The loop operation also allowed a table to be constructed. The loop was controlled


by an index (selected from 0 to 7), and this index number could replace the '8' digit of any of the arithmetic instructions.

For example, to read a table of five numbers into registers 10 to 14:

#1L0+ 5F88 F0- 10-N02 #1L

Use loop index 0 & do 5 iterations,Read a number,Store in register 10 offset by the value of index 0,Go back to tag #1L if 5 iterations have not been done

Symbolic SAM etc

Both the native machine language and the simplified A9 seem a vast distance from what would be called a programming language today, but there were symbolic assembly programs for this family of computers. An Assembly language for the ILLIAC computer was mentioned in 1959 and Bruce Chartres wrote a symbolic assembler, SAM, for SILLIAC in 1961. This more “modern” approach to program development does not seem to have been much used. [68, T14]

The programmers' laboratory about 1956(SILLIAC is visible through the doorway at the back)

Photo by kind permission of the Science Foundation for Physics

David Green’s SILLIAC emulator is available on the internet at http://members.iinet.net.au/~dgreen/silliac.html

Documents

Software's wearisome steps - University of Sydney … · Software's wearisome steps Many people wrote introductions to using members of this family of machines. ... Tony Barry wrote