Defer to Immix marker at checkpoints.

brixen · brixen · commit d265ed9b5f18 · 2015-12-30T21:56:51.000-08:00
diff --git a/vm/gc/immix_marker.cpp b/vm/gc/immix_marker.cpp
@@ -82,15 +82,18 @@ namespace rubinius {
           timer::StopWatch<timer::milliseconds> timer(
               state->vm()->metrics().gc.immix_concurrent_ms);
 
-          // TODO: Set status of this thread so STW won't consider it a
-          // possible deadlock when the thread doesn't yield soon enough.
+          state->shared().thread_nexus()->blocking(state->vm());
+
           while(immix_->process_mark_stack(immix_->memory()->collect_mature_now)) {
             if(state->shared().thread_nexus()->stop_p()) {
               state->shared().thread_nexus()->yielding(state->vm());
             }
+            state->shared().thread_nexus()->blocking(state->vm());
           }
         }
 
+        state->vm()->become_managed();
+
         if(thread_exit_) break;
 
         {
diff --git a/vm/thread_nexus.cpp b/vm/thread_nexus.cpp
@@ -13,6 +13,10 @@
 #include <time.h>
 
 namespace rubinius {
+  bool ThreadNexus::blocking_p(VM* vm) {
+    return (vm->thread_phase() & cBlocking) == cBlocking;
+  }
+
   bool ThreadNexus::yielding_p(VM* vm) {
     return (vm->thread_phase() & cYielding) == cYielding;
   }
@@ -97,6 +101,8 @@ namespace rubinius {
         return "cWaiting";
       case ThreadNexus::cYielding:
         return "cYielding";
+      case ThreadNexus::cBlocking:
+        return "cBlocking";
     }
   }
 
@@ -117,6 +123,10 @@ namespace rubinius {
     rubinius::abort();
   }
 
+  void ThreadNexus::blocking(VM* vm) {
+    vm->set_thread_phase(cBlocking);
+  }
+
 #define RBX_MAX_STOP_ITERATIONS 10000
 
   bool ThreadNexus::locking(VM* vm) {
@@ -137,6 +147,8 @@ namespace rubinius {
             if(yielding_p(other_vm)) {
               yielding = true;
               break;
+            } else if(blocking_p(other_vm)) {
+              return false;
             }
 
             static int delay[] = { 1, 21, 270, 482, 268, 169, 224, 481,
diff --git a/vm/thread_nexus.hpp b/vm/thread_nexus.hpp
@@ -32,6 +32,7 @@ namespace rubinius {
     enum Phase {
       cStop       = 0x01,
       cManaged    = 0x02,
+      cBlocking   = 0x04,
       cUnmanaged  = 0x81,
       cWaiting    = 0x82,
       cYielding   = 0x80
@@ -70,6 +71,8 @@ namespace rubinius {
       lock_.unlock();
     }
 
+    bool blocking_p(VM* vm);
+    void blocking(VM* vm);
     bool yielding_p(VM* vm);
     void yielding(VM* vm);
     bool locking(VM* vm);
diff --git a/vm/util/immix.hpp b/vm/util/immix.hpp
@@ -1097,7 +1097,7 @@ namespace immix {
         desc.walk_pointers(addr, mark);
       }
 
-      return true;
+      return !exit;
     }
 
     /**

Original file line number	Diff line number	Diff line change
`@@ -82,15 +82,18 @@ namespace rubinius {`
`82`	`82`	`timer::StopWatch<timer::milliseconds> timer(`
`83`	`83`	`state->vm()->metrics().gc.immix_concurrent_ms);`
`84`	`84`
`85`		`- // TODO: Set status of this thread so STW won't consider it a`
`86`		`- // possible deadlock when the thread doesn't yield soon enough.`
	`85`	`+ state->shared().thread_nexus()->blocking(state->vm());`
	`86`	`+`
`87`	`87`	`while(immix_->process_mark_stack(immix_->memory()->collect_mature_now)) {`
`88`	`88`	`if(state->shared().thread_nexus()->stop_p()) {`
`89`	`89`	`state->shared().thread_nexus()->yielding(state->vm());`
`90`	`90`	`}`
	`91`	`+ state->shared().thread_nexus()->blocking(state->vm());`
`91`	`92`	`}`
`92`	`93`	`}`
`93`	`94`
	`95`	`+ state->vm()->become_managed();`
	`96`	`+`
`94`	`97`	`if(thread_exit_) break;`
`95`	`98`
`96`	`99`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1097,7 +1097,7 @@ namespace immix {`
`1097`	`1097`	`desc.walk_pointers(addr, mark);`
`1098`	`1098`	`}`
`1099`	`1099`
`1100`		`- return true;`
	`1100`	`+ return !exit;`
`1101`	`1101`	`}`
`1102`	`1102`
`1103`	`1103`	`/**`