Language-specific CPUs

[Jim Battle]

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.