GIER Algol(ID:3487/gie001)
Naur's seminal ALGOL 60
Implementation of Algol 60 by Peter Naur.
Transistorized electronic computer that was a joint development of the Danish Regnecentralen and the Geodætisk Institut (Danish Geodetic Institute) GIER for Geodætisk Institut Elektronisk Regnemaskine.
It was a design classic amongst early computers, having an exterior like a teak B&O hi-fi (refer Simonyi interview). The interpreter itself was similarily elegant.
Featured "pseudo evaluation" - computing by approximations - and read the source code backwards to make forward referencing efficient!!
Related languages
| RegneCentralen ALGOL | => | GIER Algol | One of series | |
| slip | => | GIER Algol | Written using | |
| GIER Algol | => | GIER Algol II | Evolution of |
References:
in BIT 3 1963 view details
in Goodman, Richard (ed) "Annual Review in Automatic Programming" (4) 1964 Pergamon Press, Oxford view details
in Goodman, Richard (ed) "Annual Review in Automatic Programming" (4) 1964 Pergamon Press, Oxford view details
Two other procedure names described allow the placing of the appropriate code in the array of variables, and the communication between the machine code and the ALGOL variables in the text.
The article is clear but brief. For a full description the reader is referred to the Manual of GIER ALGOL III, published by the Regnecentralen, 1964.
in ACM Computing Reviews 6(03) May-June 1965 view details
The translation approach is essentially classical. The syntactic analysis (which is quite complete) is inherent in the program, rather than in separate tables; although it is not entirely clear from the description, the same seems to be true of the semantic and pragmatic parts of the translator (that is, the generation of the machine instructions). Such an approach is admirably suited to the author's goals (the production of a translator for as much of ALGO1 as possible, with complete error detection, on a small machine, and within a realistic period of time).
It should be noted that this is the same article that was published in BIT, 3, 2 and 3. The wider dissemination achieved in this book is desirable, but there is no indication of the earlier publication.
in ACM Computing Reviews 6(04) July-August 1965 view details
in ACM Computing Reviews 6(04) July-August 1965 view details
in ACM Computing Reviews 6(04) July-August 1965 view details
Introduction
In programming for a machine with an inhomogeneous store, such as a core store and a backing drum, the handling of the transfers of program and data between the two media i s usually a major problem. In designing an Algol compiler for such a machine this problem is added to all the other problems of the compiler. It soon becomes clear that the problems of program and data are essentially different, for two reasons. On the one hand, the programmer knows far more about the most suitable allocation of data than of program, because he knows the volume of the data, while his knowledge of the size of the translated program is usually very crude, On the other hand, an automatic handling of program transfers is much simpler than the corresponding handling of data because the program is unaltered during execution, at least in machines having reasonable addressing facilities.
In planning the Algol compiler for the GIER, a machine having 1024 words of core store and 12,800 words on drum, it was therefore decided to include an automatic segmentation of the program, while handling of data on the drum is left to the programmer. This decision was based on rather crude estimates as to the structure of actual programs, but has proved very successful. in practice. In fact, the programming for the GIER machines now running is done almost exclusively in Algol. The time is therefore ripe for another discussion of the problem, using the experience of the GIER Algol system as the starting point.
The present paper contains first a brief description of the logic of the segmentation scheme. This is followed by a report and a discussion of some experiments on the performance of the scheme in a few representative programs.
in Information Processing Machines: Proceedings of the Symposium held in Prague on September 7th-9th, 1964. Czechislovak Academy of Sciences (Prague) and Iliffe Books, Ltd. (London) 1965 view details
in [ACM] CACM 8(11) Nov 1965 view details
External link: Online copy
in ACM Computing Reviews 7(04) July-August 1966 view details
The basic features of the segmentation scheme are as follows: (1) the compiler formally divided the object program into 40-word relocatable segments (one segment per one track of the drum); (2) all cross references between segments are treated by a fixed administration permanently stored in the core memory at run time; (3) the administration keeps a list of numbers of the segments currently present in the core store, to avoid unnecessary transfers of segments from the drum; (4) the working space for segmeIIts in the core memory is that which is left over when all the variables currently declared have been allocated; and (a) when there is no space for a new segment required, then an oldest segment is cancelled.
The experiment consisted in varying the working space for segments of two programs (matrix inversion and Romberg double integration) from 2 to 14 and 16 segments, respectively, and in measuring the execution time, which was distributed into three items: drum track transfers, segment transitions, and pure program execution. The main resulting figures are: inversion: program execution -- 6.9 sec.; segment transitions increase very slowly from 0.a sec. to 0.7 sec., track transfers decrease by steps from 2.a sec. through 1 sec. to 0.2 sec. -- this time begins with 6 segments of the working space; integration: execution -- 2.5 sec., transitions increase from 0.3 sec. to 1.3 sec., and transfers decrease very rapidly from 19 sec. through 3 sec. (6 segments) to 0.5 sec. -- beginning with 10 segments of the working space. The 6 and, respectively, 10 segments are the critical spaces which are necessary to store all segments of inner loops of programs. Unfortunately, there are no figures for the complete sizes of both programs, in comparison with the sizes of inner loops. The author stresses that transition times are very sensitive to whether or not there is a segment transition in the innermost loop of the program. Some ways to reduce this time are discussed, with a special instruction in the hardware being preferable.
The author has discovered that the program storage cleanup, which has been implemented in the scheme (cancelling in every 512 segment transitions the segments which have not been used during the last 256 transitions), does not significantly reduce the segment transition time.
Though the experiment above is not on a very large scale, the results are quite promising concerning the general effectiveness of the discussed segmentation scheme.
in ACM Computing Reviews 7(04) July-August 1966 view details
in [ACM] CACM 9(03) March 1966 includes proceedings of the ACM Programming Languages and Pragmatics Conference, San Dimas, California, August 1965 view details
in [ACM] CACM 9(03) March 1966 includes proceedings of the ACM Programming Languages and Pragmatics Conference, San Dimas, California, August 1965 view details
The SNOBOL compiler I wrote at Berkeley, for example, was just a variation on the same theme. I think the Gier Algol program is still in my mind and influences my programming today. I always ask myself, 'If this were part of the Algol compiler, how would they do it?' It's a very, very clever program.
One notion that sticks in my mind is how they scanned the source text backwards. It turns out that in some cases, if you do things backwards, problems that previously appeared complex suddenly become very simple. For instance, resolving forward references can be difficult. If you scan backwards, they become backward references, which are easy to resolve. Just by looking at a program in a new way, what formerly might have been rather difficult to solve becomes easy to solve. The Algol compiler was absolutely full of wonderful tricks."
in [ACM] CACM 9(03) March 1966 includes proceedings of the ACM Programming Languages and Pragmatics Conference, San Dimas, California, August 1965 view details
in [ACM] CACM 9(03) March 1966 includes proceedings of the ACM Programming Languages and Pragmatics Conference, San Dimas, California, August 1965 view details
Resources
- GIER ALGOL Tutorial
This is the tutorial for both the GIER emulator and the GIER ALGOL that it has. Load tapes and watch them run.external link - Photo of a GEIR
- Memories of using GIER Algol
external link