Here's an interesting discussion thread in comp.sys.apollo from 2003: https://groups.google.com/g/comp.sys.apollo/c/55dqpf11hEw/m/yvrhy2AlZVwJ https://groups.g

Here's an interesting discussion thread in comp.sys.apollo from 2003: https://groups.google.com/g/comp.sys.apollo/c/55dqpf11hEw/m/yvrhy2AlZVwJ https://groups.google.com/g/comp.sys.apollo/c/55dqpf11hEw/m/... The setup was more complex than I described, as the second 68000 did not simply wait for a page fault to happen but was executing regular code (unclear if application only or also OS kernel, but the code was not allowed to raise page faults, user processes usually ran on one CPU, see the last quote below) and only handled the fault on the other CPU when interrupted by the MMU. Unfortunately, the only versions of Aegis/DomainOS available online seem to be 10.x (on bitsavers), but support for the "sau1" 68000-based systems (DN100/DN400/DN416) ended with version 9.x, so we can't have a look at the code implementing this feature. Interesting quotes from the thread: "The two processors were called "A" and "B" and processes could be marked runnable on A or on B or both. It was almost a multiprocessor, except that you couldn't run anything that might take a page fault on both at the same time." (by Jim Rees, who runs the Apollo archive at https://jim.rees.org/apollo-archive/ https://jim.rees.org/apollo-archive/) The answer to the following question was posted by Dave Tweed, a former Apollo engineer who worked on the MMU design for later Apollo workstations (see his resume at http://www.dtweed.com/resume2.html http://www.dtweed.com/resume2.html): "> Hmm. So how did CPU B know that this was needed? It sounds like they > weren't running the same code, after all. No, of course not. The MMU was external to both CPUs, and when one CPU encountered a page fault, the MMU would interrupt the other CPU to handle the exception. The CPUs shared the main memory, so in that sense they were running the same code -- e.g., there was only one copy of the exception handler that either CPU could run. But they were not lock-stepped the way the OP described. I can't even imagine how you'd accomplish that in general." However, from another thread, also by Jim Rees (https://groups.google.com/g/comp.sys.apollo/c/GzEtBHVHEvA/m/7bBmrCurVSoJ https://groups.google.com/g/comp.sys.apollo/c/GzEtBHVHEvA/m/...): "Back in the good old days, the 68000 was the only Motorola processor available. It did not have restartable instructions, so you couldn't do VM with them. Early Suns didn't have VM, they squeezed everything into real memory, like a pdp-11. Early Apollos had an ingenious VM system. There were two processors, the 'A' and the 'B'. One of them would run until it took a page fault, then it would go into a memory wait while the other one brought the page in. It's not really parallel in the usual sense of the word, but there were certain things that could run on either processor, and in fact you could have both of them running at the same time. Normal user processes only ran on one." What a fascinating rabbit hole...