The R1000 is a micro-coded computer built from approx 5k TTL functions, with an instruction set consisting of Ada Primitives like "Define a type for a variant structure with 3 variants, you'll get the details later".
It processes 64bit data and 64 bit type information about that data in parallel, in hardware.
It is also object oriented in hardware, there is no linear address space or VM-tree,
Three left in the world, plus one mostly empty chassis.
My Covid19 project was writing a software emulation of it, starting from 400 pages of schematics, because the instruction set is not documented.
And yes, I'm way behind on documenting it, because I also have a life :-)
> instruction set consisting of Ada Primitives like "Define a type for a variant structure with 3 variants, you'll get the details later".
Wow, it's hard for me to imagine a CPU with such high level instructions. Were these per-process, like virtual memory on a modern processor? Or was there only expected to be one executable running on the machine at a time?
> My Covid19 project was writing a software emulation of it,
The microcoding means you have fairly standard CPU hardware - an ALU, some registers, memory ports, and so on - and the microcode sequences it to emulate the ISA.
So it's not that the ADA primitives were baked directly into TTL.
It's somewhat related to the Itanium model where the compiler generates a Very Long Instruction Word.
Microcode is a standard way of implementing CISC, but this machine took it further than usual.
"fairly standard" is a bit of an understatement in this particular case.
The machine actually has both an ALU as we know it, called the "VAL" board, but it also has a second unit, which runs in parallel on the "TYP" board, which does checks and operations on the data types of the data on the VAL board.
That means that the compiler can just emit a "ADD" instruction, and leave it to the microcode to figure out if it is adding two floating point numbers, two integers or a floating-point plus an integer and if the numeric type has a range, the result will be checked to fit inside that range.
So the comparison to the Itanic is not helpful. Itanic was a pretty standard CPU which forced a lot of constraints and complexity into the compiler.
The R1000 does the opposite: The compiler gets to emit code which operates on the types as the Ada language defines and knows them, and the hardware+microcode translates that into action.
Grady Booch donated some internal documents to us, and they contain a couple of references to "Incredibly Complex Instruction Set Computer" and they're not half wrong about that.
Notably it needs KiCad to run and takes ~140 hours to boot.
Seems like the reason for KiCad and the slow operation is that the emulation occurs at a really low level, and they've written a program to digitize all of the computer's schematics and convert them into netlists (which is then converted into systemC components for the emulator): https://github.com/Datamuseum-DK/R1000.HwDoc
I knew Rational did Ada (and later acquired awesome products from Atria and Pure), but didn't know they had their own workstation hardware in the '80s.
And it had a nice portrait orientation monitor like some early Xerox workstations (the PARC ones like Alto, and the fancy word processors like 850 and 860 IPS).
Later, starting as a teen, I was working for Cadre, a competitor of Rational on workstation software engineering tools. The company started with Apollo Domain workstations (not rolled their own), and, by the time I joined, had added Sun, HP, IBM, DEC, and MS Windows.
The Cadre site I started at (a spinoff of Tektronix, which did high-end hardware in-circuit emulators with CASE workstation frontends) was practically across the street in the OGI science park from Verdix, which, a bit like Rational, did Ada development tools and related neat systems work like (IIRC) secure compartmentalized workstation technology.
It was an exciting time in computers, and in hindsight, as a kid I saw engineers picking up and applying broader mixes of skills than we usually do in today's fairly rigid skills silos.
This is not only where ClearCase comes from, this is where "The Booch Method", UML, and the software for the Space Shuttle, The International Space Station, EuroControl (= pan-european air traffic control) and the F-22 fighter jet comes from. (Plus who knows how much other militarg hardware...)
It is a truly astonishing software development environment which with a a single key-press can answer questions like "what other code is affected if I change the default value of a parameter to this function". (Think about that one for a second!)
ClearCase is the worst VCS software that I ever used in my life. Maybe in the beginning of 90s it was better than existing alternatives, but I was using it well in 2000s, and it was horrible experience compared to already existing Git, Mercurial and even Subversion.
And if you add the cost (around $5000 per workplace), it becomes even less understandable.
It also required a designated CC admin or several admins.
> Rational Machines is an enterprise founded by Paul Levy and Mike Devlin in 1981 to provide tools to expand the use of modern software engineering practices, particularly explicit modular architecture and iterative development. It changed its name in 1994 to Rational Software, and was sold for US$2.1 billion (equivalent to current US$3.59 billion[1]) to IBM on February 21,[2] 2003.
It doesn’t answer your question but I came across this yesterday doing some research on the R1000 (which is why I came across the OP). You might find it interesting:
Ada Compiler Validation Summary Report:
Rational Environment
The R1000 is a micro-coded computer built from approx 5k TTL functions, with an instruction set consisting of Ada Primitives like "Define a type for a variant structure with 3 variants, you'll get the details later".
It processes 64bit data and 64 bit type information about that data in parallel, in hardware.
It is also object oriented in hardware, there is no linear address space or VM-tree,
Three left in the world, plus one mostly empty chassis.
My Covid19 project was writing a software emulation of it, starting from 400 pages of schematics, because the instruction set is not documented.
And yes, I'm way behind on documenting it, because I also have a life :-)
> instruction set consisting of Ada Primitives like "Define a type for a variant structure with 3 variants, you'll get the details later".
Wow, it's hard for me to imagine a CPU with such high level instructions. Were these per-process, like virtual memory on a modern processor? Or was there only expected to be one executable running on the machine at a time?
> My Covid19 project was writing a software emulation of it,
Where did you get to? Do you have a link?
The microcoding means you have fairly standard CPU hardware - an ALU, some registers, memory ports, and so on - and the microcode sequences it to emulate the ISA.
So it's not that the ADA primitives were baked directly into TTL.
It's somewhat related to the Itanium model where the compiler generates a Very Long Instruction Word.
Microcode is a standard way of implementing CISC, but this machine took it further than usual.
"fairly standard" is a bit of an understatement in this particular case.
The machine actually has both an ALU as we know it, called the "VAL" board, but it also has a second unit, which runs in parallel on the "TYP" board, which does checks and operations on the data types of the data on the VAL board.
That means that the compiler can just emit a "ADD" instruction, and leave it to the microcode to figure out if it is adding two floating point numbers, two integers or a floating-point plus an integer and if the numeric type has a range, the result will be checked to fit inside that range.
So the comparison to the Itanic is not helpful. Itanic was a pretty standard CPU which forced a lot of constraints and complexity into the compiler.
The R1000 does the opposite: The compiler gets to emit code which operates on the types as the Ada language defines and knows them, and the hardware+microcode translates that into action.
Grady Booch donated some internal documents to us, and they contain a couple of references to "Incredibly Complex Instruction Set Computer" and they're not half wrong about that.
So basically an AdaMachine?
They have an emulator here: https://github.com/Datamuseum-DK/R1000.Emulator2
Notably it needs KiCad to run and takes ~140 hours to boot.
Seems like the reason for KiCad and the slow operation is that the emulation occurs at a really low level, and they've written a program to digitize all of the computer's schematics and convert them into netlists (which is then converted into systemC components for the emulator): https://github.com/Datamuseum-DK/R1000.HwDoc
a video explaining the process?: https://www.youtube.com/watch?v=oMRTr0bPuOA
Apologies for outdated information there...
On an Apple M2 CPU it runs around the same speed as the real hardware now.
(The first version based on the unaltered hardware schematics ran 4000 times slower than real hardware, it's been quite a journey :-)
I knew Rational did Ada (and later acquired awesome products from Atria and Pure), but didn't know they had their own workstation hardware in the '80s.
And it had a nice portrait orientation monitor like some early Xerox workstations (the PARC ones like Alto, and the fancy word processors like 850 and 860 IPS).
Later, starting as a teen, I was working for Cadre, a competitor of Rational on workstation software engineering tools. The company started with Apollo Domain workstations (not rolled their own), and, by the time I joined, had added Sun, HP, IBM, DEC, and MS Windows.
The Cadre site I started at (a spinoff of Tektronix, which did high-end hardware in-circuit emulators with CASE workstation frontends) was practically across the street in the OGI science park from Verdix, which, a bit like Rational, did Ada development tools and related neat systems work like (IIRC) secure compartmentalized workstation technology.
It was an exciting time in computers, and in hindsight, as a kid I saw engineers picking up and applying broader mixes of skills than we usually do in today's fairly rigid skills silos.
https://en.wikipedia.org/wiki/Rational_R1000
Appears to be an ADA-based workstation?
Is this the same Rational as Rational ClearCase etc as acquired by IBM back in the day? Crazy
This is not only where ClearCase comes from, this is where "The Booch Method", UML, and the software for the Space Shuttle, The International Space Station, EuroControl (= pan-european air traffic control) and the F-22 fighter jet comes from. (Plus who knows how much other militarg hardware...)
It is a truly astonishing software development environment which with a a single key-press can answer questions like "what other code is affected if I change the default value of a parameter to this function". (Think about that one for a second!)
ClearCase is the worst VCS software that I ever used in my life. Maybe in the beginning of 90s it was better than existing alternatives, but I was using it well in 2000s, and it was horrible experience compared to already existing Git, Mercurial and even Subversion.
And if you add the cost (around $5000 per workplace), it becomes even less understandable.
It also required a designated CC admin or several admins.
I'm personally no fan of ClearCase myself, it's far to rigid for my taste.
But if I were the pilot in an F-22 or the Space Shuttle, I probably would want it to be even more rigid :-)
It's important to keep in mind the context of this machine and the software it was used to develop.
> Is this the same Rational as Rational ClearCase etc as acquired by IBM back in the day? Crazy
Looks like it:
https://en.wikipedia.org/wiki/Rational_Software
> Rational Machines is an enterprise founded by Paul Levy and Mike Devlin in 1981 to provide tools to expand the use of modern software engineering practices, particularly explicit modular architecture and iterative development. It changed its name in 1994 to Rational Software, and was sold for US$2.1 billion (equivalent to current US$3.59 billion[1]) to IBM on February 21,[2] 2003.
This link doesn't really tell me anything.
I’d be curious if this was similar to the Western Digital Pascal chips: https://en.wikipedia.org/wiki/Pascal_MicroEngine
Supposedly the first verification of the first Ada compiler was done on a system made with the Pascal MicroEngine.
It doesn’t answer your question but I came across this yesterday doing some research on the R1000 (which is why I came across the OP). You might find it interesting:
Ada Compiler Validation Summary Report: Rational Environment
https://apps.dtic.mil/sti/tr/pdf/ADA157830.pdf