rubinius · Jun 28, 2015 · Jun 30, 2015 · Jul 1, 2015 · Jul 1, 2015 · Jul 1, 2015
diff --git a/library/rubinius/configuration.rb b/library/rubinius/configuration.rb
@@ -167,6 +167,15 @@
     s.vm_variable "log", "$TMPDIR/$PROGRAM_NAME-$USER.log",
       "Logging facility to use: 'syslog', 'console', or path"
 
+    s.vm_variable "log.limit", (10 * 1024 * 1024),
+      "The maximum size of the log file before log rotation is performed"
+
+    s.vm_variable "log.archives", 5,
+      "The number of prior logs that will be saved as '$(system.log).N.Z' zip files"
+
+    s.vm_variable "log.access", 0600,
+      "Permissions on the log file"
+
     s.vm_variable "log.level", "warn",
       "Logging level: fatal, error, warn, info, debug"
 

diff --git a/rakelib/vm.rake b/rakelib/vm.rake
@@ -116,6 +116,7 @@ field_extract_headers = %w[
   vm/builtin/atomic.hpp
   vm/builtin/thread_state.hpp
   vm/builtin/jit.hpp
+  vm/builtin/diagnostics.hpp
 ]
 
 transcoders_src_dir = File.expand_path "../../vendor/oniguruma/enc/trans", __FILE__

diff --git a/vm/builtin/bignum.hpp b/vm/builtin/bignum.hpp
@@ -2,12 +2,14 @@
 #define RBX_BUILTIN_BIGNUM_HPP
 
 #include "tommath.h"
+
 #include "builtin/integer.hpp"
 
 namespace rubinius {
   class Array;
-  class String;
+  class Fixnum;
   class Float;
+  class String;
 
   class Bignum : public Integer {
   public:

diff --git a/vm/builtin/diagnostics.cpp b/vm/builtin/diagnostics.cpp
@@ -0,0 +1,12 @@
+#include "builtin/class.hpp"
+#include "builtin/diagnostics.hpp"
+#include "builtin/lookup_table.hpp"
+
+namespace rubinius {
+  void Diagnostics::init(STATE) {
+    Module* diagnostics = state->new_object<Diagnostics>(G(module));
+    diagnostics->setup(state, "Diagnostics", G(rubinius));
+
+    diagnostics->set_const(state, "Map", LookupTable::create(state));
+  }
+}
diff --git a/vm/builtin/diagnostics.hpp b/vm/builtin/diagnostics.hpp
@@ -0,0 +1,35 @@
+#ifndef RBX_BUILTIN_DIAGNOSTICS_HPP
+#define RBX_BUILTIN_DIAGNOSTICS_HPP
+
+#include "builtin/class.hpp"
+#include "builtin/module.hpp"
+#include "builtin/object.hpp"
+
+#include "object_utils.hpp"
+#include "diagnostics.hpp"
+
+namespace rubinius {
+  class LookupTable;
+
+  class Diagnostics : public Module {
+  public:
+    const static object_type type = DiagnosticsType;
+
+  private:
+    LookupTable* map_;  // slot
+
+  public:
+    attr_accessor(map, LookupTable);
+
+  public:
+    static void init(STATE);
+
+
+    class Info : public Module::Info {
+    public:
+      BASIC_TYPEINFO(Module::Info)
+    };
+  };
+}
+
+#endif
diff --git a/vm/builtin/executable.cpp b/vm/builtin/executable.cpp
@@ -62,8 +62,10 @@ namespace rubinius {
     return dis.send(state, call_frame, args);
   }
 
-  void Executable::add_inliner(ObjectMemory* om, CompiledCode* code) {
-    if(!inliners_ || inliners_ == (Inliners*)cNil) inliners_ = new Inliners(om);
+  void Executable::add_inliner(STATE, ObjectMemory* om, CompiledCode* code) {
+    if(!inliners_ || inliners_ == (Inliners*)cNil) {
+      inliners_ = new Inliners(state, om);
+    }
     inliners_->inliners().push_back(code);
 
     om->write_barrier(this, code);
@@ -106,8 +108,8 @@ namespace rubinius {
     }
   }
 
-  Inliners::Inliners(ObjectMemory* om) {
-    om->add_code_resource(this);
+  Inliners::Inliners(STATE, ObjectMemory* om) {
+    om->add_code_resource(state, this);
   }
 
   void Inliners::cleanup(STATE, CodeManager* cm) {

diff --git a/vm/builtin/executable.hpp b/vm/builtin/executable.hpp
@@ -18,7 +18,7 @@ namespace rubinius {
     std::vector<CompiledCode*> inliners_;
 
   public:
-    Inliners(ObjectMemory* om);
+    Inliners(STATE, ObjectMemory* om);
 
     std::vector<CompiledCode*>& inliners() {
       return inliners_;
@@ -81,7 +81,7 @@ namespace rubinius {
 
     bool resolve_primitive(STATE);
 
-    void add_inliner(ObjectMemory* om, CompiledCode* code);
+    void add_inliner(STATE, ObjectMemory* om, CompiledCode* code);
     void clear_inliners(STATE);
 
     class Info : public TypeInfo {

diff --git a/vm/builtin/native_function.cpp b/vm/builtin/native_function.cpp
@@ -264,7 +264,7 @@ namespace rubinius {
       rubinius::bug("ffi_prep_cif failed");
     }
 
-    state->shared().om->add_code_resource(data);
+    state->shared().om->add_code_resource(state, data);
     this->ffi_data = data;
   }
 

diff --git a/vm/capi/handles.cpp b/vm/capi/handles.cpp
@@ -3,18 +3,30 @@
 #include "gc/baker.hpp"
 #include "capi/capi.hpp"
 #include "capi/handles.hpp"
+#include "util/logger.hpp"
 
 namespace rubinius {
   namespace capi {
+    void Handles::Diagnostics::log() {
+      if(!modified_p()) return;
+
+      diagnostics::Diagnostics::log();
+
+      utilities::logger::write("C-API handles: diagnostics: " \
+          "objects: %ld, bytes: %ld, collections: %ld\n",
+          objects_, bytes_, collections_);
+    }
 
     Handle* Handles::allocate(STATE, Object* obj) {
       bool needs_gc = false;
       Handle* handle = allocator_->allocate(&needs_gc);
       handle->set_object(obj);
       handle->validate();
       if(needs_gc) {
+        diagnostics_.collections_++;
         state->memory()->collect_mature_now = true;
       }
+      diagnostics_.objects_++;
       atomic::memory_barrier();
       return handle;
     }
@@ -29,8 +41,10 @@ namespace rubinius {
       handle->set_object(obj);
       handle->validate();
       if(needs_gc) {
+        diagnostics_.collections_++;
         state->memory()->collect_mature_now = true;
       }
+      diagnostics_.objects_++;
       atomic::memory_barrier();
 
       if(handle_index > UINT32_MAX) {
@@ -58,7 +72,9 @@ namespace rubinius {
       delete allocator_;
     }
 
-    void Handles::deallocate_handles(std::list<Handle*>* cached, unsigned int mark, BakerGC* young) {
+    void Handles::deallocate_handles(std::list<Handle*>* cached,
+        unsigned int mark, BakerGC* young)
+    {
       std::vector<bool> chunk_marks(allocator_->chunks_.size(), false);
 
       for(std::vector<int>::size_type i = 0; i < allocator_->chunks_.size(); ++i) {
@@ -94,6 +110,7 @@ namespace rubinius {
               // A weakref pointing to a dead young object
               } else {
                 handle->clear();
+                diagnostics_.objects_--;
               }
             } else {
               // Not a young object, so won't be GC'd so mark
@@ -104,6 +121,7 @@ namespace rubinius {
           // A weakref pointing to a dead mature object
           } else if(!obj->marked_p(mark)) {
             handle->clear();
+            diagnostics_.objects_--;
           } else {
             chunk_marks[i] = true;
           }
@@ -122,6 +140,9 @@ namespace rubinius {
       }
 
       allocator_->rebuild_freelist(&chunk_marks);
+
+      diagnostics_.bytes_ = allocator_->in_use_;
+      diagnostics_.modify();
     }
   }
 }
diff --git a/vm/capi/handles.hpp b/vm/capi/handles.hpp
@@ -1,27 +1,43 @@
 #ifndef RBX_CAPI_HANDLES_HPP
 #define RBX_CAPI_HANDLES_HPP
 
+#include "diagnostics.hpp"
 #include "vm.hpp"
 #include "gc/root.hpp"
 #include "util/allocator.hpp"
 #include "capi/handle.hpp"
 
 #include <vector>
+#include <stdint.h>
 
 namespace rubinius {
   class BakerGC;
 
   namespace capi {
-
     class Handles {
+    public:
+      class Diagnostics : public diagnostics::MemoryDiagnostics {
+      public:
+        int64_t collections_;
+
+        Diagnostics()
+          : diagnostics::MemoryDiagnostics()
+          , collections_(0)
+        { }
+
+        void log();
+      };
 
     private:
       Allocator<Handle>* allocator_;
 
+      Diagnostics diagnostics_;
+
     public:
 
       Handles()
         : allocator_(new Allocator<Handle>())
+        , diagnostics_(Diagnostics())
       {}
 
       ~Handles();
@@ -48,6 +64,9 @@ namespace rubinius {
         return allocator_->in_use_;
       }
 
+      Diagnostics& diagnostics() {
+        return diagnostics_;
+      }
     };
   }
 }

diff --git a/vm/codegen/field_extract.rb b/vm/codegen/field_extract.rb
@@ -744,7 +744,7 @@ def generate_marks(cpp)
     if(target->#{name}()->reference_p()) {
       Object* old = target->#{name}();
       Object* cur = mark.call(old);
-      if(cur && cur != old) target->#{name}(mark.state(), force_as<#{type}>(cur));
+      if(cur && cur != old) target->#{name}(mark.vm(), force_as<#{type}>(cur));
     }
   }
 

diff --git a/vm/diagnostics.hpp b/vm/diagnostics.hpp
@@ -0,0 +1,42 @@
+#ifndef RBX_DIAGNOSTICS_HPP
+#define RBX_DIAGNOSTICS_HPP
+
+#include <stdint.h>
+
+namespace rubinius {
+  namespace diagnostics {
+    class Diagnostics {
+      bool modified_;
+
+    public:
+      Diagnostics() : modified_(false) { }
+      virtual ~Diagnostics() { }
+
+      virtual void log() {
+        modified_ = false;
+      }
+
+      bool modified_p() {
+        return modified_;
+      }
+
+      void modify() {
+        modified_ = true;
+      }
+    };
+
+    class MemoryDiagnostics : public Diagnostics {
+    public:
+      int64_t objects_;
+      int64_t bytes_;
+
+      MemoryDiagnostics()
+        : Diagnostics()
+        , objects_(0)
+        , bytes_(0)
+      { }
+    };
+  }
+}
+
+#endif
diff --git a/vm/environment.cpp b/vm/environment.cpp
@@ -6,8 +6,8 @@
 #include "config_parser.hpp"
 #include "compiled_file.hpp"
 #include "object_memory.hpp"
-
 #include "exception.hpp"
+#include "system_diagnostics.hpp"
 
 #include "builtin/array.hpp"
 #include "builtin/class.hpp"
@@ -207,6 +207,11 @@ namespace rubinius {
     finalizer_thread_->start(state);
   }
 
+  void Environment::start_diagnostics(STATE) {
+    diagnostics_ = new diagnostics::SystemDiagnostics(
+        state->shared().memory()->diagnostics());
+  }
+
   void Environment::start_logging(STATE) {
     utilities::logger::logger_level level = utilities::logger::eWarn;
 
@@ -232,7 +237,10 @@ namespace rubinius {
       expand_config_value(config.system_log.value, "$USER", shared->username.c_str());
 
       utilities::logger::open(utilities::logger::eFileLogger,
-          config.system_log.value.c_str(), level);
+          config.system_log.value.c_str(), level,
+          config.system_log_limit.value,
+          config.system_log_archives.value,
+          config.system_log_access.value);
     }
   }
 
@@ -833,6 +841,7 @@ namespace rubinius {
     load_platform_conf(runtime);
     boot_vm();
 
+    start_diagnostics(state);
     start_finalizer(state);
 
     load_argv(argc_, argv_);