dimitrov@csd2.UUCP (Isaac Dimitrovsky) (05/27/85)
[] I am now in the middle of writing a LISP system for the NYU Ultracomputer. This is a shared memory multiprocessor being put together at NYU. It's intermediate both in the number and power of the individual processors (the final machine is supposed to have on the order of 4K processors, each roughly as powerful as a 68000). I would be glad to supply some references on this machine. Anyway, I am now working on the garbage collection for this system. I have just about decided to use a parallel version of a simple mark and sweep garbage collector. In other words, there will be N processors assigned to a run of the LISP system; under normal conditions, all will be working on interpreting LISP expressions, but when one finds that it can't allocate something from the shared memory, it will signal all the other processors, which will drop whatever they're doing and do the garbage collection together. (Of course, this must be coordinated so that processors are not collecting while others are interpreting, etc). The reasons for this just-about-decision are as follows. I recognize that not doing incremental or dedicated-processor garbage collection leads to a disadvantage (inability to do real-time applications). But using the method above has two advantages which I think have a higher priority: 1. The garbage collection has good speedup, i.e. N processors can collect about N times as fast as one processor. 2. The algorithms for the garbage collection are simple enough that I can reasonably expect to write and debug them in my lifetime. I guess I am looking for someone to convince me that I'm wrong. Also, I would be happy to discuss ideas about parallel programming languages with anyone who's interested. Isaac Dimitrovsky