code review 5334051: runtime: add timer support, use for package time

src/pkg/runtime/openbsd/thread.c

 // Use of this source file is governed by a BSD-style
 // license that can be found in the LICENSE file.`
 
 #include "runtime.h"
 #include "defs.h"
 #include "os.h"
 #include "stack.h"
 
 enum
 {
         MUTEX_UNLOCKED = 0,
         MUTEX_LOCKED = 1,
         MUTEX_SLEEPING = 2,
 
         ACTIVE_SPIN = 4,
         ACTIVE_SPIN_CNT = 30,
         PASSIVE_SPIN = 1,
 
         ESRCH = 3,
         ENOTSUP = 91,
+
+        // From OpenBSD's sys/time.h
+        CLOCK_REALTIME = 0,
+        CLOCK_VIRTUAL = 1,
+        CLOCK_PROF = 2,
+        CLOCK_MONOTONIC = 3
 };
 
 extern SigTab runtime·sigtab[];
 
 extern int64 runtime·rfork_thread(int32 flags, void *stack, M *m, G *g, void (*fn)(void));
-extern int32 runtime·thrsleep(void *, void *, void*, void *);
-extern int32 runtime·thrwakeup(void *, int32);
+extern int32 runtime·thrsleep(void *ident, int32 clock_id, void *tsp, void *lock);
+extern int32 runtime·thrwakeup(void *ident, int32 n);
 
 // From OpenBSD's <sys/sysctl.h>
 #define CTL_HW  6
 #define HW_NCPU 3
 
 static int32
 getncpu(void)
 {
         uint32 mib[2];
         uint32 out;
@@ skipping 11 matching lines @@
         else
                 return 1;
 }
 
 uintptr
 runtime·semacreate(void)
 {
         return 1;
 }
 
-void
+int32
 runtime·semasleep(int64 ns)
 {
-XXX ns
-retry:
+        Timespec ts;
+
         // spin-mutex lock
         while(runtime·xchg(&m->waitsemalock, 1))
                 runtime·osyield();
-        if(m->waitsemacount == 0) {
-                // the function unlocks the spinlock
-                runtime·thrsleep(&m->waitsemacount, 0, 0, &m->waitsemalock);
-                goto retry;
-        }
-        m->waitsemacount--;
+
+        for(;;) {
+                // lock held
+                if(m->waitsemacount == 0) {
+                        // sleep until semaphore != 0 or timeout.
+                        // thrsleep unlocks m->waitsemalock.
+                        if(ns < 0)
+                                runtime·thrsleep(&m->waitsemacount, 0, nil, &m->waitsemalock);
+                        else {
+                                ts.tv_sec = ns/1000000000LL;
+                                ts.tv_nsec = ns%1000000000LL;
+                                runtime·thrsleep(&m->waitsemacount, CLOCK_REALTIME, &ts, &m->waitsemalock);
+                        }
+                        // reacquire lock
+                        while(runtime·xchg(&m->waitsemalock, 1))
+                                runtime·osyield();
+                }
+
+                // lock held (again)
+                if(m->waitsemacount != 0) {
+                        // semaphore is available.
+                        m->waitsemacount--;
+                        // spin-mutex unlock
+                        runtime·atomicstore(&m->waitsemalock, 0);
+                        return 0;  // semaphore acquired
+                }
+
+                // semaphore not available.
+                // if there is a timeout, stop now.
+                // otherwise keep trying.
+                if(ns >= 0)
+                        break;
+        }
+
+        // lock held but giving up
         // spin-mutex unlock
         runtime·atomicstore(&m->waitsemalock, 0);
+        return -1;
 }
 
 void
 runtime·semawakeup(M *mp)
 {
         uint32 ret;
 
         // spin-mutex lock
         while(runtime·xchg(&mp->waitsemalock, 1))
                 runtime·osyield();
@@ skipping 74 matching lines @@
                 switch(g->sigcode0) {
                 case FPE_INTDIV:
                         runtime·panicstring("integer divide by zero");
                 case FPE_INTOVF:
                         runtime·panicstring("integer overflow");
                 }
                 runtime·panicstring("floating point error");
         }
         runtime·panicstring(runtime·sigtab[g->sig].name);
 }