rubinius · Mar 20, 2016 · Mar 20, 2016 · Mar 20, 2016
diff --git a/machine/builtin/thread.cpp b/machine/builtin/thread.cpp
@@ -81,8 +81,9 @@ namespace rubinius {
   }
 
   Thread* Thread::create(STATE, Object* self, ThreadFunction function) {
-    return Thread::create(state, self,
-        state->shared().thread_nexus()->new_vm_solo(&state->shared()), function);
+    VM* vm = state->shared().thread_nexus()->new_vm(&state->shared());
+
+    return Thread::create(state, self, vm, function);
   }
 
   Thread* Thread::create(STATE, Object* self, VM* vm, ThreadFunction function) {
@@ -347,7 +348,6 @@ namespace rubinius {
     State state_obj(vm), *state = &state_obj;
 
     vm->set_current_thread();
-    state->shared().thread_nexus()->add_vm(vm);
 
     RUBINIUS_THREAD_START(
         const_cast<RBX_DTRACE_CHAR_P>(vm->name().c_str()), vm->thread_id(), 0);
@@ -388,6 +388,7 @@ namespace rubinius {
 
     utilities::logger::write("exit thread: %s", vm->name().c_str());
 
+    vm->set_call_frame(0);
     vm->become_unmanaged();
 
     if(vm->main_thread_p() || (!value && vm->thread_state()->raise_reason() == cExit)) {

diff --git a/machine/internal_threads.cpp b/machine/internal_threads.cpp
@@ -49,6 +49,7 @@ namespace rubinius {
     RUBINIUS_THREAD_STOP(
         const_cast<RBX_DTRACE_CHAR_P>(vm->name().c_str()), vm->thread_id(), 1);
 
+    vm->set_call_frame(0);
     vm->become_unmanaged();
 
     vm->set_zombie(state);

diff --git a/machine/thread_nexus.cpp b/machine/thread_nexus.cpp
@@ -32,7 +32,7 @@ namespace rubinius {
     return (vm->thread_phase() & cYielding) == cYielding;
   }
 
-  VM* ThreadNexus::new_vm_solo(SharedState* shared, const char* name) {
+  VM* ThreadNexus::new_vm(SharedState* shared, const char* name) {
     utilities::thread::SpinLock::LockGuard guard(threads_lock_);
 
     uint32_t max_id = thread_ids_;
@@ -42,26 +42,13 @@ namespace rubinius {
       rubinius::bug("exceeded maximum number of threads");
     }
 
-    return new VM(id, *shared, name);
-  }
-
-  VM* ThreadNexus::new_vm(SharedState* shared, const char* name) {
-    VM* vm = new_vm_solo(shared, name);
+    VM* vm = new VM(id, *shared, name);
 
-    add_vm(vm);
+    threads_.push_back(vm);
 
     return vm;
   }
 
-  void ThreadNexus::add_vm(VM* vm) {
-    utilities::thread::SpinLock::LockGuard guard(threads_lock_);
-
-    if(vm->tracked_p()) return;
-
-    vm->set_tracked();
-    threads_.push_back(vm);
-  }
-
   void ThreadNexus::delete_vm(VM* vm) {
     utilities::thread::SpinLock::LockGuard guard(threads_lock_);
 

diff --git a/machine/thread_nexus.hpp b/machine/thread_nexus.hpp
@@ -94,8 +94,6 @@ namespace rubinius {
     void detect_halt_deadlock(uint64_t nanoseconds, VM* vm);
 
     VM* new_vm(SharedState* shared, const char* name = NULL);
-    VM* new_vm_solo(SharedState* shared, const char* name = NULL);
-    void add_vm(VM* vm);
     void delete_vm(VM* vm);
 
     void after_fork_child(STATE);

diff --git a/machine/util/logger.cpp b/machine/util/logger.cpp
@@ -48,6 +48,9 @@ namespace rubinius {
         delete logger_;
       }
 
+      void set_label() {
+        if(logger_) logger_->set_label();
+      }
 #define LOGGER_MSG_SIZE   1024
 
       static int append_newline(char* message) {
@@ -213,6 +216,10 @@ namespace rubinius {
         closelog();
       }
 
+      void Syslog::set_label() {
+        if(logger_) logger_->set_label();
+      }
+
       // Syslog doesn't give us the ability to write a message to the log
       // independent of a priority. Bummer.
       void Syslog::write(const char* message, int size) {
@@ -242,15 +249,20 @@ namespace rubinius {
 
       ConsoleLogger::ConsoleLogger(const char* identifier)
         : Logger()
+        , identifier_(identifier)
       {
-        std::ostringstream str;
-        str << identifier << "[" << getpid() << "]";
+        set_label();
+      }
 
-        identifier_ = std::string(str.str());
+      void ConsoleLogger::set_label() {
+        std::ostringstream label;
+        label << identifier_ << "[" << getpid() << "]";
+
+        label_ = std::string(label.str());
       }
 
       void ConsoleLogger::write_log(const char* level, const char* message, int size) {
-        fprintf(stderr, "%s %s %s %s", timestamp(), identifier_.c_str(), level, message);
+        fprintf(stderr, "%s %s %s %s", timestamp(), label_.c_str(), level, message);
       }
 
 #define LOGGER_LEVEL_FATAL  "<Fatal>"
@@ -260,7 +272,7 @@ namespace rubinius {
 #define LOGGER_LEVEL_DEBUG  "<Debug>"
 
       void ConsoleLogger::write(const char* message, int size) {
-        fprintf(stderr, "%s %s %s", timestamp(), identifier_.c_str(), message);
+        fprintf(stderr, "%s %s %s", timestamp(), label_.c_str(), message);
       }
 
       void ConsoleLogger::fatal(const char* message, int size) {
@@ -293,10 +305,7 @@ namespace rubinius {
         : Logger()
         , path_(path)
       {
-        std::ostringstream label;
-        label << " [" << getpid() << "] ";
-
-        identifier_ = label.str();
+        set_label();
 
         limit_ = va_arg(varargs, long);
         archives_ = va_arg(varargs, long);
@@ -314,6 +323,13 @@ namespace rubinius {
         cleanup();
       }
 
+      void FileLogger::set_label() {
+        std::ostringstream label;
+        label << " [" << getpid() << "] ";
+
+        label_ = label.str();
+      }
+
       void FileLogger::cleanup() {
         ::close(logger_fd_);
         logger_fd_ = -1;
@@ -388,7 +404,7 @@ namespace rubinius {
 
         const char* time = timestamp();
         write_status_ = ::write(logger_fd_, time, strlen(time));
-        write_status_ = ::write(logger_fd_, identifier_.c_str(), identifier_.size());
+        write_status_ = ::write(logger_fd_, label_.c_str(), label_.size());
         if(level) {
           write_status_ = ::write(logger_fd_, level, strlen(level));
           write_status_ = ::write(logger_fd_, " ", 1);

diff --git a/machine/util/logger.hpp b/machine/util/logger.hpp
@@ -32,6 +32,7 @@ namespace rubinius {
       void info(const char* message, ...);
       void debug(const char* message, ...);
 
+      void set_label();
       void set_loglevel(logger_level level);
 
       class Logger {
@@ -51,6 +52,8 @@ namespace rubinius {
         virtual void info(const char* message, int size) = 0;
         virtual void debug(const char* message, int size) = 0;
 
+        virtual void set_label() = 0;
+
         char* timestamp();
       };
 
@@ -66,10 +69,13 @@ namespace rubinius {
         void warn(const char* message, int size);
         void info(const char* message, int size);
         void debug(const char* message, int size);
+
+        void set_label();
       };
 
       class ConsoleLogger : public Logger {
         std::string identifier_;
+        std::string label_;
 
         void write_log(const char* level, const char* message, int size);
 
@@ -83,11 +89,13 @@ namespace rubinius {
         void warn(const char* message, int size);
         void info(const char* message, int size);
         void debug(const char* message, int size);
+
+        void set_label();
       };
 
       class FileLogger : public Logger {
         std::string path_;
-        std::string identifier_;
+        std::string label_;
         int logger_fd_;
         long limit_;
         long archives_;
@@ -109,6 +117,8 @@ namespace rubinius {
         void warn(const char* message, int size);
         void info(const char* message, int size);
         void debug(const char* message, int size);
+
+        void set_label();
       };
     }
   }

diff --git a/machine/vm.cpp b/machine/vm.cpp
@@ -82,8 +82,7 @@ namespace rubinius {
     , constant_missing_reason_(vFound)
     , zombie_(false)
     , main_thread_(false)
-    , tracked_(false)
-    , thread_phase_(ThreadNexus::cManaged)
+    , thread_phase_(ThreadNexus::cUnmanaged)
     , shared(shared)
     , waiting_channel_(this, nil<Channel>())
     , interrupted_exception_(this, nil<Exception>())
@@ -111,8 +110,6 @@ namespace rubinius {
   }
 
   void VM::discard(STATE, VM* vm) {
-    vm->call_frame_ = 0;
-
     state->vm()->metrics().system.threads_destroyed++;
 
     delete vm;
@@ -288,6 +285,8 @@ namespace rubinius {
   }
 
   void VM::after_fork_child(STATE) {
+    utilities::logger::set_label();
+
     thread_nexus_->after_fork_child(state);
 
     interrupt_lock_.init();

diff --git a/machine/vm.hpp b/machine/vm.hpp
@@ -115,7 +115,6 @@ namespace rubinius {
     bool tooling_;
     bool allocation_tracking_;
     bool main_thread_;
-    bool tracked_;
 
     ThreadNexus::Phase thread_phase_;
 
@@ -159,14 +158,6 @@ namespace rubinius {
       return thread_phase_;
     }
 
-    void set_tracked(bool tracked = true) {
-      tracked_ = tracked;
-    }
-
-    bool tracked_p() {
-      return tracked_;
-    }
-
     ThreadNexus* thread_nexus() {
       return thread_nexus_;
     }