Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!utgpu!water!watnot!watmath!clyde!cbatt!ucbvax!CORY.BERKELEY.EDU!dillon
From: dillon@CORY.BERKELEY.EDU.UUCP
Newsgroups: comp.sys.amiga
Subject: Re: Networking Amigas + MMU's
Message-ID: <8704080809.AA04117@cory.Berkeley.EDU>
Date: Wed, 8-Apr-87 03:09:29 EST
Article-I.D.: cory.8704080809.AA04117
Posted: Wed Apr  8 03:09:29 1987
Date-Received: Sat, 11-Apr-87 04:35:38 EST
Sender: daemon@ucbvax.BERKELEY.EDU
Lines: 91

>Well we BETTER FIGURE OUT how to make messages work over a network.  

	You go ahead and figure it out.  There is no way one can efficiently
implement the Amiga 'message port' standard over a network.  What you do is
implement the Amiga's standard device interface, DOS over the network by
writing a DOS device which allows connections to the DOS device interface on
the remote Amiga's (or the OS of some other arbitrary computer on the network).

	Doing so suddenly reduces the types of messages that can be sent
to DOS's well defined set.... You know exactly which messages can be 
sent and received and *exactly* what they contain, and thus can implement
'sending' them over the network to a counterpart device on the destination
machine efficiently.  You would have something like:

	"NET:Amiga15/DF0:charlie"  etc... 

	I.E. a generic program doesn't know or care that this 'file' would 
actually be going over the network to DF0: on some other machine.


MMU on an Amiga:

	An interesting thought.  Currently not feasible except perhaps as
a protection mechanism or to implement virtual memory.  The VM would be
limited to a general scheme for the whole machine rather than a 'per process'
scheme used by UNIX (i.e. no duplication of addresses).   Implementing an
MMU under the current Amiga enviroment would require resource tracking by
the system.

	Even so, you would *not* be able to implement page mapping (the
"all programs start at the same address" model) since arbitrary programs
will reference the same global structures (Windows/Screens/Libraries/Ports) and
pass pointers to each other.

	(1) No Address Translation
	(2) Entire address space is at least ReadOnly (this solves many
		problems right off).
	(3) Selected address ranges are R/W depending on the process.

	So the question is when to allow a process Write access to some
portion of memory.  Let's simplify the task even further:

	(4) The OS and ALL LIBRARIES and ALL SYSTEM PROCESSES have full
	    write access to the entire address space.  What does this
	    solve?  Remember that processes usually pass arbitrary pointers
	    to called library routines.

	(5) ALL EXEC DEVICES and DOS DEVICES have full write access to same.
	    For the same reason... since any number of 'user' processes can
	    be calling these devices simultaniously, it would be too
	    inefficient to force these processes to run under the 'protection'
	    mechanism.


	What does this leave us?  Well, we have to do full resource tracking,
	including tracking of memory allocation (allocating MMU segments and
	tracking the segments for each process).  


There are still a lot of problems... A process gets a message from another
process containing a pointer to a buffer (which the OS doesn't know about
because it doesn't know what's inside a message).  Currently, we can READ
the buffer no-problem, but what about writing to it?  What about the message
itself?  We have to be able to set the return value...  

What about accessing one's Process, Task, and CLI structures? many processes
(e.g. my Shell) have to modify the Process and CLI structures extensively
when running programs under them.

I guess all video memory should always be RW.  Even with all the limitations
I've put on to make things reasonable, it is still very easy for a wild user
process to destroy the system.... it could, for instance, munge the message
port's message list.  It could just as easily specify some wild pointer to
a library routine (which can write to anywhere)... whoops.

I think it's more trouble than it's worth to implement under AmigaDOS.  Of
course, there *are* OS's where you can implement and MMU, VM, etc... UNIX
for instance.  One of my projects is such an operating system.

I sometimes crash my Amiga when I'm developing a program (but I've never
lost VD0!), but it has *never* happened to me doing normal non-development
stuff.... and were talking having DME, several invocations of my SHELL, 
having two workbench screens (via MWB), all running concurrently with the
Aztec compiler, and my terminal program.  Not to mention judious use of
PIPE: and various other DOS devices (VD0:, RAM:).

Believe me, not having an MMU doesn't bother me in the least! 

(BTW having 2.5Meg of RAM changes your life!).

				-Matt