[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[ih] NCP and TCP implementations

On 16 Mar 2020 at 12:31, Noel Chiappa via Internet-history wrote:

> Anyway, on to what I wanted to comment on:
>     > From: Geoff Goodfellow
>     > for some reason when the C/70's came along, TIP's were renamed to
> TAC's
> IIRC, the C/70's were timesharing machines (running Unix, IITC); the
> C/
> machines which were packet switches (IMPs), terminal concentators (TACs)
> etc
> were C/30's. I note from the host tables that the TIP's all seem to have
> been
> H316's, and all TAC's were C/30's.

You're correct.   The TIP was a 316 IMP with the terminal handling code in the 
upper 16K of memory.   The C/30 was an implementation of the 316 on the MBB 
[Microprogrammable Building Block] that BBN had developed.   I have no idea 
about why it was "/30".  The MBB was "microprogrammable" and so we built the 
C/70 -- it was called the "C machine" and the idea what that "C" was its assembly 
language.  I have no idea how that project got started but three of us were 
working on it: Al Nemeth was hacking the Unix kernel,  Carl Howe did the 
microcode and I did a crosscompiler from TENEX to the MBB.

I think it was tagged the "C/70" because it was intended to run Unix as well as an 
11/70 [in practice it worked out to be MUCH faster].  the MBB had 20 bit words 
and Al and Carl were designing a hand-tuned, irregular "instruction set".  Such 
things as a built-in indirect index: he figured out the optimal size of the offset 
field so that referencing part of a 'struct' through a pointer could be done in a 
single instruction not using a register.

There was *NO* regularity to the "instruction set" -- each instruction carved up 
the 20 available bits as seemed most efficient.  We added new/strange 
instructions as we saw fit [e.g.,: Al noticed that almost all subroutine calls in the 
kernel were either zero or one argument calls, and so we had two call 
instructions: the normal one [push push push <call>] and one that *always* 
pushed ONE arg and called in a single instruction.   I had the fun task of putting 
together a C cross compiler running on a 36 bit machine for a 20-bit-word 
machine to handle all that irregularity.

We eventually got the kernel working [with the underlying "instruction set" 
constantly evolving as Al looked at the code the compiler was producing and 
figuring ways to tweak things to make it faster.  Carl and I mostly kept up.  The 
big day [for me, at least] was when I ported the C compiler I"d been working on 
to run natively on the MBB [which involved taking out the 36-bit-ness and 
replacing it with 20-bit-ness].  The Unix kernel compiled on the MBB  and was 
bit-for-bit the same as the image produced on TENEX and we cut the strings to 
TENEX and it was now running solo.   That was pretty much when i left the 
project:  I have no idea [at least no memory] what happened after that [some of 
you might have guessed that I was a bit of a vagabond jack-of-all-trades at BBN: I 
worked on one project or another, got it working and "released" and then I went 
onto the next thing].  I don't remember what *we* called it, but shortly after we 
got it all working it went over to BBNCC and was marketed as the "C/70"

I don't remember its ever running the IMP code.  Alex/Dave: was any of the 
development of the C70 written up?  I wasn't much on writing reports :o)


            Bernie Cosell
       bernie at fantasyfarm.com
-- Too many people; too few sheep --