rubinius · Jun 22, 2015
diff --git a/‎vm/builtin/channel.cpp
-8 b/‎vm/builtin/channel.cpp
-8
diff --git a/‎vm/builtin/compiled_code.cpp
-4 b/‎vm/builtin/compiled_code.cpp
-4
diff --git a/‎vm/gc/managed.cpp
+1-2 b/‎vm/gc/managed.cpp
+1-2
diff --git a/‎vm/gc/managed.hpp
+1-2 b/‎vm/gc/managed.hpp
+1-2
diff --git a/‎vm/global_cache.hpp
+2-4 b/‎vm/global_cache.hpp
+2-4
diff --git a/‎vm/internal_threads.hpp
-2 b/‎vm/internal_threads.hpp
-2
diff --git a/‎vm/lock.cpp
-22 b/‎vm/lock.cpp
-22
diff --git a/‎vm/lock.hpp
-240 b/‎vm/lock.hpp
-240
@@ -133,20 +133,12 @@ namespace rubinius {
       ts.tv_nsec  = nano % NANOSECONDS;
     }
 
-    // We lock to manipulate the wait condition on the VM* so that
-    // we can sync up properly with another thread trying to wake us
-    // up right as we're trying to go to sleep.
-    state->lock(gct, call_frame);
-
     if(!state->check_async(call_frame)) {
-      state->unlock();
       return NULL;
     }
 
     state->vm()->wait_on_channel(self);
 
-    state->unlock();
-
     self->waiters_++;
 
     bool exception = false;
 
@@ -204,8 +204,6 @@ namespace rubinius {
   Object* CompiledCode::default_executor(STATE, CallFrame* call_frame,
                           Executable* exec, Module* mod, Arguments& args)
   {
-    LockableScopedLock lg(state, &state->shared(), __FILE__, __LINE__);
-
     CompiledCode* code = as<CompiledCode>(exec);
     if(code->execute == default_executor) {
       const char* reason = 0;
@@ -223,8 +221,6 @@ namespace rubinius {
       }
     }
 
-    lg.unlock();
-
     return code->execute(state, call_frame, exec, mod, args);
   }
 
 
@@ -12,8 +12,7 @@ namespace rubinius {
 
   ManagedThread::ManagedThread(uint32_t id, SharedState& ss,
       ManagedThread::Kind kind, const char* name)
-    : Lockable(true)
-    , shared_(ss)
+    : shared_(ss)
     , run_state_(eIndependent)
     , kind_(kind)
     , os_thread_(pthread_self())
 
@@ -5,7 +5,6 @@
 #include "gc/variable_buffer.hpp"
 #include "gc/root_buffer.hpp"
 #include "gc/root.hpp"
-#include "lock.hpp"
 #include "metrics.hpp"
 
 #include <algorithm>
@@ -19,7 +18,7 @@ namespace rubinius {
 
   typedef std::vector<ObjectHeader*> LockedObjects;
 
-  class ManagedThread : public Lockable {
+  class ManagedThread {
   public:
     // WorldState sets the run_state_ directly.
     friend class WorldState;
 
@@ -18,7 +18,7 @@ namespace rubinius {
 
   typedef std_unordered_set<native_int> SeenMethodSet;
 
-  class GlobalCache : public Lockable {
+  class GlobalCache {
   public:
     struct CacheEntry {
       Module* klass;
@@ -44,9 +44,7 @@ namespace rubinius {
     static bool resolve(STATE, Symbol* name, Dispatch& msg, LookupData& lookup);
     bool resolve_i(STATE, Symbol* name, Dispatch& msg, LookupData& lookup);
 
-    GlobalCache()
-      : Lockable(true)
-    {
+    GlobalCache() {
       reset();
     }
 
 
@@ -1,8 +1,6 @@
 #ifndef RBX_AUXILIARY_THREADS_H
 #define RBX_AUXILIARY_THREADS_H
 
-#include "lock.hpp"
-
 #include "util/thread.hpp"
 
 #include <string>
Original file line number	Diff line number	Diff line change
`@@ -204,8 +204,6 @@ namespace rubinius {`
`204`	`204`	`Object* CompiledCode::default_executor(STATE, CallFrame* call_frame,`
`205`	`205`	`Executable* exec, Module* mod, Arguments& args)`
`206`	`206`	`{`
`207`		`- LockableScopedLock lg(state, &state->shared(), __FILE__, __LINE__);`
`208`		`-`
`209`	`207`	`CompiledCode* code = as<CompiledCode>(exec);`
`210`	`208`	`if(code->execute == default_executor) {`
`211`	`209`	`const char* reason = 0;`
`@@ -223,8 +221,6 @@ namespace rubinius {`
`223`	`221`	`}`
`224`	`222`	`}`
`225`	`223`
`226`		`- lg.unlock();`
`227`		`-`
`228`	`224`	`return code->execute(state, call_frame, exec, mod, args);`
`229`	`225`	`}`
`230`	`226`