allocating large blocks of memory

[LAu@a.darpa.mil]

In MACL 1.3.2,  I used _NewPtr to allocate large blocks of memory to be 
used as a highly efficient paging and swapping record structure.  Typically 
I could allocate 1 meg with MACL application size set at 2.5 meg.  The 
memory for such a block was created by the call to _NewPtr,  which 
typically invoked a GC to steal memory from the Lisp stack,  as seen by 
calling (room) before and after _NewPtr.

In MCL 2.0b1p3,  I've tried #_NewPtr( 200000) with the MCL application set 
to 5.0 meg.  This returns a null mac pointer.  It seems that I can only get 
about 100000 bytes from #_NewPtr before a GC is invoked.  If the GC is 
invoked, the GC fails to steal any memory from the Lisp Stack,  and 
#_NewPtr returns a useless null pointer.

Has the ability to get memory from the Lisp stack been disabled?  I plan on 
running my application on a 128Meg IIfx,  to store a 100 meg database in 
memory in the most compact form possible as records accessed by Mac 
pointers.  This won't be possible under MCL 2.0 unless I can keep most of 
that memory from being allocated to the Lisp Stack,  where I don't need it.

I am currently running MCL 2.0b1p3 on System 6.07 on a Mac IIfx. Has anyone 
else out there run into this problem?  At the moment it is a total 
roadblock to my planned high speed Lisp data server.

                                      Lawrence Au