gc_tracer 0.3.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d40ce88a683ae35d05716971bb306c3b796cf223
-  data.tar.gz: c6b1f8d10cdb302ff382f48bcbc9ce54b0a79ecc
+  metadata.gz: e93e7dfe6c23589a2f0fe11353cffb53dc903632
+  data.tar.gz: 2cb9278fbf2b4ba77e809b05421e1c5593cb3336
 SHA512:
-  metadata.gz: b5a14088fedc2332d5a9bcf43e0f080a7eea7875d82227dc20ed6c2fc685d1d29add57bbd68f7ecc61155cea27602e0a9f8c2351b609d07f4f2f0e8a0775b1c8
-  data.tar.gz: 156d0e736ae8421c6fd0808dd7eef3965fa41974534cb2d06388289aef545cfa9a33deb45f04932129b18a66fa69119968f2f37719c05857943c0a532abfe996
+  metadata.gz: f9ae74ac0d8577dd8b48b4bfaddaeb85af2aedbf70838b0f796b6eaf65193300d6e41804d28dda93861fb4b211b6bf1c71586850a811b49c390df741b18c0543
+  data.tar.gz: a1c6d9e8b33f96f664894462750add5481e7ea90ef2420742ecb030b2bd39e5ac9c9dba017e5c58b8ddea99292f9ee9c4b98a2919b23337bc026eec04d0181f3

data/README.md

@@ -23,7 +23,7 @@ Or install it yourself as:
 gc_tracer gem adds GC::Tracer module. GC::Tracer module has the following features.
 
 - Logging GC statistics information
-- ObjectSpace recorder
+- ObjectSpace recorder (not supported yet)
 
 ### Logging
 
@@ -56,59 +56,49 @@ In the stored file (filename), you can get tab separated values of:
 
 at each events, there are one of:
 
-* GC starting time
-* End of marking time
-* End of sweeping time
+* GC starting time (start)
+* End of marking time (end_mark)
+* End of sweeping time (end_sweep)
+* GC enter (enter)
+* GC exit (exit)
+* newobj (newobj)
+* freeobj (freeobj)
 
 For one GC, you can get all three lines.
 
-### ObjectSpace recorder
-
-You can records objspace snapshots on each events.  Snapshots are stored 
-in the [PPM (P6) format] (http://en.wikipedia.org/wiki/Netpbm_format).
+You can specify events by event name symbols you want to show.
 
 ```ruby
 require 'gc_tracer'
-GC::Tracer.start_objspace_recording(dirname) do
+begin
+  GC::Tracer.start_logging(filename, events: %i(enter exit))
   # do something
+ensure
+  GC::Tracer.stop_logging
 end
 ```
 
-All PPM images are stored in dirname/ppm/.
-
-If you have netpbm package and pnmtopng command, 
-bin/objspace_recorder_convert.rb converts all ppm images into png files. 
-Converted png images stored into dirname/png/.
-
-To view converted images, "dirname/viewer.html" is created.
-You can view all converted png images with "dirname/viewer.html" file in animation.
-
-This feature is supported only latest Ruby versions (2.2, and later).
-
-#### Example
+Default events are "start", "end_mark" and "end_sweep". You can specify 
+what kind of information you want to collect.
 
 ```ruby
 require 'gc_tracer'
-GC::Tracer.start_objspace_recording("objspace_recorded_type_example", :type){
-  n =  1_000
-  m = 10_000
-
-  n.times{
-    ary = []
-    m.times{
-      ary << ''
-    }
-  }
-}
+begin
+  GC::Tracer.start_logging(filename, gc_stat: false, gc_latest_gc_info: false, rusage: false)
+  # do something
+ensure
+  GC::Tracer.stop_logging
+end
 ```
 
-This program takes all snapshot of type information at each GC events.
+Above example means that no details information are not needed. Default 
+setting is "gc_stat: true, gc_latest_gc_info: true, rusage: false".
 
-- :age (default) - take snapshots of age information (empty/young/old/shady)
-- :type - take snapshots of type information (T_???)
+You can specify tick (time stamp) type with keyword parameter 
+"tick_type". You can choose one of the tick type in :hw_counter, :time, 
+:user_time and :system_time.
 
-You can see an [age example] (http://www.atdot.net/~ko1/gc_tracer/objspace_recorded_age_example/viewer.html) and
-a [type example] (http://www.atdot.net/~ko1/gc_tracer/objspace_recorded_type_example/viewer.html).
+See lib/gc_tracer.rb for more details.
 
 ## Contributing
 

data/Rakefile

@@ -15,3 +15,8 @@ task default: :spec
 task :run => 'compile' do
   ruby 'test.rb'
 end
+
+task :gdb => 'compile' do
+  system('gdb --args ruby test.rb')
+end
+

data/ext/gc_tracer/gc_tracer.c

@@ -5,6 +5,7 @@
  * created at Wed Feb 26 10:52:59 2014.
  */
 
+#if 0
 #include "ruby/ruby.h"
 #include "ruby/debug.h"
 #include "gc_tracer.h"
@@ -19,15 +20,18 @@ static ID id_young;
 struct gc_hooks {
     VALUE hooks[3];
     VALUE enabled;
-    void (*funcs[3])(void *data, int event_index);
+    void (*funcs[3])(FILE *, void *data, int event_index);
     void *args[3];
     void *data;
+    FILE *out;
 };
 
-static const char *event_names[] = {
+static const char * const event_names[] = {
     "gc_start",
     "gc_end_m",
-    "gc_end_s"
+    "gc_end_s",
+    "gc_enter",
+    "gc_exit_"
 };
 
 /* common funcs */
@@ -36,21 +40,21 @@ static void
 gc_start_i(VALUE tpval, void *data)
 {
     struct gc_hooks *hooks = (struct gc_hooks *)data;
-    (*hooks->funcs[0])(hooks->args[0], 0);
+    (*hooks->funcs[0])(hooks->out, hooks->args[0], 0);
 }
 
 static void
 gc_end_mark_i(VALUE tpval, void *data)
 {
     struct gc_hooks *hooks = (struct gc_hooks *)data;
-    (*hooks->funcs[1])(hooks->args[1], 1);
+    (*hooks->funcs[1])(hooks->out, hooks->args[1], 1);
 }
 
 static void
 gc_end_sweep_i(VALUE tpval, void *data)
 {
     struct gc_hooks *hooks = (struct gc_hooks *)data;
-    (*hooks->funcs[2])(hooks->args[2], 2);
+    (*hooks->funcs[2])(hooks->out, hooks->args[2], 2);
 }
 
 static void
@@ -95,7 +99,6 @@ stop_gc_hooks(struct gc_hooks *hooks)
 /* logger */
 
 struct gc_hooks logger;
-static FILE *gc_trace_out = NULL;
 static VALUE gc_trace_items, gc_trace_items_types;
 
 #ifdef HAVE_GETRUSAGE
@@ -112,113 +115,20 @@ enum gc_key_type {
 #endif
 };
 
-/* the following code is only for internal tuning. */
-
-/* Source code to use RDTSC is quoted and modified from
- * http://www.mcs.anl.gov/~kazutomo/rdtsc.html
- * written by Kazutomo Yoshii <kazutomo@mcs.anl.gov>
- */
-
-#if defined(__GNUC__) && defined(__i386__)
-typedef unsigned long long tick_t;
-
-static inline tick_t
-tick(void)
-{
-    unsigned long long int x;
-    __asm__ __volatile__ ("rdtsc" : "=A" (x));
-    return x;
-}
-
-#elif defined(__GNUC__) && defined(__x86_64__)
-typedef unsigned long long tick_t;
-
-static __inline__ tick_t
-tick(void)
-{
-    unsigned long hi, lo;
-    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
-    return ((unsigned long long)lo)|( ((unsigned long long)hi)<<32);
-}
-
-#elif defined(_WIN32) && defined(_MSC_VER)
-#include <intrin.h>
-typedef unsigned __int64 tick_t;
-
-static inline tick_t
-tick(void)
-{
-    return __rdtsc();
-}
-
-#else /* use clock */
-typedef clock_t tick_t;
-static inline tick_t
-tick(void)
-{
-    return clock();
-}
-#endif
-
-static tick_t start_tick;
 
 static void
-out_str(const char *str)
-{
-    fprintf(gc_trace_out, "%s\t", str);
-}
-
-static void
-out_terminate(void)
-{
-    fprintf(gc_trace_out, "\n");
-}
-
-static void
-out_sizet(size_t size)
-{
-    fprintf(gc_trace_out, "%lu\t", (unsigned long)size);
-}
-
-static void
-out_tick(void)
-{
-    out_sizet(tick() - start_tick);
-}
-
-static void
-out_obj(VALUE obj)
-{
-    if (NIL_P(obj) || obj == Qfalse) {
-	out_sizet(0);
-    }
-    else if (obj == Qtrue) {
-	out_sizet(1);
-    }
-    else if (SYMBOL_P(obj)) {
-	out_str(rb_id2name(SYM2ID(obj)));
-    }
-    else if (FIXNUM_P(obj)) {
-	out_sizet(FIX2INT(obj));
-    }
-    else {
-	rb_bug("out_obj: unknown object to output");
-    }
-}
-
-static void
-out_header(void)
+out_header(FILE *out, VALUE items, int need_type)
 {
     int i;
 
-    out_str("tick");
-    out_str("type");
+    out_str(out, "tick");
+    if (need_type) out_str(out, "type");
 
-    for (i=0; i<RARRAY_LEN(gc_trace_items); i++) {
-	out_str(rb_id2name(SYM2ID(RARRAY_AREF(gc_trace_items, i))));
+    for (i=0; i<RARRAY_LEN(items); i++) {
+	out_str(out, rb_id2name(SYM2ID(RARRAY_AREF(items, i))));
     }
 
-    out_terminate();
+    out_terminate(out);
 }
 
 #ifdef HAVE_GETRUSAGE
@@ -314,54 +224,88 @@ getrusage_sizet(VALUE sym, struct rusage_cache *rusage_cache)
 #endif
 
 static void
-trace(void *data, int event_index)
+out_items(FILE *out, VALUE items, VALUE items_types)
 {
-    const char *type = (const char *)data;
     int i;
 #ifdef HAVE_GETRUSAGE
     struct rusage_cache rusage_cache = {0};
 #endif
 
-    out_tick();
-    out_str(type);
-
-    for (i=0; i<RARRAY_LEN(gc_trace_items); i++) {
-	enum gc_key_type type = FIX2INT(RARRAY_AREF(gc_trace_items_types, i));
-	VALUE sym = RARRAY_AREF(gc_trace_items, i);
+    for (i=0; i<RARRAY_LEN(items); i++) {
+	enum gc_key_type type = FIX2INT(RARRAY_AREF(items_types, i));
+	VALUE sym = RARRAY_AREF(items, i);
 
 	switch (type) {
 	  case GC_STAT_KEY:
-	    out_sizet(rb_gc_stat(sym));
+	    out_sizet(out, rb_gc_stat(sym));
 	    break;
 	  case GC_LATEST_GC_INFO_KEY:
-	    out_obj(rb_gc_latest_gc_info(sym));
+	    out_obj(out, rb_gc_latest_gc_info(sym));
 	    break;
 #ifdef HAVE_GETRUSAGE
 	  case GC_RUSAGE_TIMEVAL_KEY:
-	    out_sizet((size_t)getrusage_timeval(sym, &rusage_cache));
+	    out_sizet(out, (size_t)getrusage_timeval(sym, &rusage_cache));
 	    break;
 	  case GC_RUSAGE_KEY:
-	    out_sizet(getrusage_sizet(sym, &rusage_cache));
+	    out_sizet(out, getrusage_sizet(sym, &rusage_cache));
 	    break;
 #endif
 	  default:
 	    rb_bug("xyzzy");
 	}
     }
+}
 
-    out_terminate();
+static void
+trace(FILE *out, void *data, int event_index)
+{
+    const char *type = (const char *)data;
+
+    out_tick(out);
+    out_str(out, type);
+    out_items(out, gc_trace_items, gc_trace_items_types);
+    out_terminate(out);
+}
+
+static void
+close_output(FILE *out)
+{
+    fflush(out);
+    if (out != stderr) {
+	fclose(out);
+    }
+}
+
+static FILE *
+open_output(int argc, VALUE *argv)
+{
+    FILE *out = NULL;
+
+    /* setup with args */
+    if (argc == 0) {
+	out = stderr;
+    }
+    else if (argc == 1) {
+	if (RB_TYPE_P(argv[0], T_STRING)) {
+	    const char *filename = StringValueCStr(argv[0]);
+	    if ((out = fopen(filename, "w")) == NULL) {
+		rb_raise(rb_eRuntimeError, "can not open file: %s\n", filename);
+	    }
+	}
+    }
+    else {
+	rb_raise(rb_eArgError, "too many arguments");
+    }
+
+    return out;
 }
 
 static VALUE
 gc_tracer_stop_logging(VALUE self)
 {
     if (logger.enabled) {
-	fflush(gc_trace_out);
-	if (gc_trace_out != stderr) {
-	    fclose(gc_trace_out);
-	}
-	gc_trace_out = NULL;
-
+	close_output(logger.out);
+	logger.out = NULL;
 	stop_gc_hooks(&logger);
     }
 
@@ -374,23 +318,8 @@ gc_tracer_start_logging(int argc, VALUE *argv, VALUE self)
     if (logger.enabled == Qfalse) {
 	int i;
 
-	/* setup with args */
-	if (argc == 0) {
-	    gc_trace_out = stderr;
-	}
-	else if (argc == 1) {
-	    if (RB_TYPE_P(argv[0], T_STRING)) {
-		const char *filename = StringValueCStr(argv[0]);
-		if ((gc_trace_out = fopen(filename, "w")) == NULL) {
-		    rb_raise(rb_eRuntimeError, "can not open file: %s\n", filename);
-		}
-	    }
-	}
-	else {
-	    rb_raise(rb_eArgError, "too many arguments");
-	}
-
-	out_header();
+	logger.out = open_output(argc, argv);
+	out_header(logger.out, gc_trace_items, 1);
 
 	for (i=0; i<3; i++) {
 	    logger.funcs[i] = trace;
@@ -430,18 +359,18 @@ item_type(VALUE sym)
     return 0; /* unreachable */
 }
 
-static VALUE
-gc_tracer_setup_logging(VALUE self, VALUE ary)
+static void
+setup_items(VALUE new_items, VALUE items, VALUE types)
 {
+    VALUE is = rb_ary_new();
+    VALUE ts = rb_ary_new();
     int i;
-    VALUE keys = rb_ary_new(), types = rb_ary_new();
 
-    if (NIL_P(ary)) { /* revert all settings */
-	int i;
+    if (NIL_P(new_items)) {
 
 #define ADD(syms) for (i=0; i<(int)(sizeof(syms)/sizeof(VALUE));i++) { \
-    rb_ary_push(gc_trace_items, syms[i]); \
-    rb_ary_push(gc_trace_items_types, INT2FIX(item_type(syms[i]))); \
+    rb_ary_push(is, syms[i]); \
+    rb_ary_push(ts, INT2FIX(item_type(syms[i]))); \
 }
 	ADD(sym_gc_stat);
 	ADD(sym_latest_gc_info);
@@ -451,23 +380,94 @@ gc_tracer_setup_logging(VALUE self, VALUE ary)
 #endif
     }
     else {
-	if (!RB_TYPE_P(ary, T_ARRAY)) rb_raise(rb_eArgError, "unsupported argument");
+	if (!RB_TYPE_P(new_items, T_ARRAY)) rb_raise(rb_eArgError, "unsupported argument");
 
-	for (i=0; i<RARRAY_LEN(ary); i++) {
-	    VALUE sym = RARRAY_AREF(ary, i);
+	for (i=0; i<RARRAY_LEN(new_items); i++) {
+	    VALUE sym = RARRAY_AREF(new_items, i);
 	    enum gc_key_type type;
 	    if (!SYMBOL_P(sym)) rb_raise(rb_eArgError, "unsupported type");
 	    type = item_type(sym);
-	    rb_ary_push(keys, sym);
-	    rb_ary_push(types, INT2FIX(type));
+	    rb_ary_push(is, sym);
+	    rb_ary_push(ts, INT2FIX(type));
 	}
 
-	rb_ary_replace(gc_trace_items, keys);
-	rb_ary_replace(gc_trace_items_types, types);
+    }
+
+    rb_ary_replace(items, is);
+    rb_ary_replace(types, ts);
+}
+
+static VALUE
+gc_tracer_setup_logging(VALUE self, VALUE ary)
+{
+    setup_items(Qnil, gc_trace_items, gc_trace_items_types);
+    return Qnil;
+}
+
+/* slot logger */
+
+struct slot_logger {
+    VALUE hook;
+    VALUE items;
+    VALUE items_types;
+    FILE *out;
+    VALUE enabled;
+} slot_logger;
+
+static void
+newobj_i(VALUE tpval, void *data)
+{
+    struct slot_logger *sl = &slot_logger;
+
+    out_tick(sl->out);
+    out_items(sl->out, sl->items, sl->items_types);
+    out_terminate(sl->out);
+}
+
+static void
+start_newobj_hook(struct slot_logger *sl)
+{
+    if (sl->hook == 0) {
+	sl->hook = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, NULL);
+	rb_gc_register_mark_object(sl->hook);
+    }
+    rb_tracepoint_enable(sl->hook);
+}
+
+static void
+stop_newobj_hook(struct slot_logger *sl)
+{
+    rb_tracepoint_disable(sl->hook);
+}
+static VALUE
+gc_tracer_stop_slot_logging(VALUE self)
+{
+    if (slot_logger.enabled) {
+	close_output(slot_logger.out);
+	slot_logger.out = NULL;
+	stop_newobj_hook(&slot_logger);
     }
     return Qnil;
 }
 
+static VALUE
+gc_tracer_start_slot_logging(int argc, VALUE *argv, VALUE self)
+{
+    if (slot_logger.enabled == Qfalse) {
+	slot_logger.enabled = Qtrue;
+	slot_logger.out = open_output(argc, argv);
+	out_header(slot_logger.out, slot_logger.items, 0);
+
+	start_newobj_hook(&slot_logger);
+
+	if (rb_block_given_p()) {
+	    rb_ensure(rb_yield, Qnil, gc_tracer_stop_slot_logging, Qnil);
+	}
+    }
+
+    return Qnil;
+}
+
 #ifdef HAVE_RB_OBJSPACE_EACH_OBJECTS_WITHOUT_SETUP
 /* image logging */
 
@@ -675,7 +675,7 @@ objspace_recording_i(void *start, void *end, size_t stride, void *data)
 }
 
 static void
-objspace_recording(void *data, int event_index)
+objspace_recording(FILE *dmy, void *data, int event_index)
 {
     /* const char *event_name = (const char *)data; */
     const char *dirname = (const char *)objspace_recorder.data;
@@ -802,6 +802,8 @@ gc_tracer_start_objspace_recording(int argc, VALUE *argv, VALUE self)
 
 #endif /* HAVE_RB_OBJSPACE_EACH_OBJECTS_WITHOUT_SETUP */
 
+
+
 /**
  * GC::Tracer traces GC/ObjectSpace behavior.
  *
@@ -829,6 +831,9 @@ Init_gc_tracer(void)
     rb_define_module_function(mod, "stop_logging", gc_tracer_stop_logging, 0);
     rb_define_module_function(mod, "setup_logging", gc_tracer_setup_logging, 1);
 
+    rb_define_module_function(mod, "start_slot_logging", gc_tracer_start_slot_logging, -1);
+    rb_define_module_function(mod, "stop_slot_logging", gc_tracer_stop_slot_logging, 0);
+
     /* recording methods */
 #ifdef HAVE_RB_OBJSPACE_EACH_OBJECTS_WITHOUT_SETUP
     rb_define_module_function(mod, "start_objspace_recording", gc_tracer_start_objspace_recording, -1);
@@ -851,6 +856,30 @@ Init_gc_tracer(void)
     gc_trace_items_types = rb_ary_new();
     rb_gc_register_mark_object(gc_trace_items);
     rb_gc_register_mark_object(gc_trace_items_types);
+    setup_items(Qnil, gc_trace_items, gc_trace_items_types);
+
+    /* slot */
+    slot_logger.items = rb_ary_new();
+    slot_logger.items_types = rb_ary_new();
+    rb_gc_register_mark_object(slot_logger.items);
+    rb_gc_register_mark_object(slot_logger.items_types);
+    setup_items(rb_ary_new3(4,
+			    ID2SYM(rb_intern("count")),
+			    ID2SYM(rb_intern("heap_live_slot")),
+			    ID2SYM(rb_intern("heap_free_slot")),
+			    ID2SYM(rb_intern("old_object"))),
+		slot_logger.items, slot_logger.items_types);
+}
 
-    gc_tracer_setup_logging(Qnil, Qnil);
+#endif
+
+#include <ruby/ruby.h>
+
+void Init_gc_tracer_logging(VALUE m_gc_tracer); /* in gc_logging.c */
+
+void
+Init_gc_tracer(void)
+{
+    VALUE mod = rb_define_module_under(rb_mGC, "Tracer");
+    Init_gc_tracer_logging(mod);
 }

data/lib/gc_tracer/version.rb

@@ -1,3 +1,3 @@
 module GC::Tracer
-  VERSION = "0.3.3"
+  VERSION = "1.0.0"
 end

data/lib/gc_tracer.rb

@@ -1,3 +1,38 @@
 require "gc_tracer/version"
 require 'gc_tracer/gc_tracer'
 
+module GC
+  module Tracer
+    def self.start_logging(filename_opt = nil,
+                           filename: nil,
+                           # event filter
+                           events: %i(start end_mark end_sweep),
+                           # tick type (:hw_counter, :time, :user_time, :system_time)
+                           tick_type: :time,
+                           # collect information
+                           gc_stat: true,
+                           gc_latest_gc_info: true,
+                           rusage: false)
+      # setup
+      raise "do not specify two fienames" if filename && filename_opt
+      setup_logging_out(filename_opt || filename)
+      setup_logging_events(*events)
+
+      self.setup_logging_gc_stat = gc_stat
+      self.setup_logging_gc_latest_gc_info = gc_latest_gc_info
+      self.setup_logging_rusage = rusage
+      self.setup_logging_tick_type = tick_type
+
+      if block_given?
+        begin
+          start_logging_
+          yield
+        ensure
+          stop_logging
+        end
+      else
+        start_logging_
+      end
+    end
+  end
+end

data/spec/gc_tracer_spec.rb

@@ -28,6 +28,7 @@ describe GC::Tracer do
     it_behaves_like "logging_test"
   end
 
+=begin not supported now.
   shared_examples "objspace_recorder_test" do
     dirname = "gc_tracer_objspace_recorder_spec.#{$$}"
 
@@ -56,4 +57,5 @@ describe GC::Tracer do
     let(:count){2}
     it_behaves_like "objspace_recorder_test"
   end
+=end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gc_tracer
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Koichi Sasada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-27 00:00:00.000000000 Z
+date: 2014-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -111,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: gc_tracer gem adds GC::Tracer module.