thread_yield() possible to return error_number obtained from thread_i…

…nterrupt()

common/lockfree_queue.h

@@ -80,7 +80,7 @@ struct ThreadPause : PauseBase {
 };
 
 namespace photon {
-void thread_yield();
+int thread_yield();
 }
 struct PhotonPause : PauseBase {
     inline static __attribute__((always_inline)) void pause() {

thread/thread.cpp

@@ -1167,41 +1167,44 @@ R"(
         return (states) th->state;
     }
 
-    void thread_yield()
+    int thread_yield()
     {
-        assert(!AtomicRunQ().single());
-        auto sw = AtomicRunQ().goto_next();
+        RunQ rq;
         if_update_now();
+        rq.current->error_number = 0;
+        auto sw = AtomicRunQ(rq).goto_next();
         switch_context(sw.from, sw.to);
+        return rq.current->error_number;
     }
 
-    void thread_yield_fast() {
-        assert(!AtomicRunQ().single());
+    static void thread_yield_fast() {
         auto sw = AtomicRunQ().goto_next();
         switch_context(sw.from, sw.to);
     }
 
-    void thread_yield_to(thread* th) {
+    int thread_yield_to(thread* th) {
         if (unlikely(th == nullptr)) { // yield to any thread
             return thread_yield();
         }
         RunQ rq;
         if (unlikely(th == rq.current)) { // yield to current should just update time
             if_update_now();
-            return;
+            return 0;
         } else if (unlikely(th->vcpu != rq.current->vcpu)) {
-            LOG_ERROR_RETURN(EINVAL, , "target thread ` must be run by the same vcpu as CURRENT!", th);
+            LOG_ERROR_RETURN(EINVAL, -1, "target thread ` must be run by the same vcpu as CURRENT!", th);
         } else if (unlikely(th->state == states::STANDBY)) {
             while (th->state == states::STANDBY)
                 resume_threads();
             assert(th->state == states::READY);
         } else if (unlikely(th->state != states::READY)) {
-            LOG_ERROR_RETURN(EINVAL, , "target thread ` must be READY!", th);
+            LOG_ERROR_RETURN(EINVAL, -1, "target thread ` must be READY!", th);
         }
 
         auto sw = AtomicRunQ(rq).try_goto(th);
         if_update_now();
+        rq.current->error_number = 0;
         switch_context(sw.from, sw.to);
+        return rq.current->error_number;
     }
 
     __attribute__((always_inline)) inline
@@ -1220,13 +1223,16 @@ R"(
         sw.from->get_vcpu()->sleepq.push(sw.from);
         return sw;
     }
-
+    inline int yield_as_sleep() {
+        int ret = thread_yield();
+        if (unlikely(ret)) { errno = ret; return -1; }
+        return 0;
+    }
     // returns 0 if slept well (at lease `useconds`), -1 otherwise
     static int thread_usleep(uint64_t useconds, thread_list* waitq)
     {
         if (unlikely(useconds == 0)) {
-            thread_yield();
-            return 0;
+            return yield_as_sleep();
         }
 
         auto r = prepare_usleep(useconds, waitq);
@@ -1298,7 +1304,7 @@ R"(
         if (unlikely(!rq.current))
             LOG_ERROR_RETURN(ENOSYS, -1, "Photon not initialized in this thread");
         if (unlikely(!useconds))
-            return thread_yield(), 0;
+            return yield_as_sleep();
         if (unlikely(rq.current->is_shutting_down()))
             return do_shutdown_usleep(useconds, rq);
         return do_thread_usleep(useconds, rq);
@@ -1325,9 +1331,14 @@ R"(
     {
         if (unlikely(!th))
             LOG_ERROR_RETURN(EINVAL, , "invalid parameter");
-        if (unlikely(th->state != states::SLEEPING)) return;
+        if (unlikely(th->state != states::SLEEPING)) {
+        out: // may have thread_yield()-ed
+            if (th->state != states::READY || th->error_number == 0)
+                th->error_number = error_number;
+            return;
+        }
         SCOPED_LOCK(th->lock);
-        if (unlikely(th->state != states::SLEEPING)) return;
+        if (unlikely(th->state != states::SLEEPING)) goto out;
 
         prelocked_thread_interrupt(th, error_number);
     }
@@ -1558,7 +1569,11 @@ R"(
         for (int tries = 0; tries < MaxTries; ++tries) {
             if (try_lock() == 0)
                 return 0;
-            thread_yield();
+            int ret = thread_yield();
+            if (unlikely(ret)) {
+                errno = ret;
+                return -1;
+            }
         }
         splock.lock();
         if (try_lock() == 0) {

thread/thread.h

@@ -68,10 +68,12 @@ namespace photon
     void thread_join(join_handle* jh);
 
     // switching to other threads (without going into sleep queue)
-    void thread_yield();
+    // return error_number if interrupted during the rolling
+    int thread_yield();
 
     // switching to a specific thread, which must be RUNNING
-    void thread_yield_to(thread* th);
+    // return error_number if interrupted during the rolling
+    int thread_yield_to(thread* th);
 
     // suspend CURRENT thread for specified time duration, and switch
     // control to other threads, resuming possible sleepers.