I've assembled some notes from old manuals and other sources
on the formats used for on-disk file systems through the
Additional notes, comments on style, and whatnot are welcome.
(It may be sensible to send anything in the last two categories
directly to me, rather than to the whole list.)
Steve Bourne tried hard to interest us in A68, and I personally liked some
features of it (especially the automatic type morphing of arguments into
the expected types). But the documentation was a huge barrier--all the
familiar ideas were given completely new (and unintuitive) names, making
it very difficult to get into.
I may be biased in my view, but I think one fatal mistake that A68 made
was that it had no scheme for porting the language to the plethora of
computers and systems around at that time. (The Bliss language from CMU
had a similar problem, requiring a bigger computer to compile for the
PDP-11). Pascal had P-code, and gave C a real run, especially as a
teaching language. C had PCC.
Nowadays, newer languages like Python just piggyback on C or C++...
> AFAIK the later ESS switches include a 3B machine but it only handles
> some administrative functions, with most of the the actual call
> processing being performed in dedicated hardware.
That is correct. The 3B2 was an administrative appendage.
Though Unix itself didn't get into switches, Unix people did
have a significant influence on the OS architecture for
ESS 5. Bob Morris, having observed some of the tribulations of
that project, suggested that CS Research build a demonstration
switch. Lee McMahon, Ken Thompson, and Joe Condon spearheaded
the effort and enlisted Gerard Holzmann's help in verification
(ironically, the only application of Gerhard's methods to
software made in his own department). They called the system,
which was very different from Unix, TPC--The Phone Company. It
actually controlled many of our phones for some years. The
cleanliness of McMahon's architecture, which ran on a PDP-11,
caught the attention of Indian Hill and spurred a major
reworking of the ESS design.
All, I was invited to give a talk at a symposium in Paris
on the early years of Unix. Slides and recording at:
Feel free to point out the inaccuracies :-)
For example, I thought Unix was used at some point
as the OS for some of the ESS switches in AT&T, but
now I think I was mistaken.
That's a temp URL, it will move somewhere else
Ori Idan <ori(a)helicontech.co.il> asks today:
>> Pascal compiler written in Pascal? how can I compile the compiler it I
>> don't yet have a pascal compiler? :-)
You compile the code by hand into assembly language for the CDC
6400/6600 machines, and bootstrap that way: see
On Code Generation in a PASCAL Compiler
The Design of a PASCAL Compiler
It has been a long time since I read those articles in the journal
Software --- Practice and Experience, but my recollection is that they
wrote the compiler in a minimal subset of Pascal needed to do the job,
just to ease the hand-translation process.
- Nelson H. F. Beebe Tel: +1 801 581 5254 -
- University of Utah FAX: +1 801 581 4148 -
- Department of Mathematics, 110 LCB Internet e-mail: beebe(a)math.utah.edu -
- 155 S 1400 E RM 233 beebe(a)acm.org beebe(a)computer.org -
- Salt Lake City, UT 84112-0090, USA URL: http://www.math.utah.edu/~beebe/ -
On 2016-06-30 21:22, Clem Cole <clemc(a)ccc.com> wrote:
> but when Moto came out with a memory management chip it had some
>> > severe flaws that made paging and fault recovery impossible, while the
>> > equivalent features available on the 8086 line were tolerable.
> Different issues...
> When the 68000 came out there was a base/limit register chip available,
> who's number I forget (Moto offered to Apple for no additional cost if they
> would use it in the Mac but sadly they did not). This chip was similar
> to the 11/70 MMU, as that's what Les and Nick were used to using (they used
> a 11/70 running Unix V6 has the development box and had been before the
> what would become the 68000 -- another set of great stories from Les, Nick
> and Tom Gunter).
Clem, I think pretty much all you are writing is correct, except that I
don't get your reference to the PDP-11 MMU.
The MMU of the PDP-11 is not some base/limit register thing. It's a
paged memory, with a flat address space. Admittedly, you only have 8
pages, but I think it's just plain incorrect to call it something else.
(Even though noone I know of ever wrote a demand-paged memory system for
a PDP-11, there is no technical reason preventing you from doing it.
Just that with 8 pages, and load more physical memory than virtual, it
just didn't give much of any benifits.)
Johnny Billquist || "I'm on a bus
|| on a psychedelic trip
email: bqt(a)softjar.se || Reading murder books
pdp is alive! || tryin' to stay hip" - B. Idol
> Ronald Natalie <ron(a)ronnatalie.com>
>> On the other hand, there was
>> no excuse for a Pascal compiler to be either large, buggy, or slow, even before Turbo Pascal.
> I remember the Pascal computer on my Apple II used to have to use some of the video memory while it was running.
UCSD Pascal, the Apple Pascal base, would grab the video memory as space to write the heap when compiling. When the Terak system was in use at UCSD the video memory would display on the screen so you could watch the heap grow down the screen while the stack crawled up when compiling. If it ever hit in the middle, you had a crash. Exciting times.
Terak systems were 11/03 based, IIRC. (http://www.threedee.com/jcm/terak/)
> On Jun 30, 2016, at 10:27 AM, schily(a)schily.net (Joerg Schilling)
> Marc Rochkind <rochkind(a)basepath.com> wrote:
>> Bill Cheswick: "What a different world it would be if IBM had selected the
>> M68000 and UCSD Pascal. Both seemed
>> to me to better better choices at the time."
>> Not for those of us trying to write serious software. The IBM PC came out
>> in August, 1981, and I left Bell Labs to write software for it full time
>> about 5 months later. At the time, it seemed to me to represent the future,
>> and that turned out to be a correct guess.
> I worked on a "Microengine" in 1979.
> The Microengine was a micro PDP-11 with a modified micro code ROM that directly
> supported to execute p-code.
> The machine was running a UCSD pascal based OS and was really fast and powerful.
Very likely one of the Western Digital products. They were the first to take UCSD Pascal and burned the p-code interpreter into the ROM. Made for a blindingly fast system. I worked with the folks who did the port and make it all play together. Fun days.
I worked on the OS and various utility programs those days. Nothing to do with the interpreters.
When the 68000 came out SofTech did a port of the system to it. Worked very well; you could take code compiled on the 6502 system write it to a floppy, take the floppy to the 68k system and just execute the binary. It worked amazingly well.
Steve almost right....mixing a few memories...see below..
On Thu, Jun 30, 2016 at 1:17 PM, <scj(a)yaccman.com> wrote:
> My memory was that the 68000 gave the 8086 a pretty good run for its
Indeed - most of the UNIX workstations folks picked it because of the
but when Moto came out with a memory management chip it had some
> severe flaws that made paging and fault recovery impossible, while the
> equivalent features available on the 8086 line were tolerable.
When the 68000 came out there was a base/limit register chip available,
who's number I forget (Moto offered to Apple for no additional cost if they
would use it in the Mac but sadly they did not). This chip was similar
to the 11/70 MMU, as that's what Les and Nick were used to using (they used
a 11/70 running Unix V6 has the development box and had been before the
what would become the 68000 -- another set of great stories from Les, Nick
and Tom Gunter).
The problem with running a 68000 with VM was not the MMU, it was the
microcode. Nick did not store all of the needed information needed by the
microcode to recover from a faulted instruction, so if a instruction could
not complete, it could not be restarted without data loss.
> There were
> some bizarre attempts to page with the 68000 (I remember one product that
> had two 68000 chips, one of which was solely to sit on the shoulder of the
> other and remember enough information to respond to faults!).
This was referred to as Forest Baskett mode -- he did a early paper that
described it. I just did a quick look but did not see a copy in my shelf
of Moto stuff. At least two commercial systems were built this way -
Apollo and Masscomp.
The two processors are called the "executor" and "fixer." The trick is
that when the MMU detects an fault will occur, the executor is sent "wait
state" cycles telling it that the required memory location is just taking
longer to read or write. The fixer is then given the faulting address,
which handles the fault. When the page is finally filled, on the
Masscomp system the cache is then loaded and the executor is allowed to
complete the memory cycle.
When Nick fixed the microcode for the processor, the updated chip was
rebranded as the 68010. In the case of the Masscomp MC-500 CPU board, we
popped the new chip in as the executor and changed the PAL's so the fault
was allowed to occur (creating the MPU board). This allowed the executor
to go do other work while the fixer was dealing with the fault. We
picked up a small amount of performance, but in fact it was not much. I
still have a system on my home network BTW (although I have not turned it
on in a while -- it was working last time I tried it).
Note the 68010 still needed an external MMU. Apollo and Masscomp built
their own, although fairly soon after they did the '10 Moto created a chip
to replace the base/limit register scheme with one that handled 2-level
In Masscomp's case when we did the 5000 series which was based on the
68020, use their MMU for their low end (300 series) and our custom MMU on
the larger systems (700 series).
> By the time
> Moto fixed it, the 8086 had taken the field...
Well sort of. The 68K definitely won the UNIX wars, at least until the
386 and linear addressing would show up in the Intel line. There were
some alternatives like the Z8000, NS32032, and AT&T did the 32100 which was
used in the 3B2/3B5 et al. but 68K was the lion share.