🚀 go-pugleaf

:However, I can see how no mmu/memory protection/etc. can appeal to
:hackers. "Do what I say, and I'll be happy." Matt and others have
:produced some very nice software because of it. Also, passing messages
:and data structures by pointer is FAST. Also, queues are a lot shorter
:because you are only passing 32 bit quantities.
:
:I just wonder what's going to happen on the 2500 and 3000...
:
:Edwin (Deepthot) Hoogerbeets
:uunet!utai!utcsri!hcr!edwin

	Yes, an interesting theoretical problem.  But actually, not so bad.
Currently, allowing a (single) application which runs (multiple) processes
to have the processes run on different machines is completely up to the
designer of the software.

	And it will be like this for the rest of eternity, because no matter
how you look at it, passing pointers around will ALWAYS be faster than passing
buffers.... even if the buffer passing is implemented by mapping the same page
to N processes.  Usually, even if the OS *does* allow the processes to run
on different machines, the overhead involved in such a scheme where the
processes don't KNOW they are on different machines can be tremendous... so
much so that it isn't worth it for the most part.

	So, at least for the next 50 years, there will be a distinction.

	Now, for machines with VM there are essentially two memory models
used today that I know about.  (1) Global address space  (2) Independant
address space.  In (1) All processes on the machine share the same address
space (4 gig usually), and thus all addresses are unique even between 
processes.  In (2) All processes have their own address space with (possibly)
limited sharing ... all addresses are NOT unique between processes.  NOTE
THAT BOTH METHODS USE THE MMU HEAVILY TO IMPLEMENT PROTECTION AND OTHER STUFF,
SUCH AS PAGING, SWAPPING, ZERO-ON-REFERENCE, ETC...

	For the amiga, method (1) Is the only possibility due to the dependance
on pointer passing (BTW, I consider this *GOOD* because it makes the entire OS
streamlined).  I happen to like (1) for a couple of reasons. 

	-Shared memory, when allowed, is inherent rather than a special case.

	-Entire data structures, especially structures that contain pointers,
	 may be shared.

	-Pointer passing and sharing can be accomplished without having to
	 translate addresses or 'trick' the process with MMU manipulations.

	-Shared libraries become inherent and extremely easy to implement

	-You don't need to clear the A/D cache when you switch between
	 processes!

NOTE:  Note, I use the word 'machine'... physically independant machines which
do not share memory (i.e. all the processors in a parallel processing machine
are considered as a single entity).

						-Matt