interrupt calls wakeall--immediately, not post hoc; hopefully now robust even on windows where there is no EINTR

Author: moon-chilled

jsrc/ct.c

@@ -182,13 +182,13 @@ typedef struct pyxcondmutex{
  S pyxorigthread;  // thread number that is working on this pyx, or _1 if the value is available
  C errcode;  // 0 if no error, or error code
 #if PYXES
- UI4 state;//one of the below pyx states.  Monotonically increases
+ UI4 state;//one of the below pyx states
 #endif
 } PYXBLOK;
 enum{  // pyx state is low 2 bytes of state.  High 2 bytes are the wakeup sequence number
  PYXEMPTY=0, //the pyx is not filled in, and no one is waiting
- PYXWAIT=3,  //at least 1 thread is waiting, and the pyx is not filled in
- PYXFULL=1}; //the pyx is filled in.  We can OR FULL into pyx state to move to FULL state
+ PYXWAIT=3,  //at least 1 thread is waiting, and the pyx is not filled in.  We can OR WAIT into pyx state to move to WAIT state
+ PYXFULL=1}; //the pyx is filled in
 #if PYXES
 
 // Install a value/errcode into a (recursive) pyx, and broadcast to anyone waiting on it.  fa() the pyx to indicate that the thread has released the pyx
@@ -221,15 +221,15 @@ static A jtcreatepyx(J jt, I thread,D timeout){A pyx;
 // EVTIME if timeout
 A jtpyxval(J jt,A pyx){ UI4 state;PYXBLOK *blok=(PYXBLOK*)AAV0(pyx); 
  if(PYXFULL==(state=lda((US*)&blok->state)))goto done; // if pyx already full, return result
- casa((US*)&blok->state,&(US){PYXEMPTY},PYXWAIT);  // if pyx is EMPTY, move it to WAIT
+ {US dummy=0;casa(state!=PYXEMPTY?&dummy:(US*)&blok->state,&(US){PYXEMPTY},PYXWAIT);}  // if pyx is EMPTY, move it to WAIT.  Avoid excess contention on hot pyxes
  UI ns=({D mwt=blok->pyxmaxwt;mwt==inf?IMAX:(I)(mwt*1e9);}); // figure out how long to wait
  struct jtimespec end=jtmtil(ns); // get the time when we have to give up on this pyx
  I err;
- sta(&jt->futexwt,&blok->state); // make sure systemlock knows how to wake us up.  We check for system events AFTER this store, but before the wait (but wakeall has a window so it is called repeatedly anyway)
+ sta(&jt->futexwt,&blok->state); // make sure systemlock knows how to wake us up.  We check for system events AFTER this store, but before the wait
  while(1){ // repeat till state goes to FULL
-  if(lda((US*)&blok->state)==PYXFULL)break; // if pyx was filled, exit and return its value
   // The wait may time out because of a pending system action (BREAK or system lock).  If so, we accept it now...
   UI4 state=lda(&blok->state); C breakb;  // get store sequence # before we check for system event
+  if(PYXFULL==(state&0xffff))break; // if pyx was filled, exit and return its value
   if(unlikely(BETWEENC(lda(&JT(jt,systemlock)),1,2))){jtsystemlockaccept(jt,LOCKALL);}  // process systemlock and keep waiting
   // the user may be requesting a BREAK interrupt for deadlock or other slow execution
   if(unlikely((breakb=lda(&JT(jt,adbreak)[0])))!=0){err=breakb==1?EVATTN:EVBREAK;goto fail;} // JBREAK: give up on the pyx and exit
@@ -238,13 +238,12 @@ A jtpyxval(J jt,A pyx){ UI4 state;PYXBLOK *blok=(PYXBLOK*)AAV0(pyx);
    else{err=EVTIME;goto fail;}} // otherwise, timeout, fail the pyx and exit
   I wr=jfutex_waitn(&blok->state,state|PYXWAIT,ns);if(unlikely(wr>0)){err=EVFACE;goto fail;} // wait on futex.  If new event# or state has moved off of WAIT, don't wait
  } 
- sta(&jt->futexwt,0); while(lda(&JT(jt,wakeallct)))YIELD;   // wait till pending wakealls complete before we allow this block to be deleted
+ CLRFUTEXWT;   // wait till pending wakealls complete before we allow this block to be deleted
 done:  // pyx has been filled in.  jt->futexwt must be 0
  if(likely(blok->pyxvalue!=NULL))R blok->pyxvalue; // valid value, use it
  ASSERT(0,blok->errcode); // if error, return the error code
 fail:
- sta(&jt->futexwt,0); while(lda(&JT(jt,wakeallct)))YIELD;
- ASSERT(0,err);}
+ CLRFUTEXWT;ASSERT(0,err);}
 
 // ************************************* Locks **************************************
 // take a readlock on *alock.  We come here only if a writelock was requested or running.  We have incremented the readlock

jsrc/d.c

@@ -205,7 +205,6 @@ F1(jtdbstackz){A y,z;
 // explicit errors also come here, so stop here to see the point at which error was detected
 static void jtjsigstr(J jt,I e,I n,C*s){
  if(jt->jerr){jt->curname=0; R;}   // if not first error, ignore: clear error-name and continue
- if(e==EVATTN||e==EVBREAK)wakeall(jt);  // if user break, interrupt all threads that are in wait loops, so they can exit
  jt->jerr=(C)e; jt->jerr1=(C)e; if(jt->etxn<0)R;  // remember error for testing, but if the error line is frozen, don't touch it
  if(e!=EVSTOP)moveparseinfotosi(jt); jt->etxn=0;  // before we display, move error info from parse variables to si; but if STOP, it's already installed
  dhead(0,0L);  // | left-header for the error line

jsrc/io.c

@@ -33,6 +33,8 @@ jfe routines (jconsole.c):
 je routines (io.c):
  jdo(line)
 
+ jinterrupt() - signal interrupt in all threads.  Safe to call from signal handlers, and even from non-j threads, but shouldn't be called concurrently
+
  jsto(type,string) - JT(jt,smoutput)() to give jfe output
              
  jgets() - JT(jt,sminput)() callback to get jfe kb input
@@ -663,6 +665,15 @@ A _stdcall Jga(JS jjt, I t, I n, I r, I*s){A z;
  return z;
 }
 
+void _stdcall JInterrupt(JS jt){
+ SETJTJM(jt,jt,jm);
+ // increment adbreak by 1, capping at 2
+ C old=lda(jt->adbreak);
+ while(1){
+  if(old>=2)break;
+  if(casa(jt->adbreak,&old,1+old))break;}
+ wakeall(jm);}
+
 void oleoutput(JS jt, I n, char* s); /* SY_WIN32 only */
 
 #define capturesize 80000

jsrc/jconsole.c

@@ -29,9 +29,8 @@
 static int forceprmpt=0;   /* emit prompt even if isatty is false */
 static int breadline=0;    /* 0: none  1: libedit  2: linenoise */
 static int norl=0;         /* disable readline/linenoise */
-static char **adadbreak;
-static void sigint(int k){**adadbreak+=1;signal(SIGINT,sigint);}
-static void sigint2(int k){**adadbreak+=1;}
+static void sigint(int k){jeinterrupt();signal(SIGINT,sigint);}
+static void sigint2(int k){jeinterrupt();}
 static char input[30000];
 
 #if defined(ANDROID) || defined(_WIN32)
@@ -155,7 +154,7 @@ char* Jinput_stdio(char* prompt)
 		if(!(forceprmpt||_isatty(_fileno(stdin)))) return "2!:55''";
 		fputs("\n",stdout);
 		fflush(stdout);
-		**adadbreak+=1;
+		jeinterrupt();
 #else
 		/* unix eof without readline */
 		return "2!:55''";
@@ -276,7 +275,6 @@ int main(int argc, char* argv[])
 
  jt=jeload(callbacks);
  if(!jt){char m[1000]; jefail(m); fputs(m,stderr); exit(1);}
- adadbreak=(char**)jt; // first address in jt is address of breakdata
 #ifndef _WIN32
  if(2==breadline){
   struct sigaction sa;

jsrc/jeload.c

@@ -36,6 +36,7 @@
 static void* hjdll;
 static JST* jt;
 static JDoType jdo;
+static JInterruptType jinterrupt;
 static JFreeType jfree;
 static JgaType jga;
 static JGetLocaleType jgetlocale;
@@ -84,6 +85,11 @@ int jedo(char* sentence)
 	return jdo(jt,(C*)sentence);
 }
 
+void jeinterrupt()
+{
+ jinterrupt(jt);
+}
+
 A jegeta(I n, char* s){return jgeta(jt,n,(C*)s);}
 I jeseta(I n,char* name,I x,char* d){return jseta(jt,n,(C*)name,x,(C*)d);}
 void jefree(){jfree(jt);}
@@ -106,6 +112,7 @@ JST* jeload(void* callbacks)
  if(!jt) return 0;
  ((JSMType)GETPROCADDRESS(hjdll,"JSM"))(jt,callbacks);
  jdo=(JDoType)GETPROCADDRESS(hjdll,"JDo");
+ jinterrupt=(JInterruptType)GETPROCADDRESS(hjdll,"JInterrupt");
  jfree=(JFreeType)GETPROCADDRESS(hjdll,"JFree");
  jga=(JgaType)GETPROCADDRESS(hjdll,"Jga");
  jgetlocale=(JGetLocaleType)GETPROCADDRESS(hjdll,"JGetLocale");

jsrc/jeload.h

@@ -7,6 +7,7 @@ int jefirst(int,char*);
 A jegeta(int,char*);
 I jeseta(I n,char* name,I x,char* d);
 int jedo(char*);
+void jeinterrupt();
 void jefree();
 char* jegetlocale();
 void jefail(char*);

jsrc/jfex.c

@@ -26,15 +26,15 @@
 #include "jlib.h"
 
 static JDoType jdo;
+static JInterruptType jinterrupt;
 static JFreeType jfree;
 static JgaType jga;
 static JGetLocaleType jgetlocale;
 
 static J jt;
 static void* hjdll;
 
-static char **adadbreak;
-static void sigint(int k){**adadbreak+=1;signal(SIGINT,sigint);}
+static void sigint(int k){jinterrupt(jt);}
 static char input[1000];
 
 // J calls for input (debug suspension and 1!:1[1) and we call for input
@@ -44,7 +44,7 @@ char* _stdcall Jinput(J jt,char* prompt)
 	if(!fgets(input, sizeof(input), stdin))
 	{
 		fputs("\n",stdout);
-		**adadbreak+=1;
+		jinterrupt(jt);
 	}
 	return input;
 }
@@ -144,10 +144,10 @@ int main(int argc, char* argv[])
 	if(!jt) return 1; // JE init failed
 	((JSMType)GETPROCADDRESS(hjdll,"JSM"))(jt,callbacks);
 	jdo=(JDoType)GETPROCADDRESS(hjdll,"JDo");
+	jinterrupt=(JInterruptType)GETPROCADDRESS(hjdll,"JInterrupt");
 	jfree=(JFreeType)GETPROCADDRESS(hjdll,"JFree");
 	jga=(JgaType)GETPROCADDRESS(hjdll,"Jga");
 	jgetlocale=(JGetLocaleType)GETPROCADDRESS(hjdll,"JGetLocale");
-	adadbreak=(char**)jt; // first address in jt is address of breakdata
 	signal(SIGINT,sigint);
 	while(1){jdo(jt,Jinput(jt,"   "));}
 	jfree(jt);

jsrc/jlib.h

@@ -11,6 +11,7 @@ CDPROC JS _stdcall JInit(void);                         /* init instance */
 CDPROC void _stdcall JSM(JS jt, void*callbacks[]);  /* set callbacks */
 CDPROC void _stdcall JSMX(JS jt, void*, void*, void*, void*, I);
 CDPROC int _stdcall JDo(JS jt,C*);                  /* run sentence */
+CDPROC void _stdcall JInterrupt(JS jt);             /* signal interrupt */
 CDPROC C* _stdcall JGetLocale(JS jt);               /* get locale */
 CDPROC A _stdcall Jga(JS jt, I t, I n, I r, I*s);
 CDPROC int _stdcall JFree(JS jt);                   /* free instance */
@@ -23,6 +24,7 @@ CDPROC int _stdcall JErrorTextM(JS jt, I ec, I* p);
 
 typedef void* (_stdcall *JInitType)     ();
 typedef int   (_stdcall *JDoType)       (JS, C*);
+typedef void  (_stdcall *JInterruptType)(JS);
 typedef C*    (_stdcall *JGetLocaleType)(JS);
 typedef void  (_stdcall *JSMType)       (JS, void*);
 typedef void  (_stdcall *JSMXType)      (JS, void*, void*, void*, void*, I);

jsrc/mt.c

@@ -156,7 +156,7 @@ C jtpthread_mutex_lock(J jt,jtpthread_mutex_t *m,I self){ //lock m; self is thre
    //a couple of alternatives suggest themselves: store up to k waiters (FREE/LOCK/WAIT is really 0/1/n; we could do eg 0/1/2/3/n); store the waiter count somehow outside of the value
    // Before waiting, handle system events if present
    UI4 waitval=lda(&m->v); C breakb;  // get the serial number before we check.  Must be atomic; this is supposed to synchronise with writes to the same location via futexwt by wakeall
-   if(unlikely(BETWEENC(lda(&JT(jt,systemlock)),1,2))){jtsystemlockaccept(jt,LOCKALL);}  // if system lock requested, accept it
+   if(unlikely(BETWEENC(lda(&JT(jt,systemlock)),1,2))){jtsystemlockaccept(jt,LOCKALL);continue;}  // if system lock requested, accept it.  Then retry; a lot can happen during a systemlock, and we probably need to resample waitval anyway
    // the user may be requesting a BREAK interrupt for deadlock or other slow execution
    if(unlikely((breakb=lda(&JT(jt,adbreak)[0])))!=0){r=breakb==1?EVATTN:EVBREAK;goto fail;} // JBREAK: give up on the pyx and exit
    // Now wait for a change.  The futex_wait is atomic, and will wait only if the state is WAIT.  In that case,
@@ -170,10 +170,10 @@ C jtpthread_mutex_lock(J jt,jtpthread_mutex_t *m,I self){ //lock m; self is thre
    if(unlikely(i>0)){r=EVFACE; goto fail;} //handle error (unaligned unmapped interrupted...)
   }
   // come out of loop when we have the lock
-  clrfutexwt(jt);
+  CLRFUTEXWT;
  }
  m->ct+=m->recursive;m->owner=self;R 0;  // install ownership info, good return
-fail:clrfutexwt(jt); R r;}  // error return, with our internal errorcode
+fail:CLRFUTEXWT; R r;}  // error return, with our internal errorcode
 
 
 // return positive error code, 0 if got lock, -1 if lock timed out
@@ -185,17 +185,18 @@ I jtpthread_mutex_timedlock(J jt,jtpthread_mutex_t *m,UI ns,I self){ //lock m, w
   sta(&jt->futexwt,&m->v); //ensure other threads know how to wake us up for systemlock
   while(xchga((US*)&m->v,WAIT)!=FREE){ //exit when _we_ successfully installed WAIT in place of FREE
    UI4 waitval=lda(&m->v); C breakb;  // get the serial number before we check.  Must be atomic; this is supposed to synchronise with writes to the same location via futexwt by wakeall
-   if(unlikely(BETWEENC(lda(&JT(jt,systemlock)),1,2))){jtsystemlockaccept(jt,LOCKALL);}
+   if(unlikely(BETWEENC(lda(&JT(jt,systemlock)),1,2))){jtsystemlockaccept(jt,LOCKALL);goto retime;}
    if(unlikely((breakb=lda(&JT(jt,adbreak)[0])))!=0){r=breakb==1?EVATTN:EVBREAK;goto fail;} // JBREAK: give up on the pyx and exit
    I i=jfutex_waitn(&m->v,waitval|WAIT,ns);
    if(unlikely(i>0)){r=EVFACE; goto fail;} //handle error (unaligned unmapped interrupted...)
    if(i==-1){r=-1;goto fail;} //if the kernel says we timed out, trust it rather than doing another syscall to check the time
+retime:
    if(-1ull==(ns=jtmdif(tgt))){r=-1;goto fail;} //update delta, abort if timed out
   }
-  clrfutexwt(jt);  // remove wakeup to this thread
+  CLRFUTEXWT;  // remove wakeup to this thread
  }
  m->ct+=m->recursive;m->owner=self;R 0;  // install ownership info, good return
-fail:clrfutexwt(jt); R r;}  // error return, with our internal errorcode or -1 if timeout
+fail:CLRFUTEXWT; R r;}  // error return, with our internal errorcode or -1 if timeout
 
 I jtpthread_mutex_trylock(jtpthread_mutex_t *m,I self){ //attempt to acquire m
  if(casa((US*)&m->v,&(US){FREE},LOCK)){m->ct+=m->recursive;m->owner=self;R 0;} //fastpath: attempt to acquire the lock; if free, take it
@@ -226,6 +227,6 @@ C jtjsleep(J jt,UI ns){
   if(i==-1){r=0;break;} //timed out
 retime:
   if(-1ull==(ns=jtmdif(tgt))){r=0;break;}}
- clrfutexwt(jt);
+ CLRFUTEXWT;
  R r;}
 #endif //PYXES

jsrc/mt.h

@@ -74,3 +74,6 @@ extern int __ulock_wake(uint32_t operation, void *addr, uint64_t wake_value);
 #error no futex support for your platform
 #endif //_WIN32
 #endif //PYXES
+
+// remove wakeup to this thread; if wakeup in progress, wait till it finishes
+#define CLRFUTEXWT {sta(&jt->futexwt,0); while(lda(&JT(jt,wakeallct)))YIELD;}