bstkreqd to before starting exec chain; allow for changes in locale from non-name execution; remove sf from jtexec1

Author: HenryHRich

jsrc/ct.c

@@ -389,7 +389,6 @@ static void *jtthreadmain(void *arg){J jt=arg;I dummy;
  __atomic_store_n(&jt->cstackmin,jt->cstackinit-(CSTACKSIZE-CSTACKRESERVE),__ATOMIC_RELEASE);  // use a local as a surrogate for the stack pointer
  // Note: we use cstackmin as an indication that this thread is ready to use.
  JOBQ *jobq=&(*JT(jt,jobqueue))[jt->threadpoolno];   // The jobq block for the threadpool we are in - never changes
- jt->uflags.bstkreqd=1;   // init so that every top-level change of locale is reflected in startcounts.  That way we can decr the global locale at end-of-job
 
  // loop forever executing tasks.  First time through, the thread-creation code holds the job lock until the initialization finishes
 nexttask: ; 
@@ -473,7 +472,8 @@ nexttasklocked: ;  // come here if already holding the lock, and job is set
    jt->locsyms=(A)(*JT(jt,emptylocale))[THREADID(jt)]; SYMSETGLOBAL(jt->locsyms,startloc); RESETRANK; jt->currslistx=-1; jt->recurstate=RECSTATERUNNING;  // init what needs initing.  Notably clear the local symbols
    jtsettaskrunning(jt);  // go to RUNNING state, perhaps after waiting for system lock to finish
    // run the task, raising & lowering the locale execct.  Bivalent
-   if(likely(startloc!=0)){INCREXECCT(startloc); fa(startloc);}  // raise execcount of current locale to protect it while running; remove the protection installed in taskrun()
+// obsolete    if(likely(startloc!=0)){INCREXECCTIF(startloc); fa(startloc);}  // raise execcount of current locale to protect it while running; remove the protection installed in taskrun()
+   jt->uflags.bstkreqd=1; INCREXECCTIF(startloc); fa(startloc);  // start new exec chain; raise execcount of current locale to protect it while running; remove the protection installed in taskrun()
    A arg1=job->user.args[0],arg2=job->user.args[1],arg3=job->user.args[2];
    fa(UNvoidAV1(job));  // job is no longer needed
    I dyad=!(AT(arg2)&VERB); A self=dyad?arg3:arg2; arg3=dyad?arg3:0;  // the call is either noun self x or noun noun self.  See which and select self.  Set arg3 to 0 if monad.
@@ -484,7 +484,7 @@ nexttasklocked: ;  // come here if already holding the lock, and job is set
    A z=(FAV(uarg3)->valencefns[dyad])(jt,arg1,uarg2,uarg3);  // execute the u in u t. v
    // ***** return from user task and look for next one *****
 // obsolete    if(likely(jt->global!=0))
-   DECREXECCT(jt->global);  // remove exec-protection from finishing locale.  This may result in its deletion
+   DECREXECCTIF(jt->global);  // remove exec-protection from finishing exec chain.  This may result in its deletion
    // put the result into the result block.  If there was an error, use the error code as the result.  But make sure the value is non0 so the pyx doesn't wait forever
    C errcode=0;
    if(unlikely(z==0)){fail:errcode=jt->jerr; errcode=(errcode==0)?EVSYSTEM:errcode;}else{realizeifvirtualERR(z,goto fail;);}  // realize virtual result before returning it

jsrc/i.c

@@ -183,8 +183,8 @@ static B jtconsinitt(J jt){
  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->uflags.bstkreqd=1;   // indicate that cocurrent has been called at this level.  This forces unquote to incr/decr execcts for every cocurrent, leaving only one active at final return
+ jt->parserstackframe.parserstkbgn=jt->parserstackframe.parserstkend1=&jt->initparserstack[1];  // ensure valid error stack after final return (start off the end)
+// obsolete  jt->uflags.bstkreqd=1;   // indicate that cocurrent has been called at this level.  This forces unquote to incr/decr execcts for every cocurrent, leaving only one active at final return
  R 1;
 }
 

jsrc/io.c

@@ -443,23 +443,22 @@ F1(jtjoff){I x;
  R 0;
 }
 
-// wrapper to raise the execct of the starting locale while an immex is running
-// If the global locale changes during execution, we must have called cocurrent or 18!:4 directly.  If cocurrent, there will be a
-// POPFIRST on the stack (which is otherwise empty).  If there is a POPFIRST we need to decrement the current global locale.
-// in this routine jt is a thread pointer and jjt is the shared pointer
+// wrapper to put a new exec chain into play
+// set bstkreqd, incr the starting locale, decr the final locale.  unquote will EXECCTIF all changes 
 static void jtimmexexecct(JJ jt, A x){
- A startloc=jt->global;  // point to current global locale
- INCREXECCT(startloc);  // raise usecount of current locale to protect it while running
- jtimmex(jt,x);   // run the sentence
- DECREXECCT(startloc);  // remove protection from executed locale.  This may result in its deletion
+// obsolete  A startloc=jt->global;  // point to current global locale
+// obsolete  INCREXECCT(startloc);  // raise usecount of current locale to protect it while running
+// obsolete  jtimmex(jt,x);   // run the sentence
+// obsolete  DECREXECCT(startloc);  // remove protection from executed locale.  This may result in its deletion
+ jt->uflags.bstkreqd=1; INCREXECCTIF(jt->global); jtimmex(jt,x); DECREXECCTIF(jt->global);  // execution of the sentence may change jt->global
 }
 
 
 // if there is an immex sentence, fetch it, protect it from deletion, run it, and undo the protection
 // in this routine jt is a thread pointer and jjt is the shared pointer
 static void runiep(JS jjt,JJ jt,A *old){
  while(1){
- // if there is an immex phrase, protect it during its execution
+  // if there is an immex phrase, protect it during its execution
   A iep=0; if(jt->iepdo&1){READLOCK(jjt->felock) if((iep=jjt->iep)!=0)ra(iep); READUNLOCK(jjt->felock)}
   if(iep==0)break;
   // run the IEP and clean up after.  We leave iepdo set to 'running' during the exec to suppress postmortem debugging while IEPs are about
@@ -487,7 +486,7 @@ static I jdo(JS jt, C* lp){I e;A x;JJ jm=MDTHREAD(jt);  // get address of thread
    // user wants to debug the error.  Transfer the pmstack to the debug stack in reverse order.  ra() the self for each block - necessary in case they are reassigned while on the stack
    DC s=jm->pmstacktop, sp=0; while(s){DC sn=s->dclnk; s->dclnk=sp; if(s->dctype==DCCALL&&s->dcpflags==1)ra(s->dcf) sp=s; s=sn;} jm->sitop=sp; jm->pmstacktop=0;  // reverse pmstack, move it to debug stack
    if(sp)sp->dcsusp=1;   // debug discards lines before the suspension, so we have to mark the stack-top as starting suspension
-   lp="'Use y___1 to look inside top stack frame; see code.jsoftware.com/wiki/Debug/Stack#irefs' [ dbg_z_ 513";  // change the sentence to one that starts the debug window with no TRACEDBSUSCLEAR flag
+   lp="'dbr 0 to end inspection; use y___1 to look inside top stack frame (see code.jsoftware.com/wiki/Debug/Stack#irefs)' [ dbg_z_ 513";  // change the sentence to one that starts the debug window with no TRACEDBSUSCLEAR flag
   }
  }
 
@@ -514,10 +513,13 @@ static I jdo(JS jt, C* lp){I e;A x;JJ jm=MDTHREAD(jt);  // get address of thread
  e=jm->jerr; MODESRESET(jm)  // save error on sentence to be our return code
  jtshowerr(jm);   // jt flags=0 to force typeout of iep errors
  RESETERRT(jm)
- // if there is an immex latent expression (9!:27), execute it before prompting
+ // if there is an immex latent expression (9!:27), execute it before prompting.  It runs in the same state as the user sentence
  // All these immexes run with result-display enabled (jt flags=0)
  // BUT: don't do it if the call is recursive.  The user might have set the iep before a prompt, and won't expect it to be executed asynchronously
+ // we could do this in a loop back through exexct, but we choose not to
  if(likely(!(jm->recurstate&RECSTATERENT)))runiep(jt,jm,old);  // IEP does not display its errors
+
+ // user's sentence and iep if any are finished.  e has the return code.  Return to user
  if(likely(wasidle)){  // returning to immex in the FE
   jtclrtaskrunning(jm);  //  clear running state in case other tasks are running and need system lock - but not if recursion
   // since we are returning to user-prompt level, we might as well take user think time to trim up memory

jsrc/jt.h

@@ -99,10 +99,11 @@ struct __attribute__((aligned(JTFLAGMSK+1))) JTTstruct {
                                    // debug flags are also used for dbuser
                    // ************************************** here starts the area that is initialized to 0 when task starts 0x14
    C init0area[0]; // label for initializing.  We overcopy to a full I, then back up to copy 0
-   C bstkreqd;   // init to 1 at thread startup.  cleared at the start of each function call.  Set at the end of a function call if (1) the function was cocurrent or (2) bstkreqd was set just before the function was called.  Taken together, these conditions
-                // mean that bstkreqd is set at the end of a function af that function or any preceding functions with the same caller changed the implied locale.  When a function ends, it looks at bstkreqd.  If it is set,
-                // the running locale has been changed by a called function and must be reset.  bstkreqd is set to 1 initially, which causes each change of locale before the first named call to incr/decr both locale counts, thus
-                // housekeeping the counts as if there were a named call to begin with.
+   C bstkreqd;   // cleared at the start of each function call.  Set at the end of a function call if (1) the function was cocurrent or (2) bstkreqd was set just before the function was called.  Taken together, these conditions
+                // mean that bstkreqd is set at the end of a function if that function or any preceding functions with the same caller changed the implied locale.  When a function ends, it looks at bstkreqd.  If it is set,
+                // the running locale has been changed by a called function and must be reset.  When a name is called, bstkreqd means that a previous name called by the same caller changes the locale.
+                // this is important because the FIRST change of locale skips some processing.  When starting an execution, such as from the console or in a thread: set bstkreqd to 1, INCREXECCTIF the starting thread, DECREXECCTIF at end of exec.
+                // This will guarantee raising the usecount of each executing thread
    union {
     US spflag; // access as short
     struct {

jsrc/jtype.h

@@ -875,6 +875,9 @@ typedef DST* DC;
 #define DECREXECCT(l) if(--LXAV0(l)[SYMLEXECCT]==0)locdestroy(l);
 #define DELEXECCT(l) if((LXAV0(l)[SYMLEXECCT]&=~EXECCTNOTDELD)==0)locdestroy(l);
 #endif
+#define INCREXECCTIF(l) {if(unlikely(!(LXAV0(l)[SYMLEXECCT]&EXECCTPERM)))INCREXECCT(l)}
+#define DECREXECCTIF(l) {if(unlikely(!(LXAV0(l)[SYMLEXECCT]&EXECCTPERM)))DECREXECCT(l)}
+#define DELEXECCTIF(l) {if(likely(!(LXAV0(l)[SYMLEXECCT]&EXECCTPERM)))DELEXECCT(l)}
 
 typedef struct {
  A name;  // name on lhs of assignment; in LINFO, pointer to NM block.  May be 0 in zombie values (modified cached values)

jsrc/px.c

@@ -32,9 +32,9 @@ DF1(jtexec1){A z;
  if(AT(w)&NAME){z=nameref(w,jt->locsyms);  // the case ".@'name' which is the fastest way to refer to a deferred name
  }else{
   F1RANK(1,jtexec1,self);
-  A savself = jt->parserstackframe.sf;  // in case we are in a recursion, preserve the restart point
+// obsolete   A savself = jt->parserstackframe.sf;  // in case we are in a recursion, preserve the restart point
   STACKCHKOFL z=PARSERVALUE(parseforexec(ddtokens(vs(w),4+1+!!EXPLICITRUNNING)));  // replace DDs, but require that they be complete within the string (no jgets)
- jt->parserstackframe.sf=savself;
+// obsolete  jt->parserstackframe.sf=savself;
  }
  RETF(z&&!(AT(z)&NOUN)?mtv:z);  // if non-noun result, return empty $0
 }

jsrc/sc.c

@@ -223,23 +223,23 @@ DF2(jtunquote){A z;
 exitpop: ;
  // LSB of z is set in the return iff what we just called was cocurrent
  // jt->global here is always the same as before the call
- if(unlikely(((C)(I)z|jt->uflags.bstkreqd)&1)){  // cocurrent OR return after cocurrent?
+ if(unlikely(((C)(I)z|jt->uflags.bstkreqd)&1)){  // cocurrent OR return after some earlier cocurrent?
   if((C)(I)z&1){  // was successful call to cocurrent?
    // here the name we called was cocurrent, possibly through a locative.  This is where we change jt->global in the caller
    // The incr/decrs here are on behalf of the caller of cocurrent.  We always incr the locale we move to; we decr a locale
    // only if a previous cocurrent moved to it; the first time we don't know whether it was incrd, and we leave
    // the decr to the caller of cocurrent
-   z=(A)((I)z&~1); INCREXECCT(z);  // z has the locale to switch to.  clear flag bit; indicate new execution starting in the locale we switch to
+   z=(A)((I)z&~1); INCREXECCTIF(z);  // z has the locale to switch to.  clear flag bit; indicate new execution starting in the locale we switch to
    // we temporarily started an execution for the locative (now jt->global).  We will close that below in common code
-   if(flgd0cpC&FLGLOCCHANGED)DECREXECCT(stack.global)   // if the caller's locale was moved to by cocurrent (i.e. this is the second cocurrent in the calling function), it must be replaced by z.  No DECR is performed for the FIRST cocurrent, so if that was entered by a locative
+   if(flgd0cpC&FLGLOCCHANGED)DECREXECCTIF(stack.global)   // if the caller's locale was moved to by cocurrent (i.e. this is the second+ cocurrent in the calling function), it must be replaced by z.  No DECR is performed for the FIRST cocurrent, so if that was entered by a locative
          // it will be owed a DECR.  We can't DECR the first call because it might be in execution higher in the stack and already have a delete outstanding
    SYMSETGLOBALINLOCAL(jt->locsyms,z);   // install new globals pointer into the locsyms (if any)...
    stack.global=z;  // ... and into the area we will pop from, thus storing through to the caller
    z=mtm;  // we have switched; this will be the result of cocurrent
    flgd0cpC|=FLGLOCCHANGED; // leave bstkreqd set as a flag indicating next function's caller has encountered cocurrent
-  }else if(jt->uflags.bstkreqd)DECREXECCT(jt->global)   // if we started with a locative and then had cocurrent, we must close the final change of locale
+  }else if(jt->uflags.bstkreqd)DECREXECCTIF(jt->global)   // we are returning from this function, which called cocurrent.  Close the final change of locale
  }
- jt->uflags.bstkreqd=(C)(flgd0cpC>>FLGLOCCHANGEDX);  // bstkreqd is set after the return if the CALLER OF THE EXITING ROUTINE has seen cocurrent.  This was passed into the exiting routine as FLGLOCCHANGED.  bstkreqd is set to be used either by the next call of the return from this caller
+ jt->uflags.bstkreqd=(C)(flgd0cpC>>FLGLOCCHANGEDX);  // bstkreqd is set after the return if the CALLER OF THE EXITING ROUTINE has seen cocurrent.  This was passed into the exiting routine as FLGLOCCHANGED.  bstkreqd is set to be used by either the next call or the return from this caller
  if(unlikely(flgd0cpC&FLGLOCINCRDECR))DECREXECCT(explocale)  // If we used a locative, undo its incr.  If there were cocurrents, the incr was a while back
  // ************** errors OK now
 exitfa:

jsrc/sl.c

@@ -192,7 +192,7 @@ A jtindexnl(J jt,I n) {A z=(A)IAV1(JT(jt,stnum))[n]; R z&&LOCPATH(z)?z:0; }  //
 // For k=0 or 1, we have made sure there are 2-k symbols reserved (for the assignments we make).  Not required for k=2, which is not assigned
 A jtstcreate(J jt,C k,I p,I n,C*u){A g,x,xx;L*v;
  // allocate the symbol table itself: we have to give exactly what the user asked for so that cloned tables will hash identically; but a minimum of 1 chain field so hashes can always run
- GATV0(g,SYMB,MAX(p,SYMLINFOSIZE+1),0); AFLAGORLOCAL(g,SYMB) LXAV0(g)[SYMLEXECCT]=EXECCTNOTDELD;  //  All SYMB tables are born recursive.  Init EXECCT to 'in use'
+ GATV0(g,SYMB,MAX(p,SYMLINFOSIZE+1),0); AFLAGORLOCAL(g,SYMB)  //  All SYMB tables are born recursive.
  // Allocate a symbol for the locale info, install in special hashchain 0.  Set flag;
  // (it is queried by 18!:_2)
  // The allocation clears all the hash chain bases, including the one used for SYMLINFO
@@ -216,7 +216,7 @@ A jtstcreate(J jt,C k,I p,I n,C*u){A g,x,xx;L*v;
    LOCBLOOM(g)=0;  // Init Bloom filter to 'nothing assigned'
    ACINITZAP(x); ACINIT(x,ACUC2)  // now that we know we will succeed, transfer ownership to name to the locale and stloc, one each
    AR(g)=ARNAMED;   // set rank to indicate named locale
-   LXAV0(g)[SYMLEXECCT]=EXECCTPERM;  // mark all named locales permanent
+   LXAV0(g)[SYMLEXECCT]=EXECCTPERM+EXECCTNOTDELD;  // mark all named locales permanent
    break;
   case 1:  // numbered locale - we have no lock
    AR(g)=ARINVALID;  // until the table is all filled in, it is in an invalid state and cannot be inspected when freed
@@ -233,11 +233,13 @@ A jtstcreate(J jt,C k,I p,I n,C*u){A g,x,xx;L*v;
    LOCNAME(g)=x;  // set name pointer in SYMLINFO
    ACINITZAP(x);   // now that we know we will succeed, transfer ownership to name to the locale
    AR(g)=0;   // set rank to indicate numbered locale
+   LXAV0(g)[SYMLEXECCT]=EXECCTNOTDELD;  // numbered locales are nondeleted but not permanent
    break;
   case 2:  // local symbol table - we have no lock and we don't assign
    AR(g)=ARLOCALTABLE;  // flag this as a local table so the first hashchain is not freed
    // The first hashchain is not used as a symbol pointer - it holds xy bucket info
    // Bloom filter not used for local symbol tables (the field is a chain for the stack of active defs)
+   // local symbol tables don't have execcts
    break;
  }
  R g;
@@ -316,7 +318,8 @@ A jtstfind(J jt,I n,C*u,I bucketx){
 
 
 // Bring a destroyed locale back to life as if it were newly created: clear the chains, set the default path, clear the Bloom filter
-#define REINITZOMBLOC(g) mvc((AN(g)-SYMLINFOSIZE)*sizeof(LXAV0(g)[0]),LXAV0(g)+SYMLINFOSIZE,1,MEMSET00); LOCBLOOM(g)=0; LXAV0(g)[SYMLEXECCT]=EXECCTNOTDELD; LOCPATH(g)=JT(jt,zpath);
+// this happens only if we force-deleted a permanent localce, so retore it to permanent
+#define REINITZOMBLOC(g) mvc((AN(g)-SYMLINFOSIZE)*sizeof(LXAV0(g)[0]),LXAV0(g)+SYMLINFOSIZE,1,MEMSET00); LOCBLOOM(g)=0; LXAV0(g)[SYMLEXECCT]=EXECCTPERM+EXECCTNOTDELD; LOCPATH(g)=JT(jt,zpath);
          // we should check whether the path in non0 but that would only matter if two threads created the locale simultaneously AND set a path, and the only loss would be that the path would leak
 static F2(jtloccre);
 
@@ -653,7 +656,7 @@ F1(jtsetpermanent){A g;
      /* check for redefinition (erasure) of entire symbol table. */
 
 // 18!:55 destroy locale(s) from user's point of view.  This counts as one usecount; others are in execution and in paths.  When all go to 0, delete the locale
-// if x is 271828, do the 
+// if x is 271828, do the deletion even if on a permanent locale
 F2(jtlocexmark){A g,*wv,y,z;B *zv;C*u;I i,m,n;
  if(unlikely(AT(w)&NOUN)){  // dyadic call
   I x; x=i0(a); if(jt->jerr){RESETERR; ASSERT(0,EVVALENCE)} ASSERT(x==271828,EVVALENCE)  // if not 271828, valence error
@@ -681,8 +684,8 @@ F2(jtlocexmark){A g,*wv,y,z;B *zv;C*u;I i,m,n;
   }
   if(g){I k;  // if the specified locale exists in the system...
    if(a){ASSERTSUFF(*JT(jt,zpath)!=g,EVRO,z=0; goto exitlock;) LXAV0(g)[SYMLEXECCT]=0; locdestroy(g);  // forced delete, clear execct/del ct & do it
-    // ignore the deletion if the locale is PERMANENT.  The execct is unreliable then
-   }else if(!(AC(g)&ACPERMANENT))DELEXECCT(g)  // say that the user doesn't want this locale any more.  Paths, execs, etc. still might.
+    // ignore the deletion if the locale is execct-permanent.  The execct is unreliable then
+   }else DELEXECCTIF(g)  // say that the user doesn't want this locale any more.  Paths, execs, etc. still might.
   }
  }
 exitlock:

test/glocale.ijs

@@ -231,7 +231,7 @@ f =: 0&".&.> y =: 18!:3 ''
 (i.0 0) -: (i.0) lpath <'asdf'
 (i.0 0) -: (0$a:)lpath <'asdf'
 
-18!:55 ;:'a abc asdf bc cool d first new NonExistent NonExistentLocale'
+(271828) 18!:55 ;:'a abc asdf bc cool d first new NonExistent NonExistentLocale'
 18!:55 e
 18!:55 >f
 
@@ -241,7 +241,7 @@ after =. 00 + 00
 before =. 7!:0 ''
 1: 18!:3 <'a'
 ('a';'a';'a';'a';'a';'a';'a';'a';'a';'a';'a') 18!:2 <'a'
-18!:55 <'a'
+(271828) 18!:55 <'a'
 after  =. 7!:0 ''
 64 >: after - before