Renamed Handlers to Threads.

vm/builtin/system.cpp

@@ -1012,13 +1012,13 @@ namespace rubinius {
   }
 
   Object* System::vm_watch_signal(STATE, Fixnum* sig, Object* ignored) {
-    SignalHandler* h = state->shared().signal_handler();
-    if(h) {
+    SignalThread* st = state->shared().signal_handler();
+    if(st) {
       native_int i = sig->to_native();
       if(i < 0) {
-        h->add_signal(state, -i, SignalHandler::eDefault);
+        st->add_signal(state, -i, SignalThread::eDefault);
       } else if(i > 0) {
-        h->add_signal(state, i, CBOOL(ignored) ? SignalHandler::eIgnore : SignalHandler::eCustom);
+        st->add_signal(state, i, CBOOL(ignored) ? SignalThread::eIgnore : SignalThread::eCustom);
       }
 
       return cTrue;

vm/environment.cpp

@@ -76,8 +76,8 @@ namespace rubinius {
     : argc_(argc)
     , argv_(0)
     , signature_(0)
-    , signal_handler_(NULL)
-    , finalizer_handler_(NULL)
+    , signal_thread_(NULL)
+    , finalizer_thread_(NULL)
   {
 #ifdef ENABLE_LLVM
 #if RBX_LLVM_API_VER < 305
@@ -110,8 +110,8 @@ namespace rubinius {
   Environment::~Environment() {
     stop_logging(state);
 
-    delete signal_handler_;
-    delete finalizer_handler_;
+    delete signal_thread_;
+    delete finalizer_thread_;
 
     VM::discard(state, root_vm);
     SharedState::discard(shared);
@@ -168,17 +168,17 @@ namespace rubinius {
 
   void Environment::start_signals(STATE) {
     state->vm()->set_run_signals(true);
-    signal_handler_ = new SignalHandler(state, config);
-    signal_handler_->start(state);
+    signal_thread_ = new SignalThread(state, config);
+    signal_thread_->start(state);
   }
 
   void Environment::stop_signals(STATE) {
-    signal_handler_->stop(state);
+    signal_thread_->stop(state);
   }
 
   void Environment::start_finalizer(STATE) {
-    finalizer_handler_ = new FinalizerHandler(state);
-    finalizer_handler_->start(state);
+    finalizer_thread_ = new FinalizerThread(state);
+    finalizer_thread_->start(state);
   }
 
   void Environment::start_logging(STATE) {

vm/environment.hpp

@@ -12,8 +12,8 @@ namespace rubinius {
 
   class ConfigParser;
   class QueryAgent;
-  class SignalHandler;
-  class FinalizerHandler;
+  class SignalThread;
+  class FinalizerThread;
 
   /**
    * Thrown when unable to find Rubinius runtime directories.
@@ -54,8 +54,8 @@ namespace rubinius {
      */
     uint64_t signature_;
 
-    SignalHandler* signal_handler_;
-    FinalizerHandler* finalizer_handler_;
+    SignalThread* signal_thread_;
+    FinalizerThread* finalizer_thread_;
 
     std::string system_prefix_;
 

vm/gc/baker.cpp

@@ -477,10 +477,10 @@ namespace rubinius {
   }
 
   void BakerGC::walk_finalizers() {
-    FinalizerHandler* fh = object_memory_->finalizer_handler();
-    if(!fh) return;
+    FinalizerThread* ft = object_memory_->finalizer_handler();
+    if(!ft) return;
 
-    for(FinalizerHandler::iterator i = fh->begin();
+    for(FinalizerThread::iterator i = ft->begin();
         !i.end();
         /* advance is handled in the loop */)
     {

vm/gc/finalize.cpp

@@ -20,7 +20,7 @@
 #include "dtrace/dtrace.h"
 
 namespace rubinius {
-  FinalizerHandler::iterator::iterator(FinalizerHandler* fh)
+  FinalizerThread::iterator::iterator(FinalizerThread* fh)
     : handler_(fh)
     , current_list_(NULL)
   {
@@ -46,7 +46,7 @@ namespace rubinius {
     }
   }
 
-  void FinalizerHandler::iterator::next(bool live) {
+  void FinalizerThread::iterator::next(bool live) {
     if(current_list_ == handler_->live_list_) {
       if(!live) current_->queued();
 
@@ -68,11 +68,11 @@ namespace rubinius {
     }
   }
 
-  bool FinalizerHandler::iterator::end() {
+  bool FinalizerThread::iterator::end() {
     return current_ == end_;
   }
 
-  FinalizerHandler::FinalizerHandler(STATE)
+  FinalizerThread::FinalizerThread(STATE)
     : InternalThread(state, "rbx.finalizer")
     , lists_(NULL)
     , live_list_(NULL)
@@ -87,7 +87,7 @@ namespace rubinius {
     live_list_ = new FinalizeObjects();
   }
 
-  FinalizerHandler::~FinalizerHandler() {
+  FinalizerThread::~FinalizerThread() {
     if(iterator_) delete iterator_;
     if(live_list_) delete live_list_;
 
@@ -99,7 +99,7 @@ namespace rubinius {
     }
   }
 
-  void FinalizerHandler::initialize(STATE) {
+  void FinalizerThread::initialize(STATE) {
     InternalThread::initialize(state);
 
     live_guard_.init();
@@ -110,15 +110,15 @@ namespace rubinius {
     finishing_ = false;
   }
 
-  void FinalizerHandler::wakeup(STATE) {
+  void FinalizerThread::wakeup(STATE) {
     utilities::thread::Mutex::LockGuard lg(worker_lock_);
 
     InternalThread::wakeup(state);
 
     worker_signal();
   }
 
-  void FinalizerHandler::run(STATE) {
+  void FinalizerThread::run(STATE) {
     GCTokenImpl gct;
 
     NativeMethod::init_thread(state);
@@ -162,7 +162,7 @@ namespace rubinius {
     NativeMethod::cleanup_thread(state);
   }
 
-  void FinalizerHandler::finalize(STATE) {
+  void FinalizerThread::finalize(STATE) {
     switch(process_item_kind_) {
     case eRuby: {
       if(process_item_->ruby_finalizer) {
@@ -227,14 +227,14 @@ namespace rubinius {
     }
   }
 
-  void FinalizerHandler::first_process_item() {
+  void FinalizerThread::first_process_item() {
     if(!process_list_ && !lists_->empty()) {
       process_list_ = lists_->back();
       process_item_ = process_list_->begin();
     }
   }
 
-  void FinalizerHandler::next_process_item() {
+  void FinalizerThread::next_process_item() {
     if(++process_item_ == process_list_->end()) {
       switch(process_item_kind_) {
       case eRuby:
@@ -256,7 +256,7 @@ namespace rubinius {
     }
   }
 
-  void FinalizerHandler::finish(STATE, GCToken gct) {
+  void FinalizerThread::finish(STATE, GCToken gct) {
     finishing_ = true;
 
     stop_thread(state);
@@ -291,11 +291,11 @@ namespace rubinius {
     }
 
     if(!lists_->empty() || !live_list_->empty() || process_list_ != NULL) {
-      utilities::logger::warn("FinalizerHandler exiting with pending finalizers");
+      utilities::logger::warn("FinalizerThread exiting with pending finalizers");
     }
   }
 
-  void FinalizerHandler::record(Object* obj, FinalizerFunction func) {
+  void FinalizerThread::record(Object* obj, FinalizerFunction func) {
     utilities::thread::Mutex::LockGuard lg(live_guard_);
 
     if(finishing_) return;
@@ -311,7 +311,7 @@ namespace rubinius {
     metrics().m.finalizer_metrics.objects_queued++;
   }
 
-  void FinalizerHandler::set_ruby_finalizer(Object* obj, Object* finalizer) {
+  void FinalizerThread::set_ruby_finalizer(Object* obj, Object* finalizer) {
     utilities::thread::Mutex::LockGuard lg(live_guard_);
 
     // Ignore Ruby finalizers created when finishing running finalizers.
@@ -357,7 +357,7 @@ namespace rubinius {
     live_list_->push_front(fi);
   }
 
-  void FinalizerHandler::queue_objects() {
+  void FinalizerThread::queue_objects() {
     FinalizeObjects* dead_list = new FinalizeObjects();
 
     for(FinalizeObjects::iterator i = live_list_->begin();
@@ -379,7 +379,7 @@ namespace rubinius {
     }
   }
 
-  void FinalizerHandler::start_collection(STATE) {
+  void FinalizerThread::start_collection(STATE) {
     if(process_item_kind_ == eRelease) {
       while(process_list_) {
         finalize(state);
@@ -388,7 +388,7 @@ namespace rubinius {
     }
   }
 
-  void FinalizerHandler::finish_collection(STATE) {
+  void FinalizerThread::finish_collection(STATE) {
     queue_objects();
 
     if(iterator_) {
@@ -399,23 +399,23 @@ namespace rubinius {
     worker_signal();
   }
 
-  void FinalizerHandler::supervisor_signal() {
+  void FinalizerThread::supervisor_signal() {
     supervisor_cond_.signal();
   }
 
-  void FinalizerHandler::supervisor_wait() {
+  void FinalizerThread::supervisor_wait() {
     supervisor_cond_.wait(supervisor_lock_);
   }
 
-  void FinalizerHandler::worker_signal() {
+  void FinalizerThread::worker_signal() {
     worker_cond_.signal();
   }
 
-  void FinalizerHandler::worker_wait() {
+  void FinalizerThread::worker_wait() {
     worker_cond_.wait(worker_lock_);
   }
 
-  FinalizerHandler::iterator& FinalizerHandler::begin() {
+  FinalizerThread::iterator& FinalizerThread::begin() {
     if(iterator_) delete iterator_;
     iterator_ = new iterator(this);
     return *iterator_;

vm/gc/finalize.hpp

@@ -52,17 +52,17 @@ namespace rubinius {
   typedef std::list<FinalizeObject> FinalizeObjects;
   typedef std::list<FinalizeObjects*> FinalizeObjectsList;
 
-  class FinalizerHandler : public InternalThread, public Lockable {
+  class FinalizerThread : public InternalThread, public Lockable {
   public:
     class iterator {
-      FinalizerHandler* handler_;
+      FinalizerThread* handler_;
       FinalizeObjects* current_list_;
       FinalizeObjects::iterator end_;
       FinalizeObjects::iterator current_;
       FinalizeObjectsList::iterator lists_iterator_;
 
     public:
-      iterator(FinalizerHandler* fh);
+      iterator(FinalizerThread* fh);
       ~iterator() {}
 
       void next(bool live);
@@ -83,7 +83,7 @@ namespace rubinius {
     FinalizeObjects* live_list_;
     FinalizeObjects* process_list_;
     FinalizeObjects::iterator process_item_;
-    FinalizerHandler::iterator* iterator_;
+    FinalizerThread::iterator* iterator_;
     ProcessItemKind process_item_kind_;
     utilities::thread::Mutex live_guard_;
     utilities::thread::Mutex worker_lock_;
@@ -94,8 +94,8 @@ namespace rubinius {
 
   public:
 
-    FinalizerHandler(STATE);
-    virtual ~FinalizerHandler();
+    FinalizerThread(STATE);
+    virtual ~FinalizerThread();
 
     void finalize(STATE);
     void first_process_item();
@@ -110,7 +110,7 @@ namespace rubinius {
     void start_collection(STATE);
     void finish_collection(STATE);
 
-    FinalizerHandler::iterator& begin();
+    FinalizerThread::iterator& begin();
 
     void worker_signal();
     void worker_wait();

vm/gc/immix.cpp

@@ -386,10 +386,10 @@ namespace rubinius {
   }
 
   void ImmixGC::walk_finalizers() {
-    FinalizerHandler* fh = object_memory_->finalizer_handler();
+    FinalizerThread* fh = object_memory_->finalizer_handler();
     if(!fh) return;
 
-    for(FinalizerHandler::iterator i = fh->begin();
+    for(FinalizerThread::iterator i = fh->begin();
         !i.end();
         /* advance is handled in the loop */)
     {

vm/object_memory.cpp

@@ -615,7 +615,7 @@ namespace rubinius {
 #ifdef RBX_GC_DEBUG
     young_->verify(data);
 #endif
-    if(FinalizerHandler* hdl = state->shared().finalizer_handler()) {
+    if(FinalizerThread* hdl = state->shared().finalizer_handler()) {
       hdl->finish_collection(state);
     }
   }
@@ -678,7 +678,7 @@ namespace rubinius {
     metrics.m.ruby_metrics.memory_code_bytes = code_manager_.size();
     metrics.m.ruby_metrics.memory_jit_bytes = data->jit_bytes_allocated();
 
-    if(FinalizerHandler* hdl = state->shared().finalizer_handler()) {
+    if(FinalizerThread* hdl = state->shared().finalizer_handler()) {
       hdl->finish_collection(state);
     }
 
@@ -1013,7 +1013,7 @@ namespace rubinius {
   }
 
   void ObjectMemory::needs_finalization(Object* obj, FinalizerFunction func) {
-    if(FinalizerHandler* fh = shared_.finalizer_handler()) {
+    if(FinalizerThread* fh = shared_.finalizer_handler()) {
       fh->record(obj, func);
     }
   }

vm/object_memory.hpp

@@ -33,7 +33,7 @@ namespace rubinius {
   class ImmixGC;
   class InflatedHeaders;
   class Thread;
-  class FinalizerHandler;
+  class FinalizerThread;
   class ImmixMarker;
 
   namespace gc {
@@ -187,7 +187,7 @@ namespace rubinius {
       allow_gc_ = false;
     }
 
-    FinalizerHandler* finalizer_handler() const {
+    FinalizerThread* finalizer_handler() const {
       return shared_.finalizer_handler();
     }
 

vm/shared_state.cpp

@@ -31,8 +31,8 @@ namespace rubinius {
 
   SharedState::SharedState(Environment* env, Configuration& config, ConfigParser& cp)
     : internal_threads_(0)
-    , signal_handler_(0)
-    , finalizer_handler_(0)
+    , signal_thread_(0)
+    , finalizer_thread_(0)
     , console_(0)
     , metrics_(0)
     , world_(new WorldState(&check_global_interrupts_))