Jim Battle wrote:
Chuck Guzis wrote:
...
Well, the Burroughs B5000 was purportedly an
Algol machine; there have
been CPU designs to eat UCSD Pascal bytecodes and Java bytecodes and
there have been various LISP machines. But none, AFAIK, to actually
lexically parse program text input in hardware. I suppose 1401
Autocoder might be in that league, if you consider Autocoder to be a
"language".
I remember reading a computer architecture book back in the early/mid
80s, I think it was by Stone. The subject was "advanced"
architectures. One section described on attempt to build a timesharing
system for running a BASIC-like subset, and everything was hardwired --
parsing was via gate-level state machines, not microcode. The intended
audience was college-level computer classes. As I recall, they gave up
after getting a simplified version going.
Dang, I have the book. I bought used recently it because of its i432 section, but
didn't
recognize it was the same book I had read so many years ago.
Chapter 8 of "Advances in Computer Architecture" describes the SYMBOL computer,
designed
and built buy Fairchild Camera, and operated at Iowa State. Only one was built. The
design was started in the mid 60s. Here is an excerpt:
The language is described as "a high-level language architecture. Its instruction
set is
a one-for-one reverse Polish representation of the system's programming language, the
SYMBOL programming language (SPL), and the compilation process is performed by the machine
rather than the software."
"An initially startling aspect of SYMBOL is the first goal; the phrase 'directly
...
implemented in hardware' means that SYMBOL contains virtually no software (it does
contain
some software, but the software performs only a few auxiliary functions, and the system
can be operated with no software), and it contains no microcode; all the system's
functions are implemented as sequential logic networks. For instance, the
'compiler' is a
hardware sequential logic network, the memory-allocation and page-replacement algorithms
are sequential logic networks, the functions that interpret end-user terminal commands are
sequential logic networks, and so on."
The machine was built as a collection of specialized processors. One did parsing, one did
numeric formatting, etc. When the user ran a program, it was handed off between the
specialized task processors, and the user was unaware of what was going on under the
hood.
The compilation was so fast that programs were all stored in source code form. The
machine could process 75,000 lines per minute. They had a design that could handle 300K
lines/minute, but it was never built. When a single user was on the system and submitted
a trivial program, the time from hitting carriage return after typing "RUN"
until the
program was done was 315 microseconds.
Other factoids: 64b core memory, 4 uS cycle time. SPL had two data types: scalars and
lists. Numeric scalars could be up to 99 mantissa digits, with one or two exponent
digits. Decimal math. Lists were limited in length only by the amount of of memory
available.