Lazily allocate and initialise JTs. The goal is to support very large numbers of threads (JTALIGNBDY=1<<31, say, or perhaps just 26 for the sake of the rwlocks) while still having minimal startup resource usage on normal-size machines. I haven't added any allowance for decommitting these; presumably, if you need O(big) threads then you need O(big) threads, so it just doesn't seem very important

Author: moon-chilled

dllsrc/jdll.c

@@ -733,25 +733,15 @@ void getpath(HINSTANCE hi, C* path)
 }
 #endif
 
-// create a memory heap of the given size, allocate a JST in it, and store the address
-// of the heap into jt->heap so that the JE can do memory allocations from it
-JS heapinit(int size)
+// create a skeletal JS--just good enough to do basic initialisation
+JS heapinit()
 {
-	HANDLE h;
-	JS jt;
-
-	h = HeapCreate(0, size, 0);
-	if(!h) return 0;
-	jt = HeapAlloc(h, 0, sizeof(JST)+JTALIGNBDY-1);
-	if(!jt)
-	{
-		HeapDestroy(h);
-		return 0;
-	}
- jt = (JS)(((I)jt+JTALIGNBDY-1)&-JTALIGNBDY);  // force to SDRAM page boundary
-	mvc(sizeof(JST),jt,1,MEMSET00);
-	JT(jt,heap) = h;
-	return jt;
+ JS jt=jmreserve(sizeof(JST),__builtin_ctz(JTALIGNBDY));
+ if(!jt)R 0; //no address space
+ I sz=(I)&jt->threaddata[2]-(I)jt; // #relevant bytes: just JS and the first JT
+ if(!jmcommit(jt,sz)){jmrelease(jt,sizeof(JST));R 0;} //no memory
+	mvc(sz,jt,1,MEMSET00);
+ R jt;
 }
 
 int WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved)
@@ -778,9 +768,9 @@ int WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved)
         // just enough to do GA().  The rest of jt is never used
 		getpath(0, modulepath);
 		getpath(hDLL, dllpath);
-		g_jt=heapinit(10000);  // just enough for a few allocations
+		g_jt=heapinit()
 		if(!g_jt) R 0;   // abort if no memory
-		if(!jtglobinit(g_jt)) {HeapDestroy(g_jt->heap); g_jt=0; R 0;};  // free & abort if initialization error
+		if(!jtglobinit(g_jt)) {jmrelease(g_jt,sizeof(JST)); g_jt=0; R 0;};  // free & abort if initialization error
         // The g_jt heap MUST NOT be freed, because it holds the blocks pointed to by initialized globals.
         // g_jt itself, a JST struct, is not used.  Perhaps it could be freed, as long as the rest of the heap remains.
 		break;
@@ -792,7 +782,7 @@ int WINAPI DllMain (HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved)
       break;
 
     case DLL_PROCESS_DETACH:
-		if(g_jt) HeapDestroy(g_jt->heap);
+		if(g_jt){jmrelease(g_jt,sizeof(JST));g_jt=0;}
 		break;
   }
 return TRUE;

jsrc/ct.c

@@ -8,7 +8,7 @@ extern int numberOfCores;
 // burn some time, approximately n nanoseconds
 NOINLINE I johnson(I n){I johnson=0x1234; if(n<0)R n; do{johnson ^= (johnson<<1) ^ johnson>>(BW-1);}while(--n); R johnson&-256;}  // return low byte 0
 #if PYXES
-#define delay(n) {if(__builtin_constant_p(n)){if(n>36)DONOUNROLL(n/36,_mm_pause();)else johnson(n);}else if(unlikely(n>36))DONOUNROLL((n-7)/36,_mm_pause();)else johnson(n);}
+#define delay(n) {if(__builtin_constant_p(n)){if(n>36)DONOUNROLL(n/36,_mm_pause();)else johnson(n);}else if(uncommon(n>36))DONOUNROLL((n-7)/36,_mm_pause();)else johnson(n);}
 #else
 #define delay(n)
 #endif
@@ -86,7 +86,7 @@ I jtextendunderlock(J jt, A *abuf, US *alock, I flags){A z;
 // wakeallct keeps track of the number of wakealls being processed.  When this is nonzero, a waiter must not allow the block pointed to by futexwt to go away.  And, it must
 // consider that wakeall may have sampled futexwt before it was cleared.  So, the waiter must wait for wakeallct to go to 0 before exiting.
 // Only a couple of threads can call wakeall (the leader, and a JBreak), so 1 byte suffices for wakeallct.
-void wakeall(J jt){aadd(&JT(jt,wakeallct),1); UI4 *wta; DONOUNROLL(MAXTHREADS,if((wta=JTTHREAD0(jt)[i].futexwt)!=0){aadd(wta,0x10000); jfutex_wakea(wta);} ) aadd(&JT(jt,wakeallct),(UC)-1);}
+void wakeall(J jt){aadd(&JT(jt,wakeallct),1); UI4 *wta; DONOUNROLL(NALLTHREADS(jt),if((wta=JTTHREAD0(jt)[i].futexwt)!=0){aadd(wta,0x10000); jfutex_wakea(wta);} ) aadd(&JT(jt,wakeallct),(UC)-1);}
 #else
 void wakeall(J jt){}
 #endif
@@ -104,11 +104,11 @@ A jtsystemlock(J jt,I priority,A (*lockedfunction)(J)){A z;
  // Process the request.  We don't know what the highest-priority request is until we have heard from all the
  // threads.  Thus, it is possible that our request will still be pending whe we finish.  In that case, loop till it is satisfied
  while(priority!=0){
-  S xxx=0; I leader=__atomic_compare_exchange_n(&JT(jt,systemlock), &xxx, (S)1, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED);  // go to state 1; set leader if we are the first to do so
+  I leader=__atomic_compare_exchange_n(&JT(jt,systemlock), &(S){0}, (S)1, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED);  // go to state 1; set leader if we are the first to do so
   I nrunning=0; JTT *jjbase=JTTHREAD0(jt);  // #running threads, base of thread blocks
   // In the leader task only, go through all tasks (including master), turning on the SYSLOCK task flag in each thread.  Count how many are running after the flag is set
   // Also, wake up all tasks that are in a loop that needs interrupting on system action.  Those loops will honor it when we are in state 1/2
-  if(leader){DONOUNROLL(MAXTHREADS, nrunning+=(__atomic_fetch_or(&jjbase[i].taskstate,TASKSTATELOCKACTIVE,__ATOMIC_ACQ_REL)>>TASKSTATERUNNINGX)&1;) wakeall(jt);}
+  if(leader){DONOUNROLL(NALLTHREADS(jt), nrunning+=(__atomic_fetch_or(&jjbase[i].taskstate,TASKSTATELOCKACTIVE,__ATOMIC_ACQ_REL)>>TASKSTATERUNNINGX)&1;) wakeall(jt);}
   // state 2: lock requesters indicate request priority and we wait for all tasks to come to a stop.  We wake all threads that are waiting on pyx/mutex
   C oldpriority; DOINSTATE(leader,2,oldpriority=__atomic_fetch_or(&JT(jt,adbreak)[1],priority,__ATOMIC_ACQ_REL);)  // remember priority before we made our request
   // state 3: all threads get the final request priorities
@@ -132,7 +132,7 @@ A jtsystemlock(J jt,I priority,A (*lockedfunction)(J)){A z;
   if(executor){
    __atomic_store_n(&((C*)&JT(jt,breakbytes))[1],0,__ATOMIC_RELEASE);  // clear the error flag from the interrupt request
    // go through all threads, turning off SYSLOCK in each.  This allows other tasks to run and new tasks to start
-   DO(MAXTHREADS, __atomic_fetch_and(&jjbase[i].taskstate,~TASKSTATELOCKACTIVE,__ATOMIC_ACQ_REL);)
+   DO(NALLTHREADS(jt), __atomic_fetch_and(&jjbase[i].taskstate,~TASKSTATELOCKACTIVE,__ATOMIC_ACQ_REL);)
    // set the systemlock to 0, completing the operation
    __atomic_store_n(&JT(jt,systemlock),0,__ATOMIC_RELEASE);
   }else{
@@ -339,7 +339,7 @@ typedef struct jobstruct {
 // we use the 6 LSBs of jobq->ht[0] as the lock, so that when we get the lock we also have the job pointer.  The job is always on a cacheline boundary
 // We take JOBLOCK before taking the mutex, always.  By measurement (20220516 SkylakeX, 4 cores) the job lock keeps contention low until the tasks are < 400ns
 // long, while using the mutex gives out at < 1000ns
-_Static_assert(MAXTHREADS<64,"JOBLOCK fails if > 63 threads");
+_Static_assert(MAXTHREADSINPOOL<64,"JOBLOCK fails if > 63 threads");
 #define JOBLOCK(jobq) ({I z; if(unlikely(((z=__atomic_fetch_add((I*)&jobq->ht[0],1,__ATOMIC_ACQ_REL))&(CACHELINESIZE-1))!=0))z=joblock(jobq); (JOB*)z; })
 #define JOBUNLOCK(jobq,oldh) __atomic_store_n(&jobq->ht[0],oldh,__ATOMIC_RELEASE);
 static NOINLINE I joblock(JOBQ *jobq){I z;
@@ -796,6 +796,10 @@ ASSERT(0,EVNONCE)
    WRITELOCK(JT(jt,flock))  // nwthreads is protected by flock
    resthread=THREADIDFORWORKER(JT(jt,nwthreads));  // number of current worker threads.  Next worker is nwthreads; convert worker# to thread#
    ASSERTSUFF(resthread<MAXTHREADS,EVLIMIT,WRITEUNLOCK(JT(jt,flock)); R 0;); //  error if new 0-origin thread# exceeds limit
+   if(!jmcommit(JTFORTHREAD(jt,resthread),sizeof(JTT))){ // attempt to commit thread data (in case it's not already committed); if failed, then bail
+    WRITEUNLOCK(JT(jt,flock));
+    ASSERT(0,EVWSFULL);}
+   if(unlikely(!jtjinitt(JTFORTHREAD(jt,resthread)))){WRITEUNLOCK(JT(jt,flock)); R 0;} // initialise thread-local state
    if(!(__atomic_load_n(&JTFORTHREAD(jt,resthread)->taskstate,__ATOMIC_ACQUIRE)&TASKSTATETERMINATE))break;
    WRITEUNLOCK(JT(jt,flock))  // release lock for next poll
    if(unlikely(lda(&JT(jt,adbreak)[1]))!=0){jtsystemlockaccept(jt,LOCKALL);}else{YIELD}  // allow syslock if requested; otherwise let other threads run

jsrc/dsusp.c

@@ -328,7 +328,7 @@ F1(jtdbc){UC k;
  if(AN(w)){
   // turn debugging on/off in all threads
   JTT *jjbase=JTTHREAD0(jt);  // base of thread blocks
-  DONOUNROLL(MAXTHREADS, if(k&1)__atomic_fetch_or(&jjbase[i].uflags.trace,TRACEDB1,__ATOMIC_ACQ_REL);else __atomic_fetch_and(&jjbase[i].uflags.trace,~TRACEDB1,__ATOMIC_ACQ_REL);) JT(jt,dbuser)=k;
+  DONOUNROLL(NALLTHREADS(jt), if(k&1)__atomic_fetch_or(&jjbase[i].uflags.trace,TRACEDB1,__ATOMIC_ACQ_REL);else __atomic_fetch_and(&jjbase[i].uflags.trace,~TRACEDB1,__ATOMIC_ACQ_REL);) JT(jt,dbuser)=k;
 #if USECSTACK
   jt->cstackmin=jt->cstackinit-((CSTACKSIZE-CSTACKRESERVE)>>k);
 #else

jsrc/dtoa.c

@@ -3398,8 +3398,7 @@ d2a_Malloc
 #endif
 
 // called only at initialization, so no ras() needed
-B jtecvtinit(JS jjt, I nthreads) {A x; struct dtoa_info *di;
- I threadno; for(threadno=0;threadno<nthreads;++threadno){JJ jt=&jjt->threaddata[threadno];
+B jtecvtinit(J jt) {A x; struct dtoa_info *di;
  GATV0(x, LIT, sizeof(struct dtoa_info), 1);
  di=(struct dtoa_info*)AV(x); 
  di->_p5s=0;
@@ -3408,7 +3407,6 @@ B jtecvtinit(JS jjt, I nthreads) {A x; struct dtoa_info *di;
  mvc( sizeof(di->_freelist),di->_freelist,1,MEMSET00);
  di->jt=jt;  // remember thread pointer in case further ga() needed
  jt->dtoa=di;
- }
  R 1;
 }
 

jsrc/i.c

@@ -54,7 +54,8 @@ JS gjt=0; // JPF debug - convenience debug single process - points to shared are
 // The jt we are given is a throwaway, needed ONLY so we can allocate some A blocks here.  Anything stored
 // into jt will never be used.  jinit3 will later be called with the real jt, to initialize it
 B jtglobinit(JS jjt){A x,y;J jt=MTHREAD(jjt);  // initialize in master thread
- jtmeminit(jjt,1);  // init allocation queues & tpop stack, master thread only
+ jtmeminits(jjt);
+ jtmeminitt(jt);  // init allocation queues & tpop stack, master thread only
  RZ(mnuvxynam[0]=makename("m",0));
  RZ(mnuvxynam[1]=makename("n",0));
  RZ(mnuvxynam[2]=makename("u",NAMEBYVALUE));  // uv (and thus u. v.) must be defined when used in an explicit def.  Otherwise OK
@@ -81,7 +82,7 @@ B jtglobinit(JS jjt){A x,y;J jt=MTHREAD(jjt);  // initialize in master thread
  R 1;
 }
 
-static B jtevinit(JS jjt,I nthreads){A q,*v;JJ jt=MTHREAD(jjt);
+static B jtevinit(JS jjt){A q,*v;JJ jt=MTHREAD(jjt);
  GA10(q,BOX,1+NEVM); v=AAV(q);
  DO(AN(q), v[i]=mtv;);
  v[EVALLOC  ]=INCORPNA(cstr("allocation error"           ));
@@ -119,14 +120,13 @@ static B jtevinit(JS jjt,I nthreads){A q,*v;JJ jt=MTHREAD(jjt);
  v[EVTHROW  ]=INCORPNA(cstr("uncaught throw."            ));
  v[EVTIME   ]=INCORPNA(cstr("time limit"                 ));
  v[EVVALUE  ]=INCORPNA(cstr("value error"                ));
-// no more v[EVCONCURRENCY]=INCORPNA(cstr("concurrency error"      ));
  ACINITZAPRECUR(q,BOX); INITJT(jjt,evm)=q;   // q and its contents are not on tstack; this way the contents are freed on assignment
  if(jt->jerr){printf("evinit failed; error %hhi\n", jt->jerr); R 0;} else R 1;
 }
 
 /* static void sigflpe(int k){jsignal(EVDOMAIN); signal(SIGFPE,sigflpe);} */
 
-static B jtconsinit(JS jjt,I nthreads){D y;JJ jt=MTHREAD(jjt);
+static B jtconsinits(JS jjt){D y;JJ jt=MTHREAD(jjt);
 // This is an initialization routine, so memory allocations performed here are NOT
 // automatically freed by tpop()
 #if AUDITCOMPILER
@@ -167,40 +167,53 @@ if(((-1) >> 1) != -1)*(I *)4 = 104;
   jt->fdepn=NFDEP;
 #endif
  MTHREAD(jjt)->threadpoolno=-1; // the master thread is in no pool, ever
- 
- I threadno; for(threadno=0;threadno<nthreads;++threadno){jt=&jjt->threaddata[threadno];
-  RESETRANK;  // init both ranks to RMAX
-  jt->ppn=6;  // default precision for printf
-  jt->fcalln=NFCALL;
-  jt->cct= 1.0-FUZZ;
-  jt->xmode=XMEXACT;
+ R 1;
+}
+
+static B jtconsinitt(J jt){
+ RESETRANK;  // init both ranks to RMAX
+ jt->ppn=6;  // default precision for printf
+ jt->fcalln=NFCALL;
+ jt->cct= 1.0-FUZZ;
+ jt->xmode=XMEXACT;
  // create an initial stack, so that stack[-1] can be used for saving error messages
-  jt->parserstackframe.parserstkbgn=jt->parserstackframe.parserstkend1=&jt->initparserstack[1];  // ensure valid error stack after final return
- }
+ jt->parserstackframe.parserstkbgn=jt->parserstackframe.parserstkend1=&jt->initparserstack[1];  // ensure valid error stack after final return
  R 1;
 }
 
-static B jtbufferinit(JS jjt,I nthreads){
- INITJT(jjt,breakfn)=malloc(NPATH); memset(INITJT(jjt,breakfn),0,NPATH);  // place to hold the break filename
- I threadno; for(threadno=0;threadno<nthreads;++threadno){JJ jt=&jjt->threaddata[threadno];
-  jt->etx=malloc(1+NETX);  // error-message buffer
-  jt->callstack=(LS *)malloc(sizeof(LS)*(1+NFCALL));  // function-call stack
-  jt->rngdata=(RNG*)(((I)malloc(sizeof(RNG)+CACHELINESIZE)+CACHELINESIZE-1)&-CACHELINESIZE); mvc(sizeof(RNG),jt->rngdata,1,MEMSET00);  // place to hold RNG data, aligned to cacheline
- }
+// initialise shared buffers
+static B jtbufferinits(JS jjt){
+ R !!(INITJT(jjt,breakfn)=calloc(1,NPATH)); // place to hold the break filename
+}
+
+// initialise thread-local buffers for thread threadno.  Requires synchronisation
+B jtbufferinitt(J jt){
+ RZ(jt->etx=malloc(1+NETX));  // error-message buffer
+ RZ(jt->callstack=malloc(sizeof(LS)*(1+NFCALL)));  // function-call stack
+ RZ(jt->rngdata=aligned_malloc(sizeof(RNG),CACHELINESIZE)); // place to hold RNG data, aligned to cacheline
+ memset(jt->rngdata,0,sizeof(RNG));
  R 1;
 }
 
- // We have completed initial allocation.  Everything allocated so far will not be freed by a tpop, because
- // tpop() isn't called during initialization.  So, to keep the memory auditor happy, we reset ttop so that it doesn't
- // look like those symbols have a free outstanding.
- // This also has the effect that buffers allocated during init do not need ra() to protect them, since they have no free outstanding
-static B jtinitfinis(JS jjt,I nthreads){
- I threadno; for(threadno=0;threadno<nthreads;++threadno){JJ jt=&jjt->threaddata[threadno];
-  jt->tnextpushp=(A*)(((I)jt->tstackcurr+NTSTACKBLOCK)&(-NTSTACKBLOCK))+1;  // first store is to entry 1 of the first block
- }
+// We have completed initial allocation.  Everything allocated so far will not be freed by a tpop, because
+// tpop() isn't called during initialization.  So, to keep the memory auditor happy, we reset ttop so that it doesn't
+// look like those symbols have a free outstanding.
+// This also has the effect that buffers allocated during init do not need ra() to protect them, since they have no free outstanding
+static B jtinitfinis(J jt){
+ jt->tnextpushp=(A*)(((I)jt->tstackcurr+NTSTACKBLOCK)&(-NTSTACKBLOCK))+1;  // first store is to entry 1 of the first block
  R 1;
 }
 
+// Initialise thread-specific data for jt.  Idempotent.  Requires synchronisation.
+C jtjinitt(J jt){
+ if(jt->etx)R 1; // already initialised; ok
+ RZ(jtbufferinitt(jt));  // init thread-local buffers
+ RZ(jtmeminitt(jt));
+ RZ(jtconsinitt(jt));
+ RZ(jtrnginit(jt)); // thread only
+ RZ(jtecvtinit(jt));
+ RZ(jtinitfinis(jt));
+ R 1;}
 
 // initialize the master thread for a new instance.  This fills in the JS block, which will remain
 // for the duration of the instance.  It also fills in the JJ block for each thread
@@ -226,24 +239,26 @@ static C jtjinit3(JS jjt){S t;JJ jt=MTHREAD(jjt);
 #endif
 // only crashing on startup INITJT(jjt,peekdata)=1;  // wake up auditing
  // Initialize subsystems in order.  Each initializes all threads, if there are thread variables
- RZ(jtbufferinit(jjt,MAXTHREADS)); // init the buffers pointed to by jjt
- RZ(jtmeminit(jjt,MAXTHREADS));
- RZ(jtsesminit(jjt,MAXTHREADS));  // master only
- RZ(jtcdinit(jjt,MAXTHREADS));  // master only
- RZ(jtevinit(jjt,MAXTHREADS));  // master only
- RZ(jtconsinit(jjt,MAXTHREADS));
- RZ(jtxsinit(jjt,MAXTHREADS));  // must be before symbinit  master only
- RZ(jtsymbinit(jjt,MAXTHREADS));  // must be after consinit   master only - global/locsyms must init at start of op
- RZ(jtparseinit(jjt,MAXTHREADS));
- RZ(jtxoinit(jjt,MAXTHREADS));  // master only
- RZ(jtsbtypeinit(jjt,MAXTHREADS));  // master only
- RZ(jtrnginit(jjt,MAXTHREADS));
+ RZ(jtbufferinits(jjt)); // init the buffers pointed to by jjt
+ RZ(jtbufferinitt(jt));  // init thread-local buffers
+ RZ(jtmeminits(jjt));
+ RZ(jtmeminitt(jt));
+ RZ(jtsesminit(jjt,1));  // master only.  scaf pointless?
+ RZ(jtcdinit(jjt));  // master only
+ RZ(jtevinit(jjt));  // master only
+ RZ(jtconsinits(jjt));
+ RZ(jtconsinitt(jt));
+ RZ(jtxsinit(jjt));  // must be before symbinit  master only
+ RZ(jtsymbinit(jjt));  // must be after consinit   master only - global/locsyms must init at start of op
+ RZ(jtxoinit(jjt));  // master only
+ RZ(jtsbtypeinit(jjt));  // master only
+ RZ(jtrnginit(jt));
 // #if (SYS & SYS_DOS+SYS_MACINTOSH+SYS_UNIX)
 #if (SYS & SYS_DOS+SYS_MACINTOSH)
- RZ(jtxlinit(jjt,MAXTHREADS));  // file info, master only
+ RZ(jtxlinit(jjt));  // file info, master only
 #endif
- RZ(jtecvtinit(jjt,MAXTHREADS));
- RZ(jtinitfinis(jjt,MAXTHREADS));
+ RZ(jtecvtinit(jt));
+ RZ(jtinitfinis(jt));
  R 1;
 }
 

jsrc/io.c

@@ -713,33 +713,30 @@ void jsto(JS jt,I type,C*s){C e;I ex;
 C dll_initialized= 0; // dll init sets to 1
 
 // dll init on load - eqivalent to windows DLLMAIN DLL_ATTACH_PROOCESS
-__attribute__((constructor)) static void Initializer(int argc, char** argv, char** envp)
-{
+__attribute__((constructor)) static void Initializer(){
  // Initialize J globals.  This is done only once.  Many of the globals are in static memory, initialized
  // by the compiler; some must be initialized a run-time in static memory; some must be allocated into A blocks
  // pointed to by static names.  Because of the A blocks, we have to perform a skeletal initialization of jt,
  // just enough to do ga().  The rest of jt is never used
- JS jtnobdy=malloc(sizeof(JST)+JTALIGNBDY-1);
- if(!jtnobdy) R;
- JS jt = (JS)(((I)jtnobdy+JTALIGNBDY-1)&-JTALIGNBDY);  // force to SDRAM page boundary
- mvc(sizeof(JST),jt,1,MEMSET00);
- if(!jtglobinit(jt)){free(jtnobdy); R;}
- dll_initialized= 1; JT(jt,heap)=(void *)jtnobdy;  // save allo address for later free
- // The g_jt heap MUST NOT be freed, because it holds the blocks pointed to by initialized globals.
- // g_jt itself, a JST struct, is not used.  Perhaps it could be freed, as long as the rest of the heap remains.
+ JS jt=jmreservea(sizeof(JST),__builtin_ctz(JTALIGNBDY));
+ if(!jt)R;
+ I sz=offsetof(JST,threaddata[1]); // #relevant bytes: just JS and the first JT
+ if(!jmcommit(jt,sz)){jmrelease(jt,sizeof(JST));R;}
+ if(!jtglobinit(jt)){jmrelease(jt,sizeof(JST)); R;}
+ dll_initialized=1;
+ jmrelease(jt,sizeof(JST)); //the jt block itself can be released; we effectively orphan any blocks pointed to there by, because they are used by the globals we've just initialised
 }
 
  // Init for a new J instance.  Globals have already been initialized.
  // Create a new jt, which will be the one we use for the entirety of the instance.
 JS _stdcall JInit(void){
- if(!dll_initialized) R 0; // constructor failed
- JS jtnobdy;
- RZ(jtnobdy=malloc(sizeof(JST)+JTALIGNBDY-1));
- JS jt = (JS)(((I)jtnobdy+JTALIGNBDY-1)&-JTALIGNBDY);  // force to SDRAM page boundary
- mvc(sizeof(JST),jt,1,MEMSET00);
+ if(!dll_initialized)R 0; // constructor failed
+ JS jt=jmreservea(sizeof(JST),__builtin_ctz(JTALIGNBDY));
+ if(!jt)R 0;
+ if(!jmcommit(jt,offsetof(JST,threaddata[1]))){jmrelease(jt,sizeof(JST));R 0;}
+ mvc(offsetof(JST,threaddata[1]),jt,1,MEMSET00);
  // Initialize all the info for the shared region and the master thread
- if(!jtjinit2(jt,0,0)){free(jtnobdy); R 0;};
- JT(jt,heap)=(void *)jtnobdy;  // save allo address for later free
+ if(!jtjinit2(jt,0,0)){jmrelease(jt,sizeof(JST)); R 0;}
  R jt;  // R (JS)MTHREAD(jt);
 }
 
@@ -753,7 +750,7 @@ int _stdcall JFree(JS jt){
 #if PYXES
   aligned_free(JT(jt,jobqueue));
 #endif
-  free(JT(jt,heap));  // free the initial allocation
+  jmrelease(jt,sizeof(JST)); // free the initial allocation
   R 0;
 }
 #endif