API cleanup, state->vm()->om => state->memory()

vm/agent_components.cpp

@@ -488,47 +488,47 @@ namespace agent {
     young->add(new StaticInteger<int>("bytes", ss.config.gc_bytes * 2));
 
     Tree* mature = mem->get_tree("mature");
-    mature->add(new ReadInteger<size_t>("bytes", &state->vm()->om->immix_usage()));
+    mature->add(new ReadInteger<size_t>("bytes", &state->memory()->immix_usage()));
 
     Tree* large = mem->get_tree("large");
-    large->add(new ReadInteger<size_t>("bytes", &state->vm()->om->loe_usage()));
+    large->add(new ReadInteger<size_t>("bytes", &state->memory()->loe_usage()));
 
     Tree* code = mem->get_tree("code");
-    code->add(new ReadInteger<size_t>("bytes", &state->vm()->om->code_usage()));
+    code->add(new ReadInteger<size_t>("bytes", &state->memory()->code_usage()));
 
     Tree* symbols = mem->get_tree("symbols");
     symbols->add(new ReadInteger<size_t>("bytes", &ss.symbols.bytes_used()));
 
     Tree* counter = mem->get_tree("counter");
     counter->add(new ReadAtomicInteger("young_objects",
-                       state->vm()->om->gc_stats.young_objects_allocated));
+                       state->memory()->gc_stats.young_objects_allocated));
     counter->add(new ReadAtomicInteger("young_bytes",
-                       state->vm()->om->gc_stats.young_bytes_allocated));
+                       state->memory()->gc_stats.young_bytes_allocated));
     counter->add(new ReadAtomicInteger("promoted_objects",
-                       state->vm()->om->gc_stats.promoted_objects_allocated));
+                       state->memory()->gc_stats.promoted_objects_allocated));
     counter->add(new ReadAtomicInteger("promoted_bytes",
-                       state->vm()->om->gc_stats.promoted_bytes_allocated));
+                       state->memory()->gc_stats.promoted_bytes_allocated));
     counter->add(new ReadAtomicInteger("mature_objects",
-                       state->vm()->om->gc_stats.mature_objects_allocated));
+                       state->memory()->gc_stats.mature_objects_allocated));
     counter->add(new ReadAtomicInteger("mature_bytes",
-                       state->vm()->om->gc_stats.mature_bytes_allocated));
+                       state->memory()->gc_stats.mature_bytes_allocated));
 
     Tree* gc_young = system_->get_tree("gc")->get_tree("young");
 
     gc_young->add(new ReadAtomicInteger("count",
-                       state->vm()->om->gc_stats.young_collection_count));
+                       state->memory()->gc_stats.young_collection_count));
     gc_young->add(new ReadAtomicInteger("total_wallclock",
-                       state->vm()->om->gc_stats.total_young_collection_time));
+                       state->memory()->gc_stats.total_young_collection_time));
     gc_young->add(new ReadAtomicInteger("last_wallclock",
-                       state->vm()->om->gc_stats.last_young_collection_time));
+                       state->memory()->gc_stats.last_young_collection_time));
 
     Tree* gc_full = system_->get_tree("gc")->get_tree("full");
     gc_full->add(new ReadAtomicInteger("count",
-                       state->vm()->om->gc_stats.full_collection_count));
+                       state->memory()->gc_stats.full_collection_count));
     gc_full->add(new ReadAtomicInteger("total_wallclock",
-                       state->vm()->om->gc_stats.total_full_collection_time));
+                       state->memory()->gc_stats.total_full_collection_time));
     gc_full->add(new ReadAtomicInteger("last_wallclock",
-                       state->vm()->om->gc_stats.last_full_collection_time));
+                       state->memory()->gc_stats.last_full_collection_time));
 
     Tree* jit = system_->get_tree("jit");
     jit->add(new ReadAtomicInteger("methods", ss.stats.jitted_methods));

vm/builtin/access_variable.cpp

@@ -91,7 +91,7 @@ namespace rubinius {
 
       if(self->reference_p()) {
         // Promote this to use a direct accessor
-        if(TypeInfo* ti = state->vm()->om->find_type_info(self)) {
+        if(TypeInfo* ti = state->memory()->find_type_info(self)) {
           TypeInfo::Slots::iterator it = ti->slots.find(access->name()->index());
           if(it != ti->slots.end()) {
             // Found one!
@@ -117,7 +117,7 @@ namespace rubinius {
 
     if(self->reference_p()) {
       // Promote this to use a direct accessor
-      if(TypeInfo* ti = state->vm()->om->find_type_info(self)) {
+      if(TypeInfo* ti = state->memory()->find_type_info(self)) {
         TypeInfo::Slots::iterator it = ti->slots.find(access->name()->index());
         if(it != ti->slots.end()) {
           // Found one!

vm/builtin/bytearray.cpp

@@ -41,7 +41,7 @@ namespace rubinius {
     assert(bytes >= 0 && bytes < INT32_MAX);
 
     size_t body = bytes;
-    ByteArray* ba = state->vm()->om->new_object_bytes_mature<ByteArray>(state, G(bytearray), body);
+    ByteArray* ba = state->memory()->new_object_bytes_mature<ByteArray>(state, G(bytearray), body);
     if(unlikely(!ba)) {
       Exception::memory_error(state);
     }

vm/builtin/chararray.cpp

@@ -39,7 +39,7 @@ namespace rubinius {
     assert(bytes >= 0 && bytes < INT32_MAX);
 
     size_t body = bytes;
-    CharArray* ba = state->vm()->om->new_object_bytes_mature<CharArray>(state, G(chararray), body);
+    CharArray* ba = state->memory()->new_object_bytes_mature<CharArray>(state, G(chararray), body);
     if(unlikely(!ba)) {
       Exception::memory_error(state);
     }

vm/builtin/class.cpp

@@ -25,15 +25,15 @@
 namespace rubinius {
 
   Class* Class::create(STATE, Class* super) {
-    Class* cls = state->vm()->om->new_object_enduring<Class>(state, G(klass));
+    Class* cls = state->memory()->new_object_enduring<Class>(state, G(klass));
 
     cls->init(state->vm()->shared.inc_class_count(state));
 
     cls->name(state, nil<Symbol>());
     cls->instance_type(state, super->instance_type());
 
     if(super->type_info()->type == PackedObject::type) {
-      cls->set_type_info(state->vm()->om->type_info[ObjectType]);
+      cls->set_type_info(state->memory()->type_info[ObjectType]);
     } else {
       cls->set_type_info(super->type_info());
     }
@@ -48,12 +48,12 @@ namespace rubinius {
   }
 
   Class* Class::s_allocate(STATE) {
-    Class* cls = as<Class>(state->vm()->om->new_object_enduring<Class>(state, G(klass)));
+    Class* cls = as<Class>(state->memory()->new_object_enduring<Class>(state, G(klass)));
 
     cls->init(state->vm()->shared.inc_class_count(state));
     cls->setup(state);
 
-    cls->set_type_info(state->vm()->om->type_info[ObjectType]);
+    cls->set_type_info(state->memory()->type_info[ObjectType]);
     return cls;
   }
 
@@ -81,7 +81,7 @@ namespace rubinius {
         obj->init_header(self, YoungObjectZone, PackedObject::type);
       } else {
         obj = reinterpret_cast<PackedObject*>(
-            state->vm()->om->new_object_fast(state, self, size, PackedObject::type));
+            state->memory()->new_object_fast(state, self, size, PackedObject::type));
       }
 
       // Don't use 'this' !!! The above code might have GC'd
@@ -115,7 +115,7 @@ namespace rubinius {
             obj->init_header(self, YoungObjectZone, PackedObject::type);
           } else {
             obj = reinterpret_cast<PackedObject*>(
-                state->vm()->om->new_object_fast(state, self, size, PackedObject::type));
+                state->memory()->new_object_fast(state, self, size, PackedObject::type));
           }
         } else {
           return collect_and_allocate(state, gct, self, calling_environment);
@@ -183,7 +183,7 @@ namespace rubinius {
 
     instance_type(state, sup->instance_type());
     if(sup->type_info()->type == PackedObject::type) {
-      set_type_info(state->vm()->om->type_info[ObjectType]);
+      set_type_info(state->memory()->type_info[ObjectType]);
     } else {
       set_type_info(sup->type_info());
     }
@@ -195,7 +195,7 @@ namespace rubinius {
 
   void Class::set_object_type(STATE, size_t type) {
     instance_type(state, Fixnum::from(type));
-    type_info_ = state->vm()->om->type_info[type];
+    type_info_ = state->memory()->type_info[type];
   }
 
   /* Look at this class and it's superclass contents (which includes
@@ -271,14 +271,14 @@ namespace rubinius {
 
   SingletonClass* SingletonClass::attach(STATE, Object* obj, Class* sup) {
     SingletonClass *sc;
-    sc = state->vm()->om->new_object_enduring<SingletonClass>(state, G(klass));
+    sc = state->memory()->new_object_enduring<SingletonClass>(state, G(klass));
     sc->init(state->vm()->shared.inc_class_count(state));
 
     sc->attached_instance(state, obj);
     sc->setup(state);
 
     if(kind_of<PackedObject>(obj)) {
-      sc->set_type_info(state->vm()->om->type_info[Object::type]);
+      sc->set_type_info(state->memory()->type_info[Object::type]);
     } else {
       sc->set_type_info(obj->klass()->type_info());
     }

vm/builtin/data.cpp

@@ -21,7 +21,7 @@ namespace rubinius {
 
     // Data is just a heap alias for the handle, so go ahead and create
     // the handle and populate it as an RData now.
-    InflatedHeader* ih = state->vm()->om->inflate_header(state, data);
+    InflatedHeader* ih = state->memory()->inflate_header(state, data);
     capi::Handle* handle = ih->handle();
 
     assert(!handle && "can't already have a handle, it's brand new!");
@@ -45,14 +45,14 @@ namespace rubinius {
     // If this Data requires a free function, register this object
     // as needing finalization.
     if(free) {
-      state->vm()->om->needs_finalization(data, (FinalizerFunction)&Data::finalize);
+      state->memory()->needs_finalization(data, (FinalizerFunction)&Data::finalize);
     }
 
     return data;
   }
 
   RDataShadow* Data::slow_rdata(STATE) {
-    InflatedHeader* ih = state->vm()->om->inflate_header(state, this);
+    InflatedHeader* ih = state->memory()->inflate_header(state, this);
     capi::Handle* handle = ih->handle();
 
     assert(handle && handle->is_rdata() && "invalid initialized Data object");

vm/builtin/dir.cpp

@@ -23,7 +23,7 @@ namespace rubinius {
     Dir* d = state->new_object<Dir>(G(dir));
     d->os_ = 0;
 
-    state->vm()->om->needs_finalization(d, (FinalizerFunction)&Dir::finalize);
+    state->memory()->needs_finalization(d, (FinalizerFunction)&Dir::finalize);
 
     return d;
   }

vm/builtin/ffi_pointer.cpp

@@ -123,7 +123,7 @@ namespace rubinius {
     autorelease = val->true_p() ? true : false;
 
     if(autorelease && !set_finalizer) {
-      state->vm()->om->needs_finalization(this,
+      state->memory()->needs_finalization(this,
           (FinalizerFunction)&Pointer::finalize);
       set_finalizer = true;
     }

vm/builtin/fiber.cpp

@@ -140,7 +140,7 @@ namespace rubinius {
     if(fib->nil_p()) {
       fib = state->new_object<Fiber>(G(fiber));
       if(fib->zone() != YoungObjectZone) {
-        state->vm()->om->remember_object(fib);
+        state->memory()->remember_object(fib);
       }
       fib->prev_ = nil<Fiber>();
       fib->top_ = 0;
@@ -156,7 +156,7 @@ namespace rubinius {
       fib->context_ = new ucontext_t;
 #endif
 
-      state->vm()->om->needs_finalization(fib, (FinalizerFunction)&Fiber::finalize);
+      state->memory()->needs_finalization(fib, (FinalizerFunction)&Fiber::finalize);
 
       state->vm()->current_fiber.set(fib);
       state->vm()->root_fiber.set(fib);
@@ -232,7 +232,7 @@ namespace rubinius {
 
     Fiber* fib = state->new_object<Fiber>(G(fiber));
     if(fib->zone() != YoungObjectZone) {
-      state->vm()->om->remember_object(fib);
+      state->memory()->remember_object(fib);
     }
     fib->starter(state, callable);
     fib->prev(state, nil<Fiber>());
@@ -243,7 +243,7 @@ namespace rubinius {
     fib->stack_size_ = stack_size;
     fib->stack_ = malloc(stack_size);
 
-    state->vm()->om->needs_finalization(fib, (FinalizerFunction)&Fiber::finalize);
+    state->memory()->needs_finalization(fib, (FinalizerFunction)&Fiber::finalize);
 
 #ifdef FIBER_NATIVE
     fib->context_ = new fiber_context_t;

vm/builtin/find_object.cpp

@@ -157,7 +157,7 @@ namespace rubinius {
       if(obj->ivars() == target_) return true;
 
       // Check slots.
-      TypeInfo* ti = state->vm()->om->type_info[obj->type_id()];
+      TypeInfo* ti = state->memory()->type_info[obj->type_id()];
       for(TypeInfo::Slots::iterator i = ti->slots.begin();
           i != ti->slots.end();
           ++i) {
@@ -257,7 +257,7 @@ namespace rubinius {
   Object* System::vm_find_object(STATE, Array* arg, Object* callable,
                                  CallFrame* calling_environment)
   {
-    ObjectMemory::GCInhibit inhibitor(state->vm()->om);
+    ObjectMemory::GCInhibit inhibitor(state->memory());
 
     // Support an aux mode, where callable is an array and we just append
     // objects to it rather than #call it.
@@ -290,7 +290,7 @@ namespace rubinius {
     }
 
     state->set_call_frame(calling_environment);
-    ObjectWalker walker(state->vm()->om);
+    ObjectWalker walker(state->memory());
     GCData gc_data(state->vm());
 
     // Seed it with the root objects.

vm/builtin/heap_dump.cpp

@@ -230,7 +230,7 @@ namespace rubinius {
 
   static Layout* find_layout(STATE, Object* obj, Layout* root, Array* ary, SymbolList& syms) {
     // Collect all the ivar names that we want to pull out
-    TypeInfo* ti = state->vm()->om->type_info[obj->type_id()];
+    TypeInfo* ti = state->memory()->type_info[obj->type_id()];
     for(TypeInfo::Slots::iterator i = ti->slots.begin();
         i != ti->slots.end();
         ++i) {
@@ -388,7 +388,7 @@ namespace rubinius {
   };
 
   Object* System::vm_dump_heap(STATE, String* path) {
-    ObjectWalker walker(state->vm()->om);
+    ObjectWalker walker(state->memory());
     GCData gc_data(state->vm());
 
     // Seed it with the root objects.

vm/builtin/io.cpp

@@ -75,7 +75,7 @@ namespace rubinius {
 
     // Don't bother to add finalization for stdio
     if(fd >= 3) {
-      state->vm()->om->needs_finalization(io, (FinalizerFunction)&IO::finalize);
+      state->memory()->needs_finalization(io, (FinalizerFunction)&IO::finalize);
     }
 
     return io;
@@ -92,7 +92,7 @@ namespace rubinius {
     // Ensure the instance's class is set (i.e. for subclasses of IO)
     io->klass(state, as<Class>(self));
 
-    state->vm()->om->needs_finalization(io, (FinalizerFunction)&IO::finalize);
+    state->memory()->needs_finalization(io, (FinalizerFunction)&IO::finalize);
 
     return io;
   }

vm/builtin/module.cpp

@@ -28,7 +28,7 @@ namespace rubinius {
   }
 
   Module* Module::create(STATE) {
-    Module* mod = state->vm()->om->new_object_enduring<Module>(state, G(module));
+    Module* mod = state->memory()->new_object_enduring<Module>(state, G(module));
 
     mod->name(state, nil<Symbol>());
     mod->superclass(state, nil<Module>());
@@ -375,7 +375,7 @@ namespace rubinius {
 
   IncludedModule* IncludedModule::create(STATE) {
     IncludedModule* imod;
-    imod = state->vm()->om->new_object_enduring<IncludedModule>(state, G(included_module));
+    imod = state->memory()->new_object_enduring<IncludedModule>(state, G(included_module));
 
     imod->name(state, state->symbol("<included module>"));
     imod->superclass(state, nil<Module>());

vm/builtin/nativemethod.cpp

@@ -61,7 +61,7 @@ namespace rubinius {
   }
 
   VALUE NativeMethodFrame::get_handle(STATE, Object* obj) {
-    InflatedHeader* ih = state->vm()->om->inflate_header(state, obj);
+    InflatedHeader* ih = state->memory()->inflate_header(state, obj);
 
     capi::Handle* handle = ih->handle();