🚀 go-pugleaf

In article <43qh32INN3hl@keats.ugrad.cs.ubc.ca>, c2a192@ugrad.cs.ubc.ca
(Kazimir Kylheku) wrote:

> My argument was that simple malloc-like heap management is more than
> sufficient to manage the dynamic data space of most applications, and that
> handle schemes are ridiculous overkill.

And this is based on what exactly?  Proof otherwise:  the Mac only does
compaction (and purging) if there is not a large enough free block to
satisfy an allocation request (coalaesing is done on freeing the block). 
Many applications have had their heaps compacted in the past.  Therefore,
it is not overkill.  The only alternate strategies I've seen you post is
to either just quit the app, or throw a heck of a lot more hardware (RAM,
disk space, etc.) to delay the problem.  Have you even bothered to read
Inside Mac to try and understand why Apple implemented memory management
in this way?

> A lot of old Mac programs (especially shareware) won't run on modern Macs,
> but ghosts of the original design still plague the system.

I have a copy of Missle Command from 1984 that still runs.  The main
problem with old apps is that they *knew* how the memory manager locked
handles and did it directly instead of calling the system.  At no point
did I have to throw away every single piece of software that I had and
start over; I got to do it gradually, which is something my pocketbook
could handle, as I am not as rich as you must be to support the kinds of
solutions you keep proposing.

> You mean they don't suffer from external fragmentation.  The internal
> fragmentation is there, but it's simply not a problem. You don't feel it.

The only way you don't feel it is if you spend enough money to delay the
problem.

> They have problems, but from my experience with Amigas, I have found
> them to be quite stable compared to the Macintoshes.

I find them just as stable/unstable as Macs.

> It could have something
> to do with not contorting the act of programming around some asinine
> memory allocation scheme.

Or more to the fact that people rarely install new software on their
Amigas these days.  My Mac is very stable when I'm not doing development
or acquiring some new piece of software.

> We are overlooking portability in all this. If I wanted to port a non-trivial
> program to the Macintosh, I would be faced with the difficult task to
> comb through the code adding WaitNextEvent() calls all over the place, 
> as well handle locks and dereferences.

Well, since you don't believe that compaction helps, there is nothing
stopping you from keeping the handles locked all the time.  Also, most of
your code probably isn't doing system calls, so it shouldn't need to
change much (they can still use pointers).  There is even a handy NewPtr()
call, and most of the development environments implement malloc() for you.


Another benefit to handles is it makes it easy to grow the size of the
allocated block.  This is hard to do with just pointers, as one has to do
a lot of bookkeeping in case more that one pointer is pointing to the same
block.  I can have as many copies of the handle as I want and not have to
worry about this.
-- 
        Nevin ":-)" Liber       nevin@CS.Arizona.EDU    (520) 293-2799