Contact us Heritage collections Image license terms
HOME ACL Associates Technology Literature Applications Society Software revisited
Further reading □ OverviewAssessingSystem OverviewPreprocessor DialectsExecution SpeedsAlgol Paper No 11Man or Boy?Algol LibraryAlgol Bulletin 1
ACD C&A INF CCD CISD Archives Contact us Heritage archives Image license terms

Search

   
ACLApplicationsAlgol :: Algol System
ACLApplicationsAlgol :: Algol System
ACL ACD C&A INF CCD CISD Archives
Further reading

Overview
Assessing
System Overview
Preprocessor Dialects
Execution Speeds
Algol Paper No 11
Man or Boy?
Algol Library
Algol Bulletin 1

Comparison of ALGOL 60 Execution Speeds

B A Wichman

January 1969

NPL CCU Report No 3

1. Introduction

The yardsticks for measuring the performance of computer systems are too few. The work described in this report is a very small step along the road to making methods of evaluating an existing computer more effective. ALGOL 60 makes an excellent vehicle for comparative study since it is a facility which is available on a large number of machines and it is better defined than most other facilities. Execution time, that is the time taken by the central processor, is fairly easily measured on most machines and is often important, so it is this aspect of ALGOL that has been considered in this study. Individual statements have been taken since it is then possible to see which language features have been dealt with efficiently and conversely which ones are particularly slow. The work has been limited to non-interpretive schemes on machines with hardware floating point The reason for this is that entirely different execution times are obtained when interpretation is involved or when floating point instructions are done by software.

2. Timing the Statements

2.1 Method of Timing

The statement s which one wishes to time is placed in a single for loop as follows:-

            for i := 1 step 1 until n do <s>

The time taken to execute this statement is subtracted from the time to execute the same for loop with a dummy statement s. This makes an assumption that the for loop control code is independent of the statement s. Two methods have been used to time the for loop itself. On a computer with a real time clock, a procedure (time) to inspect the clock can be used.

So the program now becomes


p := time;
for i := 1 step 1 until n do <s>;
q := time;
t := (q-p-c)/n;

where c is the time difference between two consecutive inspections of the clock. On machines without a clock a signal to the operator can be placed before and after the loop which can then be timed with a stop-watch. A typical program listing appears in Appendix A.

2.2 Hardware Factors involved in timing

Timing the statements has revealed a number of factors which influence the figures obtained. A major factor is the accuracy of the mill timer itself. On some machines this is only one second which is about the same accuracy as a stop watch. For the 41 statements which have been used here, this means running the timing program for about one hour to get answers within five per cent. If peripheral transfers are going on while timing is in progress, this usually slows down the processor by cycle-stealing. This is only significant for fast devices. Some processors have a speed adjustment which is usually set up by the maintenance engineer, so if accurate times are to be made he must be consulted. The time taken for some machine instructions can depend on the data presented to the processor. This is often the case with floating point instructions due to normalising shifts.

The KDF9 possesses a further difficulty in that a given sequence of machine instructions can take different times according to where the instructions lie in relation to the word boundaries. This can only happen when the instruction length is different (in some cases) from the word length.

Because of these difficulties a machine designed for multi-programming sometimes provides a mill-timer which is not affected by cycle-stealing, etc. For instance Atlas has modified instruction counter for costing mill time, which takes into account the fact that some instructions take longer than others.

2.3 Software Factors involved in timing

Even if satisfactory hardware exists for accurate timing of programs it is quite possible that the supervisory software does not assist as much as one would like. For instance, the mill timer may not be updated at every interrupt, so that some supervisory functions will be added to the mill time. On some multiprogramming machines it may be advisable to run only one program when doing timing in order to avoid these system overheads.

The other area of software difficulty lies in the actual code produced by the compiler. In some optimising compilers the code produced for a[i] := 1 for instance would depend critically on the context within which the statement appears (e.g. a simple for loop or not). Since the timing loop is a very simple for loop very favourable figures might be found which would not be typical of other contexts.

However, no such compiler was timed. A further hazard on a machine with a short address length like those of IBM 360 series is that occasional page changing instructions have to be inserted to address instructions properly. This will depend on the position of the page boundaries in relation to the statement being compiled.

2.4 Timing Techniques

The general method has been described in section 2.1, but a few additions have been found necessary in practice. With very short statements the overall time is only very slightly more than with a dummy statement. Hence it may be impossible, in view of the hardware hazards mentioned in 2.3, to achieve an error of less than five percent. This can be overcome by repeating the statement several times within the loop. . This makes the assumption that the code for the repeated statement is a repetition of the code for the single statement. On KDF9 a program for timing short instruction sequences is available which works by copying the sequence out several hundred times in the core and obeying all the copies. This was used for the very short sequences which also overcame the problem of the position of the instructions in relation to the word boundaries since this position could be varied.

Alternatively these very short sequences can be deduced from the machine instruction times if these are known. These instruction times should be checked independently. Both these techniques have the disadvantage that one must find out the machine-code generated by the compiler and so the timing itself is no longer a process which can be defined independently of the machine and done entirely with a simple ALGOL program.

3. Choice of statements

Unfortunately the choice of statements is somewhat arbitrary. The original timing program timed over 60 statements with the variables declared in the outermost block and also at an inner block. This program was run on Atlas, 1905 and KDF9, but unfortunately not all the times were available. In writing a note for the Algol Bulletin (AB 27.3.2) the author selected those statements for which the times were known. Further comments are made in section 7 on a more satisfactory method of choosing the statements. The most serious omissions are probably a parameter called by name (with expression and simple variable as actual parameter), and the for loop itself.

4. Details of the machines and sources of timing information

The ICL (Ferranti) Atlas computer is well known; it has a two microsecond core with extensive instruction look-ahead in the processor. The ALGOL compiler was produced using the compiler-compiler. The timing figures were obtained by F.R.A. Hopgood using the instruction counter (which avoids the cycle-stealing problems). The figures however do not represent true time. The Atlas timer does however give a good approximation to true time when a large sample of instructions are taken (a complete program for instance). In the case of the simpler statements, the accuracy of the counter is not likely to be very high, since the actual time taken for an instruction and the time accounted for by the counter do not agree exactly. As this timer is used for charging purposes it does seem reasonable to take this as a measure of central processor utilisation. The sin, cos, exp, sqrt, entier, arctan and ln functions are in the fixed store of Atlas which has a faster access time. But the mill timer makes no allowance for this so these figures are somewhat unfavourable.

The ICL (English Electric) KDF9 figures were obtained by the author using the Kidsgrove Algol compiler without the optimising phase. As has already been mentioned the shorter statements were timed by making large numbers of copies of the machine code sequences, and hence are accurate to half a microsecond. The longer times have an error of about three per cent. The KDF9 has a six microsecond store with extensive instruction look-ahead. It has a hardware stack of 16 cells. The average instruction time for a large number of instructions is typically about seven microseconds.

The ICL (Elliott) 4130 times were obtained by H.S.P. Jones of the University of Warwick. This particular machine had a six microsecond core store. The figures are accurate to within two per cent or one microsecond whichever is the larger. Figures passed on to the author by Mr. Jones, which are accurate to about six per cent, give the results for a two microsecond version of this machine which was timed by Dr. Thompson of Leicester University.

The ICL (Elliott) 503 times are from Enid Carter at the Rocket Propulsion Establishment. The machine has a 3.5 microsecond store. All the Elliott Algol compilers are made to a similar specification which excludes use of a procedure before declaration, but always includes subscript checks at run time.

The RREAC computer was made by the Royal Radar Establishment. It has a six microsecond store, and instructions with address modification takes about ten microseconds. The compiler was also produced locally, but it excludes mutual recursion. The timing was done by S.N. Higgins with an error of two or three microseconds. Two sets of figures were obtained depending on the context of the variables. The shorter figures apply when the variables are accessed within the local procedure or main program in which they are declared. The longer figures deal with the general case. The figures used in the analysis are the mean of the two sets. This is perhaps unfavourable to RREAC. since a simple program as run on most of the other machines would give the shorter times.

The CDC 3600 figures are from Per M. Kjeldas of the Kjeller Computer Installation, Norway. The compiler is not that provided by Control Data but written at Kjeller. The figures are apparently accurate to one microsecond. The machine has a one microsecond store.

The ICL (ICT) 1907 figures are for the two microsecond store version of this machine. The timing was done with a one second clock and the accuracy varies substantially but averages about ten per cent. In fact two sets of figures have been obtained with the variables declared at different block levels, but the shorter times with the declarations at the main block have been used.

The Univac 1108 figures were produced by Dr. M.D. Poole of the National Engineering Laboratory. These figures have an error of about .2 microseconds, and consequently the shorter statements times are not very accurate. This machine has a 750 nanosecond store.

5. The analysis

5.1 Analysis of the times - a model

The results obtained from the timing measurements are in Appendix D. These give an immediate comparison of the combined performance of machine and compiler. However, the time any statement takes on a particular machine clearly depends on both the statement and the machine. In fact, it is reasonable to suppose that a particular time is approximately the product of a factor depending only on the machine and a factor depending only on the statement. This can be used as the basis of a statistical model from which one can calculate the machine factors and statement factors. Such a statistical analysis has been done with the assistance of M.G. Cox (N.P.L. Division of Numerical and Applied Mathematics).

The machine factors are of course, relative, so one machine is taken arbitrarily to have a unit factor. In Appendixes D.5 and D.6, Atlas has been taken for this purpose. The machine factors (Appendix D.5) represent the relative machine speeds as judged from these figures only and weighting each statement with equal significance. The statement factors (Appendix D.6) are in microseconds and represent the estimated times Atlas would take to perform the statements by looking at the figures as a whole (i.e. an "average" Atlas). Since this analysis is only viable if the machines being considered are reasonably comparable, figures for machines without hardware floating point or interpretive schemes have been ignored.

5.2 Analysis of the times - the mathematics

Given that the time for statement i (i = 1 to n) on machine j (j = 1 to m) is Ti j then the model is

Ti j = Fi × Sj × Ri j

where

Fi = time depending on the statement

Sj = factor for the machine, taken as unity for one machine (arbitrarily)

Ri j = log-normally distributed "random" variable.

The problem now is to find the Fi and Sj. Denoting LTi j = ln(Ti j), etc. then one is required to minimise:

E = i j LR i j 2 = i j LF i + LS j - LT i j 2 E = i j LR i j 2 = i j LF i + LS j - LT i j 2

Differentiating with respect to the LFi and LSj one has

j LF i + LS j - LT i j = m LF i + j LS j - LT i * = 0 j LF i + LS j - LT i j = m LF i + j LS j - LT i * = 0

i LF i + LS j - LT i j = i LF i + n LS j - LT * j = 0 i LF i + LS j - LT i j = i LF i + n LS j - LT * j = 0

where LTi * and LT* j are the row and column sums respectively of the matrix (LTi j).

Taking S1 = 1 (i.e. LS1 = 0) one has m+n-1 equations

m LF i + j LS j = LT i * , i = 1 to n m LF i + j LS j = LT i * , i = 1 to n

i LF i + n LS j = LT * j , i = 2 to m i LF i + n LS j = LT * j , i = 2 to m

but we also have

i LF i = LT * i i LF i = LT * i

which is a linear combination of the others. Hence

LS j = 1 n LT * j - LT * 1 , j = 1 to m LS j = 1 n LT * j - LT * 1 , j = 1 to m

LF i = LT i * m + LT * 1 n - LT * * m n , j = 1 to n LF i = LT i * m + LT * 1 n - LT * * m n , j = 1 to n

where LT* * is the sum of all the elements of (LTi j).

From this the Sj, Fi and Ei j can be calculated. the computer program for doing this calculation is listed in Appendix B, the data for the program in Appendix C and the results in Appendix D.

6. Comments on the figures

The matrix Ei j printed out in Appendix D.3 represents the ratio between a predicted value for the time (based on the model) and the actual time. hence the significance of the Ri j is that a large value indicates that the machine is slower than expected on this operation and vice-versa for small values. Note that the Ri j are independent of the machine taken as standard, so individual characteristics of the chosen implementation are not significant. These figures therefore provide a yardstick for compiler writers in measuring the performance of their implementation. One can also see which parts of an implementation are relatively slow giving one an indication of which things are possibly capable of improvement.

Some of the exceptional figures have simple explanations. On the UNIVAC 1108 variables are initialised on declaration, so begin array a[1 :500]; end' naturally takes some time. The short time for 'begin real a; end' on RREAC (actually zero, but this value could not be inserted because of the analysis) is due to the fact that storage is laid out at procedure rather than block level (except for arrays). This technique is described in [1]. The short time for 'k:= 1.0' on the ICL 1907 is because it is the only compiler so far to do the type conversion at compile time. The large value for procedure entry on the CDC 3600 is due to the fact that use of formal parameters has been optimised at the expense of procedure entry (call by simple name is thus very fast).

All the Elliott compilers (for both the 4130's and 503) do subscript checking and so the array accessing instructions are not strictly comparable with the other machines. The 4130 has special hardware instructions for array accessing. It can be seen that this is very effective since the machine is faster on this in relation to the speed of the machine than most of the machines which do not do subscript checking (see Algol Bulletin 29 for a discussion of this). Most compilers offer an option over this but the ratio of time between doing and not doing the check varies substantially.

The time for x := y exp z on KDF9 is faster than the times for ln and exp since the exp routine checks to see if z is integral and if so uses repeated multiplication. Hence the choice of 1.0 for z is very unfortunate in this case.

It is important to note that the machine factors Sj may not correspond to the relative execution times of bench-mark programs due to the fact that some of the simpler statements are likely to be relatively more important than others (see section 7). For this reason this analysis could not replace the conventional assessment of machines based upon bench-mark programs.

By inspecting the rows and columns of the Ri j one can calculate how consistent a machine or statement is. These figures are the standard errors in the machine and statement factors, and are printed out in Appendixes D.5 and D.7. The most consistent statement is x := y/z which is to be expected when one realises that this statement probably spends a large proportion of its time in one instruction - floating point divide. It is also clear from the standard errors that different techniques are used for abs and ln. The standard error for 'begin real a; end' is anomalous because of the very short time (actually zero but replaced by one microsecond) on RREAC.

7. Optimising Compilers

The technique described in this paper is not very suitable for compilers which generate extensively optimised code. . The reason for this is that the code produced for a statement will depend critically on the context in which it appears. This relates mainly to subscripting since the use of index registers for this instead of simple code represents a very substantial improvement in the running time of most programs. Of course, if code is take out of the for loop then the timing method is no longer valid for i := 1 step 1 until n do x:= y can be optimised to x := y. Such optimisation is done in some FORTRAN compilers (see [3]). Even if this degree of optimisation is not done, it may no longer be true that the for loop code is independent. of the statement s.

Evaluation of such compilers clearly requires some statistical information about the use of subscripted variables in different contexts. This could be obtained from programs at a particular installation or from the published algorithms. The GAMM program is a good example of a bench-mark which is capable of extensive optimisation. A set of such bench-marks may be the simplest solution to this problem.

The KDF9 has an optimising compiler which was not used in this study (see [1]). Apart from the difficulties outlined above, the optimising phase is incorrect code in some cases.

8. Further Work

As has already been mentioned, it is not clear which particular statements and language features are more important from the point of view of execution times. At this Laboratory the Whetstone Algol system is extensively used for program testing. This can be modified to count the frequency of Object Program Operations (see [2]) which will give some indication of how important particular features are during program testing.

Although the figures give a lot of information and the Ri j indicates what features are dealt with satisfactorily, the analysis gives little indication why the figures have the form they do. It is hoped to investigate the code produced by a few compilers for a number of simple programs (including the timing program) to answer this question.

The author would welcome timing figures for additional machines since repeated for an extra machine with very little effort.

9. Acknowledgements

The author expresses his gratitude for substantial assistance in the above, particularly from M.G. Cox in providing the explicit equations for the machine and statement factors given in section 5.2. Of course, the paper would not have been possible without the machine times provided by the following:-

Appendix A

Listing of the timing program

The following is a listing of a program to time one statement s. It may be more convenient to put some or all of the statements in one program. In this version of the program the clock correction c has been omitted since the value of n is assumed to be large enough for c to be negligible.

            begin 
real x,y,z; integer  i,k,l,m; integer  array e1 [1:1], e2 [1:1, 1:1], e3 [1:1, 1:1, 1:1] ; procedure pO; ; procedure p1 (x); value x; real x; ; procedure p2(x,y); value x,y; real x,y; ; procedure p3(x,y,z); value x,y,z; real x,y,z; ; x := y := z := 1.0; k := m := 1; e1 [1] := 1; outreal (time); for i := 1 step 1 until <n> do <s>; outreal (time); end

Appendix B.1

Comments on the analysis program

A program to do the calculation as in section 5.2 is listed below. Some timing values may be absent, and this is dealt with in the following way. Missing values are given a negative time on the data tape. The values of i and j for which t[i,j] is missing is recorded in the array mi and mj, and the value replaced by 1.0. The analysis is then used to guess better values for the missing t[i,j]. This process is repeated until the ratio between the next guess and the current guess for all the missing t[i,j] lies between .999 and 1.001. The number of iterations is recorded by tt. Not more than one tenth of the total timing values must be missing.

In order to provide an intelligent print-out, the machine names and statement texts are preserved in the array text, so that they can be printed out when appropriate. The KDF9 library procedures instring and outstring are particularly convenient for this. The only complication is that it is necessary to preserve the starting position of the machine names in the variable machstart.

Listing of the analysis program Appendix B.2

            begin
            
library A6. A13, A20, A30; commentA6, A13, A20, A30; integer  fl, f2, 1, j, jl, j2, k, m, missing, mstart, n, od, size, start, cr1f, maize, machstart, tt; boolean recalculate; real sum, s1, x, l1; comment Initialise, variables; crlf := 16o; f1 := format( [8s-ndd0.0] ); f2 := format( [7s-ndd.000]); l1 := ln(1.001); missing := 0; open(20) ; od := read( 20 ); open( od ); m := read(2o); n := read(20); msize := 3 × m + 5 × n; tt := 0; begin
real array t, lt, r, lr[1:n, 1:m], lf, f[1:n], ls, s[1:m]; integer  array text [ 1:msize ], ml, mj[ 1:4 + n ×m + 10]; procedure read descriptions; begin start := 1; size := 6 × msize; for i := 1 step 1 until n do
instrlng(20, text, start, size); machstart := start; end read descriptions; procedure read times; for j := 1 step 1 until m do
begin instring(20, text, start, size); for 1 := 1 step 1 until n do
begin x := read(20); if x < 0 then 
begin missing := missing + 1; mi[missing] := i; mj[missing] := j; t [i,j] := -1.0; lt[i,j] := 0.0 end
else
begin t [i, j] := x; lt[i, j] := ln(x) end
end
end read times; procedure print row (p); procedure p; begin  start := machstart; for j := 1 step 1 until m do
begin p; write text( od, [[5s]] }; outstring( text, start, od ); if j = j+5×5 then  outbasicsymbol( outbasicsymbol(od,crlf); end
end print row; procedure print column(p}; procedure p; begin  start := 1; for j := 1 step 1 until n do
begin p; write text( od, [[5s]] ); outstring( text, start, od }; if i = i+5×5 then  outbasicsymbol( outbasicsymbol(od,crlf); end
end print column; procedure print matrix(p): procedure p; begin  mstart := machstart; j1 := 1; j2 := if m < 5 then  m else 5; again: write text(od, [[5s]]); for j := j1 step 1 until j2 do
outstring( text, mstart, od ); write text( od, [[cc]]); start := 1; for i := 1 step 1 until n do
begin
for j := j1 step 1 until j2 do
p; write text( od, [[5s]] ); outstring( text, start, od ); if i = i+5×5 then  outbasicsymbol( outbasicsymbol(od,crlf); outbasicsymbol(od,crlf); end; if j2 = m then  goto finish else
begin  j1 := j2 + 1; j2 := if j1 + 4 > m then  m else j1 + 4; write text(od, [[cc]]); goto again; end; finish:; end print matrix; procedure tij; if t [i,j] ≥ 0 then  write( od,f1, t[i,j] ) else
begin write text( od, [[7s]missing*] ); t[i,j] := 1.0 end; procedure sj; write(od, f2 , s[j] ) ; procedure fi; write(od, f1 , f[i] ) ; procedure rij; write(od, f2 , r [i,j] ); procedure lrij; write(od, f2, lr[i,j] ); comment main program; read descriptions; read times; write text(od, [[clobserved*machine*times[c]]); close(20) ; print matrix(tij); iteration step:; tt := t t + 1; for i := 1 step 1 until n do
begin x := 0.0; for j := 1 step 1 until m do
x := x + lt[i.j]; f[i] := x; end; sum := 0.0; for j := 1 step 1 until m do
begin x := 0.0; for i := 1 step 1 until n do
x := x + lt[i,j]; sum := sum + x; s[j] := x end; comment s and f are the row and column sums and sum the total sum of the matr1x lt; s1 := s[l]; s[1] := 1.0; for j := 2 step 1 until m do
begin ls [j] := (s[j] -s1)/n; s[j] := exp(ls[j]) end; for i := 1 step 1 until n do
for j := 2 step 1 until m do
x := lf[i] := f[i]/m + s1/n - sum/(m×n); x := f[i] := exp(x}; for j := 1 step 1 until m do
begin r[i,j] := t[i,j]/xxs[j]); lr[i,j] := lt[i,j] - lf[i] - ls[j] end
end; rli,j) := t[1,j]/( xxs[J] ); lr[ 1, j] := It L 1, j] - If [ 1] - 1 s [ j ) recalculate := false; for k := 1 step 1 until missing do
begin x := t[mi[k] , mj[k] ] := t[ mi[k] , mj[k] ] / r[mi[k] , mj[k] ]; recalculate := recalculate or (abs( ln( r[mi[k] , mj[k]] ] )) > l1); end; if recalculate then  goto iteration step; if missing ≠ 0 then  begin write text( od, [[cc]number*of*iteratlons[c]] ); write( od, format[ [ndd] ), tt-1 ); write text( od, [[cc]observed*times*and*predicted*times[cc]] ); print matrix( tij ) end; write text( od, [[cc]r[i,j]*after*1teratlon[cc]] ); print matrix (rij); write text( od, [[ cc]logarithms*of*r[i,j] [ cc]] ); print matrix( lrij ); write text( od, [[ cc]machine*factors[ cc]] ); print row( sj ); write text( od, [[ cc]statement*factors[ cc]] ); print column( fi ) for j := 1 step 1 until m do
s[j] := 1.0/s[j]; write text( od, [[ cc]speed*factors*=*1/machine*factors[ cc]] ); print row(sj); ) ; comment calculate standard error of fi and sj expressed as a percentage; for j := 1 step 1 until m do
begin x := 0.0; for i := 1 step 1 until n do
x := x + lr[i,j] exp 2; s[j] := 100.0 × ( exp( sqrt ( x/n ) ) - 1.0 ); end; write text( od, [[ cc]standard*error*in*machine*factors*as*a*percentage[ cc]] ); print row (sj ); for i := 1 step 1 until n do
begin x := 0.0; for j := 1 step 1 until m do
x := x + lr[i,j] exp 2; f[i] := 100.0 × ( exp ( sqrt (x/m ) ) - 1.0); end; write text( od, [[ cc]standard*error*ln*statement*factors*as*a*percentage[ cc]] ); print column( fi ); close(od); end; end

Data for the analysis program Appendix C

            [ x := 1.0 ]
            
[ x := 1 ]
[ x := y ]
[ x := y + z ]
[ x := y × z ]
[ x := y / z ]
[ k := 1 ]
[ k := 1.0 ]
[ k := l + m]
[ k := l × m]
[ k := l ÷ m ]
[ k := l ]
[ x := l ]
[ l := y ]
[ x := y exp 2 ]
[ x := y exp 3 ]
[ x := y exp z ]
[e1[1] := 1 ]
[e2[1,1] := 1 ]
[e3[1,1,1] := 1]
[l := e1[1] ]
[ begin real a; end ]
[ begin array a[ 1:1 ]; end ]
[ begin array a[ 1:500 ]; end ]
[ begin array a [ 1:1, 1:1 ]; end ]
[ begin array a [ 1:1, 1:1, 1:1 ]; end ]
[ begin goto abcd; abcd: end ]
[ begin switch ss:=pq; goto ss[1]; pq:end ]
[x := sin(y)]
[x := cos(y)]
[x := abs(y)]
[x := exp(y)]
[x := ln(y)]
[x := sqrt(y)]
[x := arctan(y)]
[x := sign(y)]
[x := entier(y)]
[p0]
[p1( x )]
[p2 ( x, y )]
[p3( x, y, z )]

Data for the analysis program Appendix C

            [ ATLAS ]
6;6;6;9;12;
18;9;18;12;15; 
48;9;6;18;39;
48;120;21;27;33;
15;45;96;96;156;
216;42;129;210;222;
84;270;261;246;272; 
99;99;54;69;75;
93;






[ KDF9 ]
27.3;118;27.3;45;53;
73;24.3;93;40;53;
121;28;124;101;209;
88;33;771;764;995;
1052;31;591;654;696;
193;676;783;422;1115;
191;326;80;110;121;
137;

[ ICL4130 2 µs ]
-1;24;17;28;47; 
80;11;38;16;36;
40;11;21;38;55;
170;1700;46;60;120;
36;350;1000;1000;1100; 
2300;3;900;1100;1000; 
60;700;1100;600;1100; 
60;80;390;410;430;
400;
[ ICL4130 6 µs ]
36;44;37;56;74;
109;24;66;35;70;
64;23;41;66;92;
339;2920;99;136;174;
74;820;2340;2330;3790;
5200;5;1990;1560;1650;
138;1430;2020;1140;1710;
152;164;900;930;980;
1010;

[ ICL 503 ]
20;53;20;42;63; 
87;20;186;36;85;
281;18;46;182;401;
457;2974;216;347;480;
236;210;910;910;1220; 
1528;28;288;1272;1177; 
36;1343;1519;518;1726;
122;211;27;42;59;
79;

[ RREAC ]
47;98;56;94;129;
185;45;84;80;147; 
410;53;107;92;676;
750;3166;109;208;272;
118;1;1062;1062;1593; 
1965;58;208;1122;1299; 
97;1111;1708;842;1749;
195;151;255;332;381;
430;


[ CDC 3600 ]
4;4;4;9;11;
18;4;4;9;11;
24;4;4;9;124 ;
130;99;11;29;40;
9;5;65;65;89;
113;12;98;131;137;
23;141;130;113;159;
25;30;114;246;362;
504;


[ ICL 1907 ]
15;14;14;23;31; 
47;8;8;15;37;
53;11;36;37;97;
117;232;17;37;57;
20;64.357;324;407; 
507;14;109;328;357;
70;386;97;357;490;
64;96;104;187;232;
282;

[ UNIVAC 1108 ]
1.9;1.9;1.8;3.7;4.8;
11;2;17.9;2.9;4.4; .
13.8;1.6;3.6;17.4;11;
10.7;12.4;12.6;20.4;44.4;
13;52.3;113.6;1017;125.7;
141.1;1.1;156.7;42.9;44.2;
1.9;40.8;38.3;36.8;74.9;
5.4;16.4;73.9;170.6;267.6;
361.6; 

Observed machine times in microseconds Appendix D.1

ATLAS KDF9 ICL 4130 2µs ICL 4130 6µs ICL 503 Instruction
6.0 27.3 missing 36.0 20.0 [ x := 1.0 ]
6.0 118.0 24.0 44.0 53.0 [ x := 1 ]
6.0 27.3 17.0 37.0 20.0 [ x := y ]
9.0 45.0 28.0 56.0 42.0 [ x := y + z ]
12.0 53.0 47.0 74.0 63.0 [ x := y × z ]
18.0 73.0 80.0 109.0 87.0 [ x := y / z ]
9.0 24.3 11.0 24.0 20.0 [ k := 1 ]
18.0 93.0 38.0 66.0 186.0 [ k := 1.0 ]
12.0 40.0 16.0 35.0 36.0 [ k := l + m]
15.0 53.0 36.0 70.0 85.0 [ k := l × m]
48.0 121.0 40.0 54.0 281.0 [ k := l ÷ m ]
9.0 28.0 11.0 23.0 18.0 [ k := l ]
6.0 124.0 21.0 41.0 46.0 [ x := l ]
18.0 101.0 38.0 66.0 182.0 [ l := y ]
39.0 209.0 55.0 92.0 401.0 [ x := y exp 2 ]
48.0 231.0 170.0 339.0 457.0 [ x := y exp 3 ]
120.0 288.0 1700.0 2920.0 2970.0 [ x := y exp z ]
21.0 78.0 46.0 99.0 216.0 [e1[1] := 1 ]
27.0 181.0 60.0 136.0 347.0 [e2[1,1] := 1 ]
33.0 367.0 120.0 174.0 480.0 [e3[1,1,1] := 1]
15.0 88.0 36.0 74.0 236.0 [l := e1[1] ]
45.0 33.0 350.0 820.0 210.0 [ begin real a; end ]
96.0 771.0 1000.0 2340.0 910.0 [ begin array a[ 1:1 ]; end ]
96.0 764.0 1000.0 2330.0 910.0 [ begin array a[ 1:500 ]; end ]
156.0 995.0 1600.0 3790.0 1220.0 [ begin array a [ 1:1, 1:1 ]; end ]
216.0 1050.0 2300.0 5200.0 1530.0 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
42.0 31.0 3.0 5.0 28.0 [ begin goto abcd; abcd: end ]
129.0 591.0 900.0 1990.0 288.0 [ begin switch ss:=pq; goto ss[1]; pq:end ]
210.0 654.0 1100.0 1560.0 1270.0 [x := sin(y)]
222.0 696.0 1000.0 1650.0 1180.0 [x := cos(y)]
84.0 193.0 60.0 138.0 36.0 [x := abs(y)]
270.0 676.0 700.0 1430.0 1340.0 [x := exp(y)]
261.0 783.0 1100.0 2020.0 1520.0 [x := ln(y)]
246.0 422.0 600.0 1140.0 518.0 [x := sqrt(y)]
272.0 1120.0 1100.0 1710.0 1730.0 [x := arctan(y)]
99.0 191.0 60.0 152.0 122.0 [x := sign(y)]
99.0 326.0 80.0 164.0 211.0 [x := entier(y)]
54.0 80.0 390.0 900.0 27.0 [p0]
69.0 110.0 410.0 930.0 42.0 [p1( x )]
75.0 121.0 430.0 980.0 59.0 [p2 ( x, y )]
93.0 137.0 400.0 1010.0 79.0 [p3( x, y, z )]
RREAC CDC 3600 ICL 1907 UNIVAC 1108 Instruction
47.0 4.0 15.0 1.9 [ x := 1.0 ]
98.0 4.0 14.0 1.9 [ x := 1 ]
56.0 4.0 14.0 1.8 [ x := y ]
94.0 9.0 23.0 3.7 [ x := y + z ]
129.0 11.0 31.0 4.8 [ x := y × z ]
185.0 18.0 47.0 11.0 [ x := y / z ]
45.0 4.0 8.0 2.0 [ k := 1 ]
84.0 4.0 8.0 17.9 [ k := 1.0 ]
80.0 9.0 15.0 2.9 [ k := l + m]
147.0 11.0 37.0 4.4 [ k := l × m]
410.0 24.0 53.0 13.8 [ k := l ÷ m ]
53.0 4.0 11.0 1.6 [ k := l ]
107.0 4.0 36.0 3.6 [ x := l ]
92.0 9.0 37.0 17.4 [ l := y ]
676.0 124.0 97.0 11.0 [ x := y exp 2 ]
750.0 130.0 117.0 10.7 [ x := y exp 3 ]
3170.0 99.0 232.0 12.4 [ x := y exp z ]
109.0 11.0 17.0 12.6 [e1[1] := 1 ]
208.0 29.0 37.0 20.4 [e2[1,1] := 1 ]
272.0 40.0 57.0 44.4 [e3[1,1,1] := 1]
118.0 9.0 20.0 13.0 [l := e1[1] ]
1.0 5.0 64.0 52.3 [ begin real a; end ]
1060.0 65.0 357.0 114.0 [ begin array a[ 1:1 ]; end ]
1060.0 65.0 324.0 1020.0 [ begin array a[ 1:500 ]; end ]
1590.0 89.0 407.0 126.0 [ begin array a [ 1:1, 1:1 ]; end ]
1960.0 113.0 507.0 141.0 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
58.0 12.0 14.0 1.1 [ begin goto abcd; abcd: end ]
208.0 98.0 109.0 157.0 [ begin switch ss:=pq; goto ss[1]; pq:end ]
1120.0 131.0 328.0 42.9 [x := sin(y)]
1300.0 137.0 357.0 44.2 [x := cos(y)]
97.0 23.0 70.0 1.9 [x := abs(y)]
1110.0 141.0 386.0 40.8 [x := exp(y)]
1710.0 130.0 97.0 38.3 [x := ln(y)]
842.0 113.0 357.0 36.8 [x := sqrt(y)]
1750.0 159.0 490.0 74.9 [x := arctan(y)]
195.0 25.0 64.0 5.4 [x := sign(y)]
151.0 30.0 96.0 16.4 [x := entier(y)]
255.0 114.0 104.0 73.9 [p0]
332.0 246.0 187.0 171.0 [p1( x )]
381.0 362.0 232.0 268.0 [p2 ( x, y )]
430.0 504.0 282.0 362.0 [p3( x, y, z )]

Observed and predicted machine times Appendix D.2

ATLAS KDF9 ICL 4130 2µs ICL 4130 6µs ICL 503 Instruction
6.0 27.3 18.6 36.0 20.0 [ x := 1.0 ]
6.0 118.0 24.0 44.0 53.0 [ x := 1 ]
6.0 27.3 17.0 37.0 20.0 [ x := y ]
9.0 45.0 28.0 56.0 42.0 [ x := y + z ]
12.0 53.0 47.0 74.0 63.0 [ x := y × z ]
18.0 73.0 80.0 109.0 87.0 [ x := y / z ]
9.0 24.3 11.0 24.0 20.0 [ k := 1 ]
18.0 93.0 38.0 66.0 186.0 [ k := 1.0 ]
12.0 40.0 16.0 35.0 36.0 [ k := l + m]
15.0 53.0 36.0 70.0 85.0 [ k := l × m]
48.0 121.0 40.0 64.0 281.0 [ k := l ÷ m ]
9.0 28.0 11.0 23.0 18.0 [ k := l ]
6.0 124.0 21.0 41.0 46.0 [ x := l ]
18.0 101.0 38.0 66.0 182.0 [ l := y ]
39.0 209.0 55.0 92.0 401.0 [ x := y exp 2 ]
48.0 231.0 170.0 339.0 457.0 [ x := y exp 3 ]
120.0 288.0 1700.0 2920.0 2970.0 [ x := y exp z ]
21.0 78.0 46.0 99.0 216.0 [e1[1] := 1 ]
27.0 181.0 60.0 136.0 347.0 [e2[1,1] := 1 ]
33.0 367.0 120.0 174.0 480.0 [e3[1,1,1] := 1]
15.0 88.0 36.0 74.0 236.0 [l := e1[1] ]
45.0 33.0 350.0 820.0 210.0 [ begin real a; end ]
96.0 771.0 1000.0 2340.0 910.0 [ begin array a[ 1:1 ]; end ]
96.0 764.0 1000.0 2330.0 910.0 [ begin array a[ 1:500 ]; end ]
156.0 995.0 1600.0 3790.0 1220.0 [ begin array a [ 1:1, 1:1 ]; end ]
216.0 1050.0 2300.0 5200.0 1530.0 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
42.0 31.0 3.0 5.0 28.0 [ begin goto abcd; abcd: end ]
129.0 591.0 900.0 1990.0 288.0 [ begin switch ss:=pq; goto ss[1]; pq:end ]
210.0 654.0 1100.0 1560.0 1270.0 [x := sin(y)]
222.0 696.0 1000.0 1650.0 1180.0 [x := cos(y)]
84.0 193.0 60.0 138.0 36.0 [x := abs(y)]
270.0 676.0 700.0 1430.0 1340.0 [x := exp(y)]
261.0 783.0 1100.0 2020.0 1520.0 [x := ln(y)]
246.0 422.0 600.0 1140.0 518.0 [x := sqrt(y)]
272.0 1120.0 1100.0 1710.0 1730.0 [x := arctan(y)]
99.0 191.0 60.0 152.0 122.0 [x := sign(y)]
99.0 326.0 80.0 164.0 211.0 [x := entier(y)]
54.0 80.0 390.0 900.0 27.0 [p0]
69.0 110.0 410.0 930.0 42.0 [p1( x )]
75.0 121.0 430.0 980.0 59.0 [p2 ( x, y )]
93.0 137.0 400.0 1010.0 79.0 [p3( x, y, z )]
RREAC CDC 3600 ICL 1907 UNIVAC 1108 Instruction
47.0 4.0 15.0 1.9 [ x := 1.0 ]
98.0 4.0 14.0 1.9 [ x := 1 ]
56.0 4.0 14.0 1.8 [ x := y ]
94.0 9.0 23.0 3.7 [ x := y + z ]
129.0 11.0 31.0 4.8 [ x := y × z ]
185.0 18.0 47.0 11.0 [ x := y / z ]
45.0 4.0 8.0 2.0 [ k := 1 ]
84.0 4.0 8.0 17.9 [ k := 1.0 ]
80.0 9.0 15.0 2.9 [ k := l + m]
147.0 11.0 37.0 4.4 [ k := l × m]
410.0 24.0 53.0 13.8 [ k := l ÷ m ]
53.0 4.0 11.0 1.6 [ k := l ]
107.0 4.0 36.0 3.6 [ x := l ]
92.0 9.0 37.0 17.4 [ l := y ]
676.0 124.0 97.0 11.0 [ x := y exp 2 ]
750.0 130.0 117.0 10.7 [ x := y exp 3 ]
3170.0 99.0 232.0 12.4 [ x := y exp z ]
109.0 11.0 17.0 12.6 [e1[1] := 1 ]
208.0 29.0 37.0 20.4 [e2[1,1] := 1 ]
272.0 40.0 57.0 44.4 [e3[1,1,1] := 1]
118.0 9.0 20.0 13.0 [l := e1[1] ]
1.0 5.0 64.0 52.3 [ begin real a; end ]
1060.0 65.0 357.0 114.0 [ begin array a[ 1:1 ]; end ]
1060.0 65.0 324.0 1020.0 [ begin array a[ 1:500 ]; end ]
1590.0 89.0 407.0 126.0 [ begin array a [ 1:1, 1:1 ]; end ]
1960.0 113.0 507.0 141.0 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
58.0 12.0 14.0 1.1 [ begin goto abcd; abcd: end ]
208.0 98.0 109.0 157.0 [ begin switch ss:=pq; goto ss[1]; pq:end ]
1120.0 131.0 328.0 42.9 [x := sin(y)]
1300.0 137.0 357.0 44.2 [x := cos(y)]
97.0 23.0 70.0 1.9 [x := abs(y)]
1110.0 141.0 386.0 40.8 [x := exp(y)]
1710.0 130.0 97.0 38.3 [x := ln(y)]
842.0 113.0 357.0 36.8 [x := sqrt(y)]
1750.0 159.0 490.0 74.9 [x := arctan(y)]
195.0 25.0 64.0 5.4 [x := sign(y)]
151.0 30.0 96.0 16.4 [x := entier(y)]
255.0 114.0 104.0 73.9 [p0]
332.0 246.0 187.0 171.0 [p1( x )]
381.0 362.0 232.0 268.0 [p2 ( x, y )]
430.0 504.0 282.0 362.0 [p3( x, y, z )]

r[i,j] matrix Appendix D.3

r[i,j] after iteration

ATLAS KDF9 ICL 4130 2µs ICL 4130 6µs ICL 503 Instruction
0.946 1.180 0.999 0.980 0.754 [ x := 1.0 ]
0.637 3.430 0.867 0.807 1.350 [ x := 1 ]
0.947 1.180 0.913 1.010 0.755 [ x := y ]
0.805 1.100 0.853 0.866 0.899 [ x := y + z ]
0.793 0.959 1.060 0.845 0.996 [ x := y × z ]
0.757 0.841 1.150 0.792 0.875 [ x := y / z ]
1.630 1.210 0.679 0.752 0.868 [ k := 1 ]
1.160 1.640 0.832 0.733 2.860 [ k := 1.0 ]
1.320 1.200 0.598 0.664 0.946 [ k := l + m]
0.946 0.915 0.773 0.763 1.280 [ k := l × m]
1.470 1.010 0.417 0.338 2.060 [ k := l ÷ m ]
1.590 1.350 0.660 0.701 0.759 [ k := l ]
0.547 3.090 0.651 0.645 1.000 [ x := l ]
0.880 1.350 0.632 0.558 2.130 [ l := y ]
0.774 1.140 0.372 0.315 1.900 [ x := y exp 2 ]
0.669 0.882 0.806 0.816 1.520 [ x := y exp 3 ]
0.584 0.384 2.820 2.460 3.460 [ x := y exp z ]
1.030 1.050 0.771 0.843 2.540 [e1[1] := 1 ]
0.761 1.400 0.576 0.662 2.340 [e2[1,1] := 1 ]
0.598 1.820 0.740 0.545 2.080 [e3[1,1,1] := 1]
0.789 1.270 0.645 0.673 2.970 [l := e1[1] ]
1.920 0.386 5.090 6.050 2.140 [ begin real a; end ]
0.469 1.030 1.660 1.980 1.060 [ begin array a[ 1:1 ]; end ]
0.373 0.812 1.320 1.560 0.845 [ begin array a[ 1:500 ]; end ]
0.550 0.962 1.920 2.310 1.030 [ begin array a [ 1:1, 1:1 ]; end ]
0.606 0.808 2.200 2.520 1.020 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
7.150 1.450 0.174 0.147 1.140 [ begin goto abcd; abcd: end ]
0.928 1.160 2.200 2.470 0.495 [ begin switch ss:=pq; goto ss[1]; pq:end ]
0.989 0.844 1.760 1.270 1.430 [x := sin(y)]
1.010 0.868 1.550 1.300 1.280 [x := cos(y)]
3.600 2.270 0.876 1.020 0.369 [x := abs(y)]
1.270 0.874 1.130 1.170 1.520 [x := exp(y)]
1.240 1.020 1.780 1.660 1.730 [x := ln(y)]
1.550 0.727 1.280 1.240 0.770 [x := sqrt(y)]
0.940 1.060 1.290 1.020 1.430 [x := arctan(y)]
2.970 1.570 0.614 0.789 0.877 [x := sign(y)]
2.160 1.950 0.593 0.618 1.100 [x := entier(y)]
0.875 0.355 2.150 2.520 0.105 [p0]
0.754 0.329 1.530 1.760 0.110 [p1( x )]
0.671 0.296 1.310 1.510 0.126 [p2 ( x, y )]
0.701 0.283 1.030 1.320 0.142 [p3( x, y, z )]
RREAC CDC 3600 ICL 1907 UNIVAC 1108 Instruction
1.330 0.880 1.460 0.710 [ x := 1.0 ]
1.870 0.592 0.917 0.478 [ x := 1 ]
1.590 0.881 1.360 0.674 [ x := y ]
1.510 1.120 1.270 0.785 [ x := y + z ]
1.530 1.010 1.260 0.752 [ x := y × z ]
1.400 1.060 1.220 1.100 [ x := y / z ]
1.470 1.010 0.895 0.860 [ k := 1 ]
0.972 0.359 0.317 2.730 [ k := 1.0 ]
1.580 1.380 1.020 0.756 [ k := l + m]
1.670 0.968 1.440 0.658 [ k := l × m]
2.260 1.020 1.000 1.000 [ k := l ÷ m ]
1.680 0.984 1.200 0.669 [ k := l ]
1.750 0.508 2.020 0.778 [ x := l ]
0.809 0.614 1.120 2.020 [ l := y ]
2.410 3.430 1.190 0.518 [ x := y exp 2 ]
1.880 2.530 1.010 0.354 [ x := y exp 3 ]
2.770 0.673 0.697 0.143 [ x := y exp z ]
0.966 0.756 0.517 1.470 [e1[1] := 1 ]
1.050 1.140 0.644 1.360 [e2[1,1] := 1 ]
0.887 1.010 0.638 1.910 [e3[1,1,1] := 1]
1.120 0.661 0.649 1.620 [l := e1[1] ]
0.008 0.298 1.690 5.300 [ begin real a; end ]
0.935 0.444 1.080 1.320 [ begin array a[ 1:1 ]; end ]
0.742 0.352 0.776 9.360 [ begin array a[ 1:500 ]; end ]
1.010 0.438 0.886 1.050 [ begin array a [ 1:1, 1:1 ]; end ]
0.991 0.442 0.877 0.938 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
1.780 2.850 1.470 0.444 [ begin goto abcd; abcd: end ]
0.269 0.984 0.484 2.670 [ begin switch ss:=pq; goto ss[1]; pq:end ]
0.951 0.861 0.953 0.479 [x := sin(y)]
1.060 0.870 1.000 0.477 [x := cos(y)]
0.749 1.380 1.850 0.193 [x := abs(y)]
0.944 0.929 1.120 0.457 [x := exp(y)]
1.460 0.862 0.285 0.432 [x := ln(y)]
0.953 0.991 1.390 0.549 [x := sqrt(y)]
1.090 0.767 1.050 0.614 [x := arctan(y)]
1.050 1.050 1.190 0.385 [x := sign(y)]
0.592 0.912 1.290 0.848 [x := entier(y)]
0.744 2.580 1.040 2.840 [p0]
0.653 3.750 1.260 4.420 [p1( x )]
0.613 4.520 1.280 5.670 [p2 ( x, y )]
0.583 5.300 1.310 6.460 [p3( x, y, z )]

Logarithms of r[i,j] matrix Appendix D.4

ATLAS KDF9 ICL 4130 2µs ICL 4130 6µs ICL 503 Instruction
-0.056 0.164 -0.001 -0.020 -0.283 [ x := 1.0 ]
-0.451 1.230 -0.143 -0.215 0.297 [ x := 1 ]
-0.055 0.166 -0.091 0.009 -0.281 [ x := y ]
-0.217 0.098 -0.159 -0.144 -0.107 [ x := y + z ]
-0.232 -0.042 0.056 -0.169 -0.004 [ x := y × z ]
-0.278 -0.173 0.136 -0.233 -0.133 [ x := y / z ]
0.490 0.188 -0.387 -0.285 -0.142 [ k := 1 ]
0.146 0.493 -0.184 -0.310 1.050 [ k := 1.0 ]
0.276 0.185 -0.514 -0.409 -0.056 [ k := l + m]
-0.056 -0.088 -0.258 -0.271 0.248 [ k := l × m]
0.384 0.014 -0.876 -1.080 0.721 [ k := l ÷ m ]
0.462 0.302 -0.415 -0.356 -0.276 [ k := l ]
-0.604 1.130 -0.429 -0.438 0.002 [ x := l ]
-0.128 0.302 -0.458 -0.584 0.755 [ l := y ]
0.256 0.128 -0.990 -1.150 0.644 [ x := y exp 2 ]
-0.402 -0.126 -0.215 -0.203 0.421 [ x := y exp 3 ]
-0.538 -0.957 1.040 0.899 1.240 [ x := y exp z ]
0.034 0.051 -0.260 -0.171 0.934 [e1[1] := 1 ]
-0.273 0.334 -0.552 -0.412 0.850 [e2[1,1] := 1 ]
-0.514 0.600 -0.301 -0.607 0.733 [e3[1,1,1] := 1]
-0.237 0.237 -0.439 -0.397 1.090 [l := e1[1] ]
0.653 -0.952 1.630 1.800 0.763 [ begin real a; end ]
-0.756 0.032 0.510 0.682 0.062 [ begin array a[ 1:1 ]; end ]
-0.987 -0.208 0.278 0.446 -0.169 [ begin array a[ 1:500 ]; end ]
-0.597 -0.039 0.653 0.838 0.029 [ begin array a [ 1:1, 1:1 ]; end ]
-0.502 -0.213 0.786 0.924 0.024 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
1.970 0.369 -1.750 -1.920 0.131 [ begin goto abcd; abcd: end ]
-0.075 0.152 0.790 0.906 -0.702 [ begin switch ss:=pq; goto ss[1]; pq:end ]
-0.011 -0.170 0.567 0.238 0.359 [x := sin(y)]
0.010 -0.142 0.438 0.260 0.248 [x := cos(y)]
1.280 0.819 -0.132 0.023 -0.996 [x := abs(y)]
0.243 -0.134 0.118 0.154 0.416 [x := exp(y)]
0.216 0.019 0.577 0.506 0.546 [x := ln(y)]
0.436 -0.319 0.250 0.214 -0.250 [x := sqrt(y)]
-0.062 0.054 0.258 0.021 0.355 [x := arctan(y)]
1.090 0.452 -0.488 -0.237 -0.132 [x := sign(y)]
0.769 0.666 -0.522 -0.482 0.095 [x := entier(y)]
-0.133 -1.040 0.766 0.924 -2.260 [p0]
-0.282 -1.110 0.422 0.563 -2.210 [p1( x )]
-0.400 -1.220 0.269 0.415 -2.070 [p2 ( x, y )]
-0.355 -1.260 0.026 0.274 -1.950 [p3( x, y, z )]
RREAC CDC 3600 ICL 1907 UNIVAC 1108 Instruction
0.287 -0.128 0.378 -0.342 [ x := 1.0 ]
0.627 -0.524 -0.087 -0.738 [ x := 1 ]
0.464 -0.127 0.310 -0.395 [ x := y ]
0.415 0.117 0.239 -0.242 [ x := y + z ]
0.428 0.014 0.234 -0.285 [ x := y × z ]
0.337 0.055 0.199 0.093 [ x := y / z ]
0.384 0.012 -0.110 -0.151 [ k := 1 ]
-0.028 -1.020 -1.150 1.000 [ k := 1.0 ]
0.458 0.322 0.017 -0.280 [ k := l + m]
0.512 -0.033 0.365 -0.419 [ k := l × m]
0.814 0.024 0.001 0.001 [ k := l ÷ m ]
0.520 -0.016 0.180 -0.402 [ k := l ]
0.562 -0.676 0.705 -0.251 [ x := l ]
-0.211 -0.488 0.110 0.702 [ l := y ]
0.881 1.230 0.172 -0.658 [ x := y exp 2 ]
0.632 0.927 0.006 -1.040 [ x := y exp 3 ]
1.020 -0.397 -0.361 -1.940 [ x := y exp z ]
-0.034 -0.280 -0.660 0.387 [e1[1] := 1 ]
0.053 0.131 -0.441 0.310 [e2[1,1] := 1 ]
-0.120 0.012 -0.450 0.646 [e3[1,1,1] := 1]
0.111 -0.415 -0.432 0.483 [l := e1[1] ]
-4.870 -1.210 0.523 1.670 [ begin real a; end ]
-0.068 -0.813 0.075 0.276 [ begin array a[ 1:1 ]; end ]
-0.299 -1.040 -0.254 2.240 [ begin array a[ 1:500 ]; end ]
0.011 -0.825 -0.121 0.051 [ begin array a [ 1:1, 1:1 ]; end ]
-0.009 -0.816 -0.131 -0.064 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
0.575 1.050 0.386 -0.811 [ begin goto abcd; abcd: end ]
-1.310 -0.016 -0.726 0.983 [ begin switch ss:=pq; goto ss[1]; pq:end ]
-0.050 -0.150 -0.048 -0.736 [x := sin(y)]
0.062 -0.139 0.003 -0.740 [x := cos(y)]
-0.289 0.320 0.617 -1.640 [x := abs(y)]
-0.058 -0.074 0.118 -0.783 [x := exp(y)]
0.379 -0.148 -1.260 -0.840 [x := ln(y)]
-0.048 -0.009 0.326 -0.600 [x := sqrt(y)]
0.084 -0.266 0.044 -0.488 [x := arctan(y)]
0.053 0.047 0.171 -0.955 [x := sign(y)]
-0.524 -0.092 0.255 -0.165 [x := entier(y)]
-0.296 0.947 0.040 1.040 [p0]
-0.426 1.320 0.232 1.490 [p1( x )]
-0.489 1.510 0.247 1.740 [p2 ( x, y )]
-0.539 1.670 0.271 1.870 [p3( x, y, z )]

Machine factor, machine speeds, and standard error in machine factors Appendix D.5

Machine Factors Machine
1.000 ATLAS
3.650 KDF9
2.940 ICL4130 2µs
5.790 ICL4130 6µs
4.180 ICL503
5.560 RREAC
0.717 CDC 3600
1.620 ICL 1907
0.422 UNIVAC 1108
Speed Factors
1/Machine Factors
Machine
1.000 ATLAS
0.274 KDF9
0.340 ICL4130 2µs
0.173 ICL4130 6µs
0.239 ICL503
0.180 RREAC
1.400 CDC 3600
0.617 ICL 1907
2.370 UNIVAC 1108
Standard error
in Machine Factors
as a percentage
Machine
75.4 ATLAS
75.2 KDF9
82.2 ICL4130 2µs
91.9 ICL4130 6µs
132.0 ICL503
144.0 RREAC
96.1 CDC 3600
51.2 ICL 1907
152.0 UNIVAC 1108

Statement factors Appendix D.6

Statement Factors Instruction
6.3 [ x := 1.0 ]
9.4 [ x := 1 ]
6.3 [ x := y ]
11.2 [ x := y + z ]
15.1 [ x := y × z ]
23.8 [ x := y / z ]
5.5 [ k := 1 ]
15.6 [ k := 1.0 ]
9.1 [ k := l + m]
15.9 [ k := l × m]
32.7 [ k := l ÷ m ]
5.7 [ k := l ]
11.0 [ x := l ]
20.5 [ l := y ]
50.4 [ x := y exp 2 ]
71.8 [ x := y exp 3 ]
205.0 [ x := y exp z ]
20.3 [e1[1] := 1 ]
35.5 [e2[1,1] := 1 ]
55.2 [e3[1,1,1] := 1]
19.0 [l := e1[1] ]
23.4 [ begin real a; end ]
204.0 [ begin array a[ 1:1 ]; end ]
258.0 [ begin array a[ 1:500 ]; end ]
283.0 [ begin array a [ 1:1, 1:1 ]; end ]
357.0 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
5.9 [ begin goto abcd; abcd: end ]
139.0 [ begin switch ss:=pq; goto ss[1]; pq:end ]
212.0 [x := sin(y)]
220.0 [x := cos(y)]
23.3 [x := abs(y)]
212.0 [x := exp(y)]
210.0 [x := ln(y)]
159.0 [x := sqrt(y)]
289.0 [x := arctan(y)]
33.3 [x := sign(y)]
45.9 [x := entier(y)]
61.7 [p0]
91.5 [p1( x )]
112.0 [p2 ( x, y )]
133.0 [p3( x, y, z )]

Standard error in Statement factors Appendix D.7

Standard error
in Statement Factors
as a percentage
Instruction
25.7 [ x := 1.0 ]
79.8 [ x := 1 ]
29.5 [ x := y ]
24.0 [ x := y + z ]
23.7 [ x := y × z ]
22.2 [ x := y / z ]
32.4 [ k := 1 ]
109.0 [ k := 1.0 ]
38.1 [ k := l + m]
34.3 [ k := l × m]
82.8 [ k := l ÷ m ]
42.8 [ k := l ]
84.1 [ x := l ]
60.5 [ l := y ]
120.0 [ x := y exp 2 ]
74.4 [ x := y exp 3 ]
183.0 [ x := y exp z ]
53.2 [e1[1] := 1 ]
54.3 [e2[1,1] := 1 ]
65.0 [e3[1,1,1] := 1]
64.9 [l := e1[1] ]
639.0 [ begin real a; end ]
61.1 [ begin array a[ 1:1 ]; end ]
150.0 [ begin array a[ 1:500 ]; end ]
63.7 [ begin array a [ 1:1, 1:1 ]; end ]
68.6 [ begin array a [ 1:1, 1:1, 1:1 ]; end ]
233.0 [ begin goto abcd; abcd: end ]
114.0 [ begin switch ss:=pq; goto ss[1]; pq:end ]
42.0 [x := sin(y)]
37.5 [x := cos(y)]
135.0 [x := abs(y)]
37.8 [x := exp(y)]
84.6 [x := ln(y)]
38.0 [x := sqrt(y)]
27.1 [x := arctan(y)]
72.1 [x := sign(y)]
58.8 [x := entier(y)]
182.0 [p0]
200.0 [p1( x )]
214.0 [p2 ( x, y )]
221.0 [p3( x, y, z )]
⇑ Top of page
© Chilton Computing and UKRI Science and Technology Facilities Council webmaster@chilton-computing.org.uk
Our thanks to UKRI Science and Technology Facilities Council for hosting this site