pyx timeout works. futexes might work on windows

moon-chilled · moon-chilled · commit 7459ffa9df8f · 2022-06-03T13:49:24.000-07:00
diff --git a/jsrc/ct.c b/jsrc/ct.c
@@ -213,26 +213,26 @@ static A jtcreatepyx(J jt, I thread,D timeout){A pyx;
 }
 
 // w is an A holding a pyx value.  Return its value when it has been resolved.  If it times out
-A jtpyxval(J jt,A pyx){ UI4 state;
- if(PYXFULL==(state=lda(&((PYXBLOK*)AAV0(pyx))->state)))goto done;
- if(state!=PYXWAIT)if(!casa(&((PYXBLOK*)AAV0(pyx))->state,&state,PYXWAIT))goto done;
- UI ns=({D mwt=((PYXBLOK*)AAV0(pyx))->pyxmaxwt;mwt==inf?IMAX:(I)(mwt*1e9);});
+A jtpyxval(J jt,A pyx){ UI4 state;PYXBLOK *blok=(PYXBLOK*)AAV0(pyx);
+ if(PYXFULL==(state=lda(&blok->state)))goto done;
+ if(state!=PYXWAIT)if(!casa(&blok->state,&state,PYXWAIT))goto done;
+ UI ns=({D mwt=blok->pyxmaxwt;mwt==inf?IMAX:(I)(mwt*1e9);});
  struct jtimespec end=jtmtil(ns); // get the time when we have to give up on this pyx
  while(1){ // repeat till defined
-  _jfutex_waitn(&((PYXBLOK*)AAV0(pyx))->state,PYXWAIT,ns);
-  if(lda(&((PYXBLOK*)AAV0(pyx))->state)==PYXFULL)break; // if pyx was filled, exit and return its value
+  I wr=jfutex_waitn(&blok->state,PYXWAIT,ns);ASSERT(wr<=0,wr);
+  if(lda(&blok->state)==PYXFULL)break; // if pyx was filled, exit and return its value
   I adbreak=lda((US*)&JT(jt,adbreak)[0]);  // break requests
   // wait till the value is defined.  We have to make one last check inside the lock to make sure the value is still unresolved
   // The wait may time out because another thread is requesting a system lock.  If so, we accept it now
   if(unlikely(adbreak>>8)!=0){jtsystemlockaccept(jt,LOCKPRISYM+LOCKPRIPATH+LOCKPRIDEBUG); continue;}  // process lock and keep waiting
-  // or, the user may be requesting a BREAK interrupt for deadlock or other slow execution.  In that case fail the pyx.  It will not be deleted until the value has been stored
-  if(unlikely(adbreak&0xff))ASSERT(0,adbreak&0xff);  // JBREAK: fail the pyx and exit
-  if(uncommon(-1==(ns=jtmdif(end)))){ //update timeout
-   if(unlikely(inf==((PYXBLOK*)AAV0(pyx))->pyxmaxwt))ns=IMAX;
+  // or, the user may be requesting a BREAK interrupt for deadlock or other slow execution
+  if(unlikely((adbreak&0xff)!=0))ASSERT(0,adbreak&0xff);  // JBREAK: give up on the pyx and exit
+  if(uncommon(-1ull==(ns=jtmdif(end)))){ //update timeout
+   if(unlikely(inf==blok->pyxmaxwt))ns=IMAX;
    else ASSERT(0,EVTIME);}}  // fail the pyx and exit
 done:
- if(likely(!!((PYXBLOK*)AAV0(pyx))->pyxvalue))R ((PYXBLOK*)AAV0(pyx))->pyxvalue; // valid value, use it
- ASSERT(0,((PYXBLOK*)AAV0(pyx))->errcode);} // if error, return the error code
+ if(likely(blok->pyxvalue!=NULL))R blok->pyxvalue; // valid value, use it
+ ASSERT(0,blok->errcode);} // if error, return the error code
 
 // ************************************* Locks **************************************
 // take a readlock on *alock.  We come here only if a writelock was requested or running.  We have incremented the readlock
diff --git a/jsrc/mt.c b/jsrc/mt.c
@@ -18,15 +18,100 @@
 
 #include"j.h"
 
+// timing shenanigans
 struct jtimespec jtmtil(UI ns){
  struct jtimespec r=jmtclk();
- r.tv_sec+=ns/1000000000;r.tv_nsec+=ns%1000000000;
- if(r.tv_nsec>=1000000000){r.tv_sec++;r.tv_nsec-=1000000000;}
+ r.tv_sec+=ns/1000000000ull;r.tv_nsec+=ns%1000000000ull;
+ if(r.tv_nsec>=1000000000ll){r.tv_sec++;r.tv_nsec-=1000000000ll;}
  R r;}
 I jtmdif(struct jtimespec w){
  struct jtimespec t=jmtclk();
  if(t.tv_sec>w.tv_sec||t.tv_sec==w.tv_sec&&t.tv_nsec>=w.tv_nsec)R -1;
- R (w.tv_sec-t.tv_sec)*1000000000+w.tv_nsec-t.tv_nsec;}
+ R (w.tv_sec-t.tv_sec)*1000000000ull+w.tv_nsec-t.tv_nsec;}
+
+#ifdef __APPLE__
+void jfutex_wake1(UI4 *p){__ulock_wake(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,0);}
+void jfutex_wakea(UI4 *p){__ulock_wake(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO|ULF_WAKE_ALL,p,0);}
+C jfutex_wait(UI4 *p,UI4 v){
+ I r=__ulock_wait(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,v,0);
+ if(r>=0)R 0;
+ if(r==-EINTR||r==-EFAULT)R 0; //EFAULT means the address needed to be paged in, not that it wasn't mapped?
+ R EVFACE;} //should never happen?
+#if __arm64__
+// wait2 takes an ns timeout, but it's only available from macos 11 onward; coincidentally, arm macs only support macos 11+
+// so we can count on having this
+I jfutex_waitn(UI4 *p,UI4 v,UI ns){
+ I r=R __ulock_wait2(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,v,ns,0);
+ if(r>=0)R 0;
+ if(r==-ETIMEDOUT)R -1;
+ if(r==-EINTR||r==-EFAULT)R 0;
+ if(r==-ENOMEM)R EVWSFULL;//lol
+ R EVFACE;}
+#else
+// but for the x86 case, we keep compatibility with older macos.  Revisit in the future
+// deal with >32 bits; 2^32us is just a little over an hour; just too close for comfort
+I jfutex_waitn(UI4 *p,UI4 v,UI ns){I r;
+ UI us=ns/1000;
+ while(us>0xfffffff){
+  r=__ulock_wait2(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,v,0xffffffff,0);
+  if(r!=-ETIMEDOUT)goto out;
+  us-=0xffffffff;}
+ r=__ulock_wait2(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,v,us,0);
+out:
+ if(r>=0)R 0;
+ if(r==-ETIMEDOUT)R -1;
+ if(r==-EINTR||r==-EFAULT)R 0;
+ if(r==-ENOMEM)R EVWSFULL;
+ R EVFACE;}
+#endif
+#elif defined(__linux__)
+//glibc 'syscall': stupid errno
+void jfutex_wake1(UI4 *p){
+ __asm__ volatile("syscall" :: "a" (SYS_futex), //eax: syscall#
+                               "D" (p), //rdi: ptr
+                               "S" (FUTEX_WAKE), //rsi: op
+                               "d" (1));} //rdx: count
+void jfutex_wakea(UI4 *p){
+ __asm__ volatile("syscall" :: "a" (SYS_futex), //eax: syscall#
+                               "D" (p), //rdi: ptr
+                               "S" (FUTEX_WAKE), //rsi: op
+                               "d" (0xffffffff));} //rdx: count
+C jfutex_wait(UI4 *p,UI4 v){
+ register struct timespec *pts asm("r10") = 0;
+ int r;__asm__ volatile("syscall" : "=a"(r) //result in rax
+                                  : "a" (SYS_futex), //eax: syscall#
+                                    "D" (p), //rdi: ptr
+                                    "S" (FUTEX_WAIT), //rsi: op
+                                    "d" (v), //rdx: espected
+                                    "r" (pts)); //r10: timeout (null=no timeout)
+ if(r>=0)R 0;
+ if(r==-EAGAIN||r==-EINTR)R 0;
+ R EVFACE;}
+I jfutex_waitn(UI4 *p,UI4 v,UI ns){
+ struct timespec ts={.tv_sec=ns/1000000000ull, .tv_nsec=ns%1000000000ull};
+ register struct timespec *pts asm("r10") = &ts;
+ int r;__asm__ volatile("syscall" : "=a"(r) //result in rax
+                                  : "a" (SYS_futex), //eax: syscall#
+                                    "D" (p), //rdi: ptr
+                                    "S" (FUTEX_WAIT), //rsi: op
+                                    "d" (v), //rdx: espected
+                                    "r" (pts)); //r10: timeout (relative!)
+ if(r>=0)R 0;
+ if(r==-ETIMEDOUT)R -1;
+ if(r==-EAGAIN||r==-EINTR)R 0;
+ R EVFACE;}
+#elif defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+void jfutex_wake1(UI4 *p){WakeByAddressSingle(p);}
+void jfutex_wakea(UI4 *p){WakeByAddressAll(p);}
+C jfutex_wait(UI4 *p,UI4 v){R WaitOnAddress(p,&v,4,INFINITE)?0:EVFACE;}
+I jfutex_waitn(UI4 *p,UI4 v,UI ns){
+ if(WaitOnAddress(p,&v,4,ns/1000000))R 0;
+ if(GetLastError()==ERROR_TIMEOUT)R -1;
+ //is there EINTR on windows?  Does it manifest as a spurious wake with no error?
+ R EVFACE;}
+#endif
 
 #if defined(__APPLE__) || defined(__linux__)
 enum{FREE=0,LOCK=1,WAIT=2};//values for mutex->v
@@ -45,17 +130,14 @@ C jtpthread_mutex_lock(J jt,jtpthread_mutex_t *m,I self){
  UI4 e;if(likely((!(e=lda(&m->v)))&&((e=FREE),casa(&m->v,&e,LOCK))))goto success; //fast path.  test-and-test-and-set is from glibc, mildly optimises the case when many threads swarm a locked mutex.  Not sure if this is for the best, but after waffling for a bit I think it is
  if(e!=WAIT)e=xchga(&m->v,WAIT); //penalise the multi-waiters case, since it's slower anyway
  while(e!=FREE){
+  if(JT(jt,adbreakr)[0])R EVATTN;
 #if __linux__
-  I i=_jfutex_waitn(&m->v,WAIT,(UI)-1);
+  I i=jfutex_waitn(&m->v,WAIT,(UI)-1);
   //bug? futex wait doesn't get interrupted by signals on linux if timeout is null
 #else
   I i=jfutex_wait(&m->v,WAIT);
 #endif
-  if(uncommon(i<0)){
-   if(i==-EINTR){if(JT(jt,adbreakr)[0])R EVATTN;}
-   else if(i==-EOWNERDEAD)R EVCONCURRENCY;
-   else if(i==-ENOMEM)R EVWSFULL;//lol
-   else R EVFACE;}
+  if(i>0)R i;
   e=xchga(&m->v,WAIT);} //exit when e==FREE; i.e., _we_ successfully installed WAIT in place of FREE
 success:m->ct+=m->recursive;m->owner=self;  R 0;}
 I jtpthread_mutex_timedlock(J jt,jtpthread_mutex_t *m,UI ns,I self){
@@ -64,17 +146,13 @@ I jtpthread_mutex_timedlock(J jt,jtpthread_mutex_t *m,UI ns,I self){
  struct timespec tgt=jtmtil(ns);
  if(common(e!=WAIT)){e=xchga(&m->v,WAIT);if(e==FREE)goto success;} //penalise the multi-waiters case, since it's slower anyway
  while(1){
-  I i=_jfutex_waitn(&m->v,WAIT,ns);
-  if(uncommon(i==-ETIMEDOUT)); //don't penalise this case too harshly
-  else if(unlikely(i<0)){
-   if(i==-EINTR){if(JT(jt,adbreakr)[0])R EVATTN;}
-   else if(i==-EOWNERDEAD)R EVCONCURRENCY;
-   else if(i==-ENOMEM)R EVWSFULL;
-   else R EVFACE;}
+  if(JT(jt,adbreakr)[0])R EVATTN;
+  I i=jfutex_waitn(&m->v,WAIT,ns);
+  if(unlikely(i>0))R i;
   e=xchga(&m->v,WAIT);
   if(e==FREE)goto success; //exit when e==FREE; i.e., _we_ successfully installed WAIT in place of FREE
-  if(i==-ETIMEDOUT)R -1; //if the kernel says we timed out, trust it rather than doing another syscall to check the time
-  if(-1==(ns=jtmdif(tgt)))R -1;} //update delta, abort if timed out
+  if(i==-1)R -1; //if the kernel says we timed out, trust it rather than doing another syscall to check the time
+  if(-1ull==(ns=jtmdif(tgt)))R -1;} //update delta, abort if timed out
 success:m->ct+=m->recursive;m->owner=self; R 0;}
 I jtpthread_mutex_trylock(jtpthread_mutex_t *m,I self){
  if(uncommon(m->recursive)&&m->owner){if(m->owner!=self)R -1; m->ct++;R 0;}
@@ -87,6 +165,7 @@ C jtpthread_mutex_unlock(jtpthread_mutex_t *m,I self){
  if(!casa(&m->v,&(UI4){LOCK},FREE)){sta(&m->v,FREE);jfutex_wake1(&m->v);}
  //below is what drepper does; I think the above is always faster, but it should definitely be faster without xadd
  //agner sez lock xadd has one cycle better latency vs lock cmpxchg on intel ... ??
+ //(probably that's only in the uncontended case)
  //if(adda(&m->v,-1)){sta(&m->v,FREE);jfutex_wake1(&m->v);}
  R 0;}
 #endif //__APPLE__
diff --git a/jsrc/mt.h b/jsrc/mt.h
@@ -6,6 +6,11 @@ struct jtimespec jtmtil(UI ns); //returns a time ns ns in the future
 I jtmdif(struct jtimespec when); //returns the time in ns between now and when.  If when is not in the future, the result will be -1
 //both of these are implemented in terms of mtclk and use its clock
 
+__attribute__((cold)) C jfutex_wait(UI4 *p,UI4 v); //atomically, compare v to *p and go to sleep if they are equal.  Return error code
+__attribute__((cold)) I jfutex_waitn(UI4 *p,UI4 v,UI ns); //ditto, but wake up after at most ns ns.  Result -1 means timeout definitely exceeded; other result is an error code
+__attribute__((cold)) void jfutex_wake1(UI4 *p); //wake 1 thread waiting on p
+__attribute__((cold)) void jfutex_wakea(UI4 *p); //wake all threads waiting on p
+
 #if !defined(__APPLE__) && !defined(__linux__)
 #include <pthread.h>
 typedef pthread_mutex_t jtpthread_mutex_t;
@@ -65,36 +70,6 @@ C jtpthread_mutex_unlock(jtpthread_mutex_t*,I self); //0 or error code
 #if defined(__linux__)
 #include <linux/futex.h>
 #include <sys/syscall.h>
-//glibc 'syscall': stupid errno
-static inline void jfutex_wake1(UI4 *p){
- __asm__ volatile("syscall" :: "a" (SYS_futex), //eax: syscall#
-                               "D" (p), //rdi: ptr
-                               "S" (FUTEX_WAKE), //rsi: op
-                               "d" (1));} //rdx: count
-static inline void jfutex_wakea(UI4 *p){
- __asm__ volatile("syscall" :: "a" (SYS_futex), //eax: syscall#
-                               "D" (p), //rdi: ptr
-                               "S" (FUTEX_WAKE), //rsi: op
-                               "d" (0xffffffff));} //rdx: count
-static inline int jfutex_wait(UI4 *p,UI4 v){
- register struct timespec *pts asm("r10") = 0;
- int r;__asm__ volatile("syscall" : "=a"(r) //result in rax
-                                  : "a" (SYS_futex), //eax: syscall#
-                                    "D" (p), //rdi: ptr
-                                    "S" (FUTEX_WAIT), //rsi: op
-                                    "d" (v), //rdx: espected
-                                    "r" (pts)); //r10: timeout (null=no timeout)
- R r;}
-static inline int _jfutex_waitn(UI4 *p,UI4 v,UI ns){
- struct timespec ts={.tv_sec=ns/1000000000, .tv_nsec=ns%1000000000};
- register struct timespec *pts asm("r10") = &ts;
- int r;__asm__ volatile("syscall" : "=a"(r) //result in rax
-                                  : "a" (SYS_futex), //eax: syscall#
-                                    "D" (p), //rdi: ptr
-                                    "S" (FUTEX_WAIT), //rsi: op
-                                    "d" (v), //rdx: espected
-                                    "r" (pts)); //r10: timeout (relative!)
- R r;}
 #elif defined(__APPLE__)
 // ulock (~futex) junk from xnu.  timeout=0 means wait forever
 extern int __ulock_wait(uint32_t operation, void *addr, uint64_t value, uint32_t timeout);             // timeout in us
@@ -128,32 +103,9 @@ extern int __ulock_wake(uint32_t operation, void *addr, uint64_t wake_value);
 
 //positive (or just 1?) result from wait means someone else is waiting on this too?
 
-static inline void jfutex_wake1(UI4 *p){__ulock_wake(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,0);}
-static inline void jfutex_wakea(UI4 *p){__ulock_wake(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO|ULF_WAKE_ALL,p,0);}
-static inline int jfutex_wait(UI4 *p,UI4 v){R __ulock_wait(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,v,0);}
-#if __arm64__
-// wait2 takes an ns timeout, but it's only available from macos 11 onward; coincidentally, arm macs only support macos 11+
-// so we can count on having this
-static inline int _jfutex_waitn(UI4 *p,UI4 v,UI ns){R __ulock_wait2(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,v,ns,0);}
-#else
-// but for the x86 case, we keep compatibility with older macos.  Revisit in the future
-// deal with >32 bits; 2^32us is just a little over an hour; just too close for comfort
-static inline int _jfutex_waitn(UI4 *p,UI4 v,UI ns){
- UI us=ns/1000;
- while(us>0xfffffff){
-  I4 r=__ulock_wait2(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,v,0xffffffff,0);
-  if(r!=-ETIMEDOUT)R r;
-  us-=0xffffffff;}
- R __ulock_wait2(UL_COMPARE_AND_WAIT|ULF_NO_ERRNO,p,v,us,0);}
-#endif
 #elif defined(_WIN32)
 // untested windows path; make henry test it when he gets back from vacation
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-static inline int jfutex_wait(UI4 *p,UI4 v){R WaitOnAddress(p,&v,4,INFINITE);} //todo return wrong
-static inline int _jfutex_waitn(UI4 *p,UI4 v,UI ns){R WaitOnAddress(p,&v,4,ns/1000000);} //ditto
-static inline void jfutex_wake1(UI4 *p){WakeByAddressSingle(p);}
-static inline void jfutex_wakea(UI4 *p){WakeByAddressAll(p);}
+// don't pollute everybody with windows.h.  win api is fairly basic anyway, so there is not much to take advantage of
 #endif //_WIN32
 #endif //__APPLE__ || __linux__
 #endif //PYXES
