Reworked running finalizers.

rubinius · Jun 4, 2016 · 2310fd3 · 2310fd3
1 parent 949b25e
commit 2310fd3
Show file tree

Hide file tree

Showing 25 changed files with 419 additions and 561 deletions.
diff --git a/core/loader.rb b/core/loader.rb
@@ -758,10 +758,6 @@ def epilogue
 
       run_at_exits
 
-      @stage = "running object finalizers"
-      ::GC.start
-      ObjectSpace.run_finalizers
-
       flush_stdio
 
     rescue Object => e

diff --git a/core/object_space.rb b/core/object_space.rb
@@ -52,6 +52,14 @@ def self.each_object(what=nil, &block)
   def self.define_finalizer(obj, prc=nil, &block)
     prc ||= block
 
+    if obj.kind_of? ImmediateValue or obj.kind_of? Float
+      raise ArgumentError, "can't define finalizer for #{obj.class}"
+    end
+
+    if obj.frozen?
+      raise RuntimeError, "can't modify frozen #{obj.class}"
+    end
+
     if obj.equal? prc
       # This is allowed. This is the Rubinius specific API that calls
       # __finalize__ when the object is finalized.
@@ -74,9 +82,6 @@ def self.undefine_finalizer(obj)
     return obj
   end
 
-  def self.run_finalizers
-  end
-
   def self.garbage_collect
     GC.start
   end

diff --git a/core/process.rb b/core/process.rb
@@ -83,8 +83,6 @@ def self.fork
         end
       end
 
-      ObjectSpace.run_finalizers
-
       # Do not use Kernel.exit. This raises a SystemExit exception, which
       # will run ensure blocks. This is not what MRI does and causes bugs
       # in programs. See issue http://github.com/rubinius/rubinius/issues#issue/289 for

diff --git a/machine/builtin/call_site.hpp b/machine/builtin/call_site.hpp
@@ -181,7 +181,7 @@ namespace rubinius {
       cache->name(name);
       cache->ip(ip);
 
-      state->memory()->needs_finalization(state, cache,
+      state->memory()->native_finalizer(state, cache,
           (memory::FinalizerFunction)&CallSite::finalize);
 
       state->vm()->metrics().machine.call_site_count++;

diff --git a/machine/builtin/data.cpp b/machine/builtin/data.cpp
@@ -39,7 +39,7 @@ namespace rubinius {
     data->internal(rdata);
 
     if(mark || free) {
-      state->memory()->needs_finalization(state, data,
+      state->memory()->extension_finalizer(state, data,
           (memory::FinalizerFunction)&Data::finalize);
     }
 
@@ -73,7 +73,7 @@ namespace rubinius {
     data->internal(rdata);
 
     if(type->function.dmark || type->function.dfree) {
-      state->memory()->needs_finalization(state, data,
+      state->memory()->extension_finalizer(state, data,
           (memory::FinalizerFunction)&Data::finalize);
     }
 

diff --git a/machine/builtin/dir.cpp b/machine/builtin/dir.cpp
@@ -18,9 +18,8 @@ namespace rubinius {
     Dir* d = Dir::allocate(state, G(dir));
     d->os(0);
 
-    state->memory()->needs_finalization(state, d,
-        (memory::FinalizerFunction)&Dir::finalize,
-        memory::FinalizeObject::eUnmanaged);
+    state->memory()->native_finalizer(state, d,
+        (memory::FinalizerFunction)&Dir::finalize);
 
     return d;
   }

diff --git a/machine/builtin/encoding.cpp b/machine/builtin/encoding.cpp
@@ -729,9 +729,8 @@ namespace rubinius {
 
     c->converter(NULL);
 
-    state->memory()->needs_finalization(state, c,
-        (memory::FinalizerFunction)&Converter::finalize,
-        memory::FinalizeObject::eUnmanaged);
+    state->memory()->native_finalizer(state, c,
+        (memory::FinalizerFunction)&Converter::finalize);
 
     return c;
   }

diff --git a/machine/builtin/ffi_pointer.cpp b/machine/builtin/ffi_pointer.cpp
@@ -115,14 +115,13 @@ namespace rubinius {
 
     if(autorelease) {
       if(!set_finalizer) {
-        state->memory()->needs_finalization(state, this,
-            (memory::FinalizerFunction)&Pointer::finalize,
-            memory::FinalizeObject::eUnmanaged);
+        state->memory()->native_finalizer(state, this,
+            (memory::FinalizerFunction)&Pointer::finalize);
         set_finalizer = true;
       }
     } else {
       if(set_finalizer) {
-        state->memory()->set_ruby_finalizer(this, cNil);
+        state->memory()->managed_finalizer(state, this, cNil);
         set_finalizer = false;
       }
     }

diff --git a/machine/builtin/fiber.cpp b/machine/builtin/fiber.cpp
@@ -38,9 +38,8 @@ namespace rubinius {
       fib->data(state->vm()->new_fiber_data(true, fib->stack_size()->to_native()));
       fib->data()->set_call_frame(state->vm()->call_frame());
 
-      state->memory()->needs_finalization(state, fib,
-          (memory::FinalizerFunction)&Fiber::finalize,
-          memory::FinalizeObject::eUnmanaged);
+      state->memory()->native_finalizer(state, fib,
+          (memory::FinalizerFunction)&Fiber::finalize);
 
       state->vm()->current_fiber.set(fib);
       state->vm()->root_fiber.set(fib);
@@ -119,9 +118,8 @@ namespace rubinius {
 
     state->vm()->metrics().system.fibers_created++;
 
-    state->memory()->needs_finalization(state, fib,
-        (memory::FinalizerFunction)&Fiber::finalize,
-        memory::FinalizeObject::eUnmanaged);
+    state->memory()->native_finalizer(state, fib,
+        (memory::FinalizerFunction)&Fiber::finalize);
 
     return fib;
 #else

diff --git a/machine/builtin/fsevent.cpp b/machine/builtin/fsevent.cpp
@@ -34,9 +34,8 @@ namespace rubinius {
     if(fsevent->kq() < 0) {
       logger::error("%s: unable to create kqueue", strerror(errno));
     } else {
-      state->memory()->needs_finalization(state, fsevent,
-          (memory::FinalizerFunction)&FSEvent::finalize,
-          memory::FinalizeObject::eUnmanaged);
+      state->memory()->native_finalizer(state, fsevent,
+          (memory::FinalizerFunction)&FSEvent::finalize);
     }
 
     return fsevent;
@@ -84,9 +83,8 @@ namespace rubinius {
     if(fsevent->in() < 0) {
       logger::error("%s: unable to create inotify", strerror(errno));
     } else {
-      state->memory()->needs_finalization(state, fsevent,
-          (memory::FinalizerFunction)&FSEvent::finalize,
-          memory::FinalizeObject::eUnmanaged);
+      state->memory()->native_finalizer(state, fsevent,
+          (memory::FinalizerFunction)&FSEvent::finalize);
     }
 
     return fsevent;

diff --git a/machine/builtin/io.cpp b/machine/builtin/io.cpp
@@ -75,7 +75,7 @@ namespace rubinius {
 
     // Don't bother to add finalization for stdio
     if(fd >= 3) {
-      state->memory()->needs_finalization(state, io,
+      state->memory()->extension_finalizer(state, io,
           (memory::FinalizerFunction)&IO::finalize);
     }
 
@@ -86,7 +86,7 @@ namespace rubinius {
     IO* io = state->memory()->new_object<IO>(state, as<Class>(self));
     io->ibuffer(state, IOBuffer::create(state));
 
-    state->memory()->needs_finalization(state, io,
+    state->memory()->extension_finalizer(state, io,
         (memory::FinalizerFunction)&IO::finalize);
 
     return io;

diff --git a/machine/builtin/system.cpp b/machine/builtin/system.cpp
@@ -1510,7 +1510,7 @@ namespace rubinius {
 
   Object* System::vm_set_finalizer(STATE, Object* obj, Object* fin) {
     if(!obj->reference_p()) return cFalse;
-    state->memory()->set_ruby_finalizer(obj, fin);
+    state->memory()->managed_finalizer(state, obj, fin);
     return cTrue;
   }
 

diff --git a/machine/builtin/thread.cpp b/machine/builtin/thread.cpp
@@ -90,9 +90,8 @@ namespace rubinius {
 
     thr->function(function);
 
-    state->memory()->needs_finalization(state, thr,
-        (memory::FinalizerFunction)&Thread::finalize,
-        memory::FinalizeObject::eUnmanaged);
+    state->memory()->native_finalizer(state, thr,
+        (memory::FinalizerFunction)&Thread::finalize);
 
     state->vm()->metrics().system.threads_created++;
 

diff --git a/machine/environment.cpp b/machine/environment.cpp
@@ -551,7 +551,7 @@ namespace rubinius {
 
     shared->thread_nexus()->lock(state->vm());
 
-    shared->finalizer_handler()->finish(state);
+    shared->finalizer()->finish(state);
 
     NativeMethod::cleanup_thread(state);
 

diff --git a/machine/machine_threads.cpp b/machine/machine_threads.cpp
@@ -15,8 +15,8 @@ namespace rubinius {
 
   MachineThread::MachineThread(STATE, std::string name, StackSize stack_size)
     : vm_(state->shared().thread_nexus()->new_vm(&state->shared(), name.c_str()))
-    , thread_running_(false)
     , stack_size_(stack_size)
+    , thread_running_(false)
     , thread_exit_(false)
   {
     state->shared().machine_threads()->register_thread(this);

diff --git a/machine/machine_threads.hpp b/machine/machine_threads.hpp
@@ -5,6 +5,7 @@
 
 #include "util/thread.hpp"
 
+#include <atomic>
 #include <string>
 #include <list>
 
@@ -16,12 +17,12 @@ namespace rubinius {
 
   class MachineThread {
     VM* vm_;
-    bool thread_running_;
     uint32_t stack_size_;
 
   protected:
 
-    bool thread_exit_;
+    std::atomic<bool> thread_running_;
+    std::atomic<bool> thread_exit_;
 
   public:
 

diff --git a/machine/memory.cpp b/machine/memory.cpp
@@ -523,10 +523,6 @@ namespace rubinius {
 
     if(!collect_young_flag_ && !collect_full_flag_) return;
 
-    if(memory::FinalizerThread* finalizer = state->shared().finalizer_handler()) {
-      finalizer->start_collection(state);
-    }
-
     if(cDebugThreading) {
       std::cerr << std::endl << "[" << state
                 << " WORLD beginning GC.]" << std::endl;
@@ -584,10 +580,6 @@ namespace rubinius {
 #ifdef RBX_GC_DEBUG
     young_->verify(data);
 #endif
-
-    if(memory::FinalizerThread* finalizer = state->shared().finalizer_handler()) {
-      finalizer->finish_collection(state);
-    }
     */
 
     collect_young_flag_ = false;
@@ -666,10 +658,6 @@ namespace rubinius {
     metrics.gc.immix_count++;
     metrics.gc.large_count++;
 
-    if(memory::FinalizerThread* finalizer = state->shared().finalizer_handler()) {
-      finalizer->finish_collection(state);
-    }
-
     collect_full_flag_ = false;
     interrupt_flag_ = false;
 
@@ -846,18 +834,6 @@ namespace rubinius {
     }
   }
 
-  void Memory::needs_finalization(STATE, Object* obj, memory::FinalizerFunction func,
-      memory::FinalizeObject::FinalizeKind kind)
-  {
-    if(memory::FinalizerThread* finalizer = shared_.finalizer_handler()) {
-      finalizer->record(state, obj, func, kind);
-    }
-  }
-
-  void Memory::set_ruby_finalizer(Object* obj, Object* finalizer) {
-    shared_.finalizer_handler()->set_ruby_finalizer(obj, finalizer);
-  }
-
   capi::Handle* Memory::add_capi_handle(STATE, Object* obj) {
     if(!obj->reference_p()) {
       rubinius::bug("Trying to add a handle for a non reference");

diff --git a/machine/memory.hpp b/machine/memory.hpp
@@ -223,8 +223,8 @@ namespace rubinius {
       }
     }
 
-    memory::FinalizerThread* finalizer_handler() const {
-      return shared_.finalizer_handler();
+    memory::FinalizerThread* finalizer() const {
+      return shared_.finalizer();
     }
 
     memory::InflatedHeaders* inflated_headers() const {
@@ -550,9 +550,23 @@ namespace rubinius {
 
     void collect_maybe(STATE);
 
-    void needs_finalization(STATE, Object* obj, memory::FinalizerFunction func,
-        memory::FinalizeObject::FinalizeKind kind = memory::FinalizeObject::eManaged);
-    void set_ruby_finalizer(Object* obj, Object* finalizer);
+    void native_finalizer(STATE, Object* obj, memory::FinalizerFunction func) {
+      if(memory::FinalizerThread* f = this->finalizer()) {
+        f->native_finalizer(state, obj, func);
+      }
+    }
+
+    void extension_finalizer(STATE, Object* obj, memory::FinalizerFunction func) {
+      if(memory::FinalizerThread* f = this->finalizer()) {
+        f->extension_finalizer(state, obj, func);
+      }
+    }
+
+    void managed_finalizer(STATE, Object* obj, Object* finalizer) {
+      if(memory::FinalizerThread* f = this->finalizer()) {
+        f->managed_finalizer(state, obj, finalizer);
+      }
+    }
 
     InflatedHeader* inflate_header(STATE, ObjectHeader* obj);
     void inflate_for_id(STATE, ObjectHeader* obj, uint32_t id);