Clean up young generation debris.

Author: brixen

machine/builtin/string.hpp

@@ -187,6 +187,7 @@ namespace rubinius {
          * allocate a new object in the young space, we can copy it directly
          * without needing a write barrier.
          */
+        /* TODO: young gen removal
         String* so = state->memory()->new_object<String>(state, G(string));
         if(likely(so->young_object_p())) {
           so->copy_body(state, this);
@@ -195,6 +196,7 @@ namespace rubinius {
           infect(state, so);
           return so;
         }
+        */
       }
       return string_dup_slow(state);
     }

machine/capi/handles.cpp

@@ -70,9 +70,7 @@ namespace rubinius {
       if(diagnostics()) delete diagnostics();
     }
 
-    void Handles::deallocate_handles(std::list<Handle*>* cached,
-        unsigned int mark, /* BakerGC */ void* young)
-    {
+    void Handles::deallocate_handles(std::list<Handle*>* cached, unsigned int mark) {
       std::vector<bool> chunk_marks(allocator_->chunks_.size(), false);
 
       diagnostics()->objects_ = 0;
@@ -96,35 +94,7 @@ namespace rubinius {
             continue;
           }
 
-          if(young) {
-            /*
-            if(obj->young_object_p()) {
-              // A weakref pointing to a valid young object
-              //
-              // TODO this only works because we run prune_handles right after
-              // a collection. In this state, valid objects are only in current.
-              if(young->in_current_p(obj)) {
-                chunk_marks[i] = true;
-                diagnostics()->objects_++;
-              // A weakref pointing to a forwarded young object
-              } else if(obj->forwarded_p()) {
-                handle->set_object(obj->forward());
-                chunk_marks[i] = true;
-                diagnostics()->objects_++;
-              // A weakref pointing to a dead young object
-              } else {
-                handle->clear();
-              }
-            } else {
-              // Not a young object, so won't be GC'd so mark
-              // chunk as still active
-              chunk_marks[i] = true;
-              diagnostics()->objects_++;
-            }
-            */
-
-          // A weakref pointing to a dead mature object
-          } else if(!obj->marked_p(mark)) {
+          if(!obj->marked_p(mark)) {
             handle->clear();
           } else {
             chunk_marks[i] = true;

machine/capi/handles.hpp

@@ -51,7 +51,7 @@ namespace rubinius {
 
       bool validate(Handle* handle);
 
-      void deallocate_handles(std::list<Handle*>* cached, unsigned int mark, /* BakerGC */ void* young);
+      void deallocate_handles(std::list<Handle*>* cached, unsigned int mark);
 
       void flush_all(NativeMethodEnvironment* env);
 

machine/global_cache.cpp

@@ -193,33 +193,6 @@ namespace rubinius {
       Object* klass = entry->klass;
       if(!klass) continue;
 
-      if(klass->young_object_p()) {
-        if(klass->forwarded_p()) {
-          Module* fwd = force_as<Module>(klass->forward());
-          entry->klass = fwd;
-        } else {
-          clear = true;
-        }
-      }
-
-      Object* mod = entry->module;
-      if(mod->young_object_p()) {
-        if(mod->forwarded_p()) {
-          entry->module = force_as<Module>(mod->forward());
-        } else {
-          clear = true;
-        }
-      }
-
-      Object* exec = entry->method;
-      if(exec->young_object_p()) {
-        if(exec->forwarded_p()) {
-          entry->method = force_as<Executable>(exec->forward());
-        } else {
-          clear = true;
-        }
-      }
-
       if(clear) {
         entry_names[i] = NULL;
         entry->clear();

machine/memory.cpp

@@ -68,7 +68,6 @@ namespace rubinius {
     , mature_gc_in_progress_(false)
     , slab_size_(4096)
     , interrupt_flag_(false)
-    , collect_young_flag_(false)
     , collect_full_flag_(false)
     , last_object_id(1)
     , last_snapshot_id(0)
@@ -82,6 +81,8 @@ namespace rubinius {
     }
 #endif
 
+    state->shared().set_memory(this);
+
     for(size_t i = 0; i < LastObjectType; i++) {
       type_info[i] = NULL;
     }
@@ -100,7 +101,6 @@ namespace rubinius {
 
     delete immix_;
     delete mark_sweep_;
-    /* delete young_; */
 
     for(std::list<capi::GlobalHandle*>::iterator i = global_capi_handle_locations_.begin();
           i != global_capi_handle_locations_.end(); ++i) {
@@ -421,26 +421,6 @@ namespace rubinius {
     }
   }
 
-  bool Memory::refill_slab(STATE, memory::Slab& slab) {
-    utilities::thread::SpinLock::LockGuard guard(allocation_lock_);
-
-    memory::Address addr = memory::Address::null(); /* young_->allocate_for_slab(slab_size_); */
-
-    metrics::MetricsData& metrics = state->vm()->metrics();
-    metrics.memory.young_objects += slab.allocations();
-    metrics.memory.young_bytes += slab.bytes_used();
-
-    if(addr) {
-      slab.refill(addr, slab_size_);
-      metrics.memory.slab_refills++;
-      return true;
-    } else {
-      slab.refill(0, 0);
-      metrics.memory.slab_refills_fails++;
-      return false;
-    }
-  }
-
   bool Memory::valid_object_p(STATE, Object* obj) {
     if(obj->true_p()) {
       return true;
@@ -454,8 +434,6 @@ namespace rubinius {
       return true;
     } else if(obj->symbol_p()) {
       return true;
-    } else if(obj->young_object_p()) {
-      return false; /* young_->validate_object(obj) == cValid; */
     } else if(obj->mature_object_p()) {
       if(obj->in_immix_p()) {
         if(immix_->validate_object(state, obj) == cInImmix) {
@@ -511,76 +489,24 @@ namespace rubinius {
      * prohibition lifts, a GC will eventually be triggered again.
      */
     if(!can_gc()) {
-      collect_young_flag_ = false;
       collect_full_flag_ = false;
       interrupt_flag_ = false;
       return;
     }
 
-    if(!collect_young_flag_ && !collect_full_flag_) return;
+    if(!collect_full_flag_) return;
 
     if(cDebugThreading) {
       std::cerr << std::endl << "[" << state
                 << " WORLD beginning GC.]" << std::endl;
     }
 
-    if(collect_young_flag_) {
-      memory::GCData gc_data(state);
-
-      RUBINIUS_GC_BEGIN(0);
-      collect_young(state, &gc_data);
-
-      if(!collect_full_flag_) interrupt_flag_ = false;
-
-      RUBINIUS_GC_END(0);
-    }
-
     if(collect_full_flag_) {
       RUBINIUS_GC_BEGIN(1);
       collect_full(state);
     }
   }
 
-  void Memory::collect_young(STATE, memory::GCData* data) {
-    timer::StopWatch<timer::milliseconds> timerx(
-        state->vm()->metrics().gc.young_ms);
-
-    /* 
-    young_->collect(data);
-
-    prune_handles(state, data->handles(), data->cached_handles(), young_);
-
-    metrics::MetricsData& metrics = state->vm()->metrics();
-    metrics.gc.young_count++;
-
-    data->global_cache()->prune_young();
-
-    {
-      std::lock_guard<std::mutex> guard(data->thread_nexus()->threads_mutex());
-
-      for(ThreadList::iterator i = data->thread_nexus()->threads()->begin();
-          i != data->thread_nexus()->threads()->end();
-          ++i)
-      {
-        memory::Slab& slab = (*i)->local_slab();
-
-        // Reset the slab to a size of 0 so that the thread has to do
-        // an allocation to get a proper refill. This keeps the number
-        // of threads in the system from starving the available
-        // number of slabs.
-        slab.refill(0, 0);
-      }
-    }
-
-    young_->reset();
-#ifdef RBX_GC_DEBUG
-    young_->verify(data);
-#endif
-    */
-
-    collect_young_flag_ = false;
-  }
-
   void Memory::collect_full(STATE) {
     // If we're already collecting, ignore this request
     if(mature_gc_in_progress_) return;
@@ -634,7 +560,7 @@ namespace rubinius {
 
     data->global_cache()->prune_unmarked(mark());
 
-    prune_handles(state, data->handles(), data->cached_handles(), NULL);
+    prune_handles(state, data->handles(), data->cached_handles());
 
     // Have to do this after all things that check for mark bits is
     // done, as it free()s objects, invalidating mark bits.
@@ -723,10 +649,8 @@ namespace rubinius {
 
   }
 
-  void Memory::prune_handles(STATE, capi::Handles* handles,
-      std::list<capi::Handle*>* cached, /* BakerGC */ void* young)
-  {
-    handles->deallocate_handles(cached, mark(), young);
+  void Memory::prune_handles(STATE, capi::Handles* handles, std::list<capi::Handle*>* cached) {
+    handles->deallocate_handles(cached, mark());
   }
 
   void Memory::add_type_info(STATE, TypeInfo* ti) {
@@ -793,11 +717,6 @@ namespace rubinius {
   ObjectPosition Memory::validate_object(STATE, Object* obj) {
     ObjectPosition pos;
 
-    /*
-    pos = young_->validate_object(obj);
-    if(pos != cUnknown) return pos;
-    */
-
     pos = immix_->validate_object(state, obj);
     if(pos != cUnknown) return pos;
 

machine/memory.hpp

@@ -115,9 +115,6 @@ namespace rubinius {
     /// Flag indicating that a Memory condition exists
     bool interrupt_flag_;
 
-    /// Flag indicating whether a young collection should be performed soon
-    bool collect_young_flag_;
-
     /// Flag indicating whether a full collection should be performed soon
     bool collect_full_flag_;
 
@@ -172,16 +169,6 @@ namespace rubinius {
       allow_gc_ = false;
     }
 
-    void schedule_young_collection(STATE, metrics::metric& counter) {
-      counter++;
-
-      // Don't trigger GC if currently prohibited so we don't thrash checking.
-      if(can_gc()) {
-        interrupt_flag_ = collect_young_flag_ = true;
-        state->vm()->thread_nexus()->set_stop();
-      }
-    }
-
     void schedule_full_collection(STATE, const char* trigger, metrics::metric& counter) {
       counter++;
       schedule_full_collection(state, trigger);
@@ -277,25 +264,7 @@ namespace rubinius {
     Object* new_object(STATE, Class* klass, native_int bytes, object_type type) {
       // TODO: GC
     // allocate:
-      Object* obj = 0; /* state->vm()->local_slab().allocate(bytes).as<Object>();
-
-      if(likely(obj)) {
-        state->vm()->metrics().memory.young_objects++;
-        state->vm()->metrics().memory.young_bytes += bytes;
-
-        obj->init_header(YoungObjectZone, type);
-
-        goto set_klass;
-      }
-
-      if(state->vm()->local_slab().empty_p()) {
-        if(refill_slab(state, state->vm()->local_slab())) {
-          goto allocate;
-        } else {
-          schedule_young_collection(state->vm(), state->vm()->metrics().gc.young_set);
-       }
-      }
-      */
+      Object* obj = 0;
 
       if(likely(obj = new_object(state, bytes))) goto set_type;
 
@@ -510,8 +479,6 @@ namespace rubinius {
     TypeInfo* find_type_info(STATE, Object* obj);
     Object* promote_object(STATE, Object* obj);
 
-    bool refill_slab(STATE, memory::Slab& slab);
-
     void assign_object_id(STATE, Object* obj);
     bool inflate_lock_count_overflow(STATE, ObjectHeader* obj, int count);
     LockStatus contend_for_lock(STATE, ObjectHeader* obj, size_t us, bool interrupt);
@@ -525,14 +492,12 @@ namespace rubinius {
     void add_code_resource(STATE, memory::CodeResource* cr);
 
     void validate_handles(STATE, capi::Handles* handles);
-    void prune_handles(STATE, capi::Handles* handles,
-        std::list<capi::Handle*>* cached, /* BakerGC */ void* young);
+    void prune_handles(STATE, capi::Handles* handles, std::list<capi::Handle*>* cached);
 
     ObjectPosition validate_object(STATE, Object* obj);
 
     void collect(STATE) {
       if(can_gc()) {
-        collect_young_flag_ = true;
         collect_full_flag_ = true;
         interrupt_flag_ = true;
         state->vm()->thread_nexus()->set_stop();
@@ -590,10 +555,6 @@ namespace rubinius {
       return interrupt_flag_;
     }
 
-    bool& collect_young_p() {
-      return collect_young_flag_;
-    }
-
     bool& collect_full_p() {
       return collect_full_flag_;
     }

machine/memory/debug.cpp

@@ -34,14 +34,6 @@ namespace memory {
 
     seen[obj] = 1;
 
-    /*
-    if(obj->young_object_p()) {
-      if(!memory_->young.current->contains_p(obj)) {
-        throw std::runtime_error("Invalid young object detected.");
-      }
-    }
-    */
-
     scan_object(state, obj);
 
     return NULL;