majo 0.0.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c68eebecd1591a5579a3c44135c7d29c7b46743c0f35c65f8ebd3b557bd78f4a
-  data.tar.gz: 5742f4feabbead870b4becbeb8c40f5591eff79541f3f70dd4aef285c1de5f0d
+  metadata.gz: 5db0056e26ba9974d00512d31930aad34d35af8e5ed9f880eda7665bdb9c2f59
+  data.tar.gz: 7489e069356907943bdf68de696cd3c9071aa4c2918743a5c05ba3b4ce286bf4
 SHA512:
-  metadata.gz: e1e165da4e081ca6886db4631f1052bab452551b073784c90507da80d1f35672edc0a9b7ead753b32c5d1fc7884e8fe87778c76b38c0b8dbadbde417362902db
-  data.tar.gz: 24cfe454a1f38b70f7c1b12d6f4bd3a1cf94384b9f18eabe10e27907e93c5b0e8417e53d405582086571e4cd649ca14d6d4cdd05e5e5b50794ff2994cc1f077f
+  metadata.gz: 3ab8e2fa890a01d0ac7a36c7be6e2adbe492fbd58319888636e6c733459a0f76dbf3d8aedc08cbe68d488f3a11ff54be758f661b0866afa31b2b4c6ce75abae0
+  data.tar.gz: 42ce9c56b603b4f50ff1504a47bf8f1616d384c4e135034be6b7f9d13c9afa6b5f278fde5683b2011ae9a3b024c9dc2f2b87da955b9dfdaad8fd44bb6fd08e1b

data/ARCHITECTURE.md

@@ -0,0 +1,25 @@
+# Architecture of Majo
+
+Majo uses internal TracePoint hooks, `RUBY_INTERNAL_EVENT_NEWOBJ` and `RUBY_INTERNAL_EVENT_FREEOBJ`, to trace object allocation and free events.
+We can use `ObjectSpace.trace_object_allocations_start` method in the Ruby-level, but this API is not suitable for Majo because it does not provide information about freed objects. Therefore, Majo uses these hooks in the C-level.
+
+## On allocation event
+
+When an object is allocated, Majo records the object into a st table with the path, line number, and so on.
+
+See `newobj_i` function in `majo.c`.
+
+## On free event
+
+When an object is freed, Majo moves the allocation information to an array from the st table if it's a long-lived object.
+It determines whether the object is long-lived by checking the GC count. If the object is not swept by a GC sweeping phase, it's a long-lived object.
+
+See `freeobj_i` function in `majo.c`.
+
+## Output format
+
+Majo provides three output formats: `color`, `monochrome`, and `csv`.
+
+`color` and `monochrome` are for human-readable output. They provide overview information about long-lived objects.
+
+`csv` is for machine-readable output. It provides the raw information. You can use this format to analyze the result with other tools.

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# CHANGELOG
+
+## v1.0.0 - 2024-07-26
+
+The first stable release of Majo!
+
+* Report retained objects [#32](https://github.com/pocke/majo/pull/32)
+* Add options for upper and lower threshold of lifetime [#34](https://github.com/pocke/majo/pull/34)
+* Display class path for singleton method call [#37](https://github.com/pocke/majo/pull/37)
+
+## v0.1.0 - 2024-07-25
+
+* Initial release

data/README.md

@@ -37,10 +37,10 @@ result.report
 
 You can pass the following options to `report` method.
 
-| Name        | Description              | Default   | Type                                                                     |
-| ----------- | ------------------------ | --------- | ------------------------------------------------------------------------ |
-| `out`       | Output file or IO        | `$stdout` | `IO`, `String` or an object having `to_path` method (such as `Pathname`) |
-| `formatter` | The format of the result | `:color`  | `:color`, or `:csv`                                                      |
+| Name        | Description              | Default                  | Type                                                                     |
+| ----------- | ------------------------ | ------------------------ | ------------------------------------------------------------------------ |
+| `out`       | Output file or IO        | `$stdout`                | `IO`, `String` or an object having `to_path` method (such as `Pathname`) |
+| `formatter` | The format of the result | `:color` or `monochrome` | `:color`, `:monochrome`, or `:csv`                                       |
 
 For example:
 
@@ -54,7 +54,7 @@ result.report(out: "majo-result.csv", formatter: :csv)
 
 ### Result Example
 
-The result contains only long-lived objects, which are collected by the major GC.
+The result contains only long-lived objects, which are collected by the major GC or retained.
 
 The example is as follows:
 
@@ -102,15 +102,53 @@ Objects by class
 22435  RBS::Location
 11144  RBS::TypeName
 (snip)
+
+Retained Memory by file
+-----------------------------------
+7040  /path/to/gems/3.3.0/gems/rbs-3.5.1/lib/rbs/parser_aux.rb
+ 256  /path/to/gems/3.3.0/gems/rbs-3.5.1/lib/rbs/resolver/type_name_resolver.rb
+(snip)
+
+Retained Memory by location
+-----------------------------------
+7040  /path/to/gems/3.3.0/gems/rbs-3.5.1/lib/rbs/parser_aux.rb:20
+ 256  /path/to/gems/3.3.0/gems/rbs-3.5.1/lib/rbs/resolver/type_name_resolver.rb:22
+(snip)
+
+Retained Memory by class
+-----------------------------------
+6920  String
+ 256  Hash
+ 120  Symbol
+(snip)
+
+Retained Objects by file
+-----------------------------------
+160  /path/to/gems/3.3.0/gems/rbs-3.5.1/lib/rbs/parser_aux.rb
+  1  /path/to/gems/3.3.0/gems/rbs-3.5.1/lib/rbs/resolver/type_name_resolver.rb
+(snip)
+
+Retained Objects by location
+-----------------------------------
+160  /path/to/gems/3.3.0/gems/rbs-3.5.1/lib/rbs/parser_aux.rb:20
+  1  /path/to/gems/3.3.0/gems/rbs-3.5.1/lib/rbs/resolver/type_name_resolver.rb:22
+(snip)
+
+Retained Objects by class
+-----------------------------------
+157  String
+  3  Symbol
+  1  Hash
+(snip)
 ```
 
 The CSV format is as follows:
 
 ```csv
-Object class path,Class path,Method ID,Path,Line,Alloc generation,Free generation,Memsize,Count
-Hash,,_parse_signature,/path/to/gems/rbs-3.5.1/lib/rbs/parser_aux.rb,20,20,22,160,3
-Hash,RBS::EnvironmentLoader,each_signature,/path/to/gems/rbs-3.5.1/lib/rbs/environment_loader.rb,159,20,22,160,1
-Hash,,_parse_signature,/path/to/gems/rbs-3.5.1/lib/rbs/parser_aux.rb,20,21,23,160,1
+Object class path,Class path,Method ID,Singleton method,Path,Line,Alloc generation,Free generation,Memsize,Count
+Hash,RBS::Parser,_parse_signature,true,/path/to/gems/rbs-3.5.1/lib/rbs/parser_aux.rb,20,20,22,160,3
+Hash,RBS::EnvironmentLoader,each_signature,false,/path/to/gems/rbs-3.5.1/lib/rbs/environment_loader.rb,159,20,22,160,1
+Hash,RBS::Parser,_parse_signature,true,/path/to/gems/rbs-3.5.1/lib/rbs/parser_aux.rb,20,21,23,160,1
 (snip)
 ```
 
@@ -118,17 +156,18 @@ You can find the raw data in the CSV format. It is useful for further analysis.
 
 The columns are as follows:
 
-| Column name         | Description                                                        |
-| ------------------- | ------------------------------------------------------------------ |
-| `Object class path` | The class name of the allocated object                             |
-| `Class path`        | The class name of the receiver of the method allocating the object |
-| `Method ID`         | The method name allocating the object                              |
-| `Path`              | The file path of the method allocating the object                  |
-| `Line`              | The line number of the method allocating the object                |
-| `Alloc generation`  | The GC generation number when the object is allocated              |
-| `Free generation`   | The GC generation number when the object is freed                  |
-| `Memsize`           | The memory size of the object in bytes                             |
-| `Count`             | Number of objects allocated with the same conditions               |
+| Column name         | Description                                                                         |
+| ------------------- | ----------------------------------------------------------------------------------- |
+| `Object class path` | The class name of the allocated object                                              |
+| `Class path`        | The class name of the receiver of the method allocating the object                  |
+| `Method ID`         | The method name allocating the object                                               |
+| `Singleton method`  | `true` if the method call is for a singleton method                                 |
+| `Path`              | The file path of the method allocating the object                                   |
+| `Line`              | The line number of the method allocating the object                                 |
+| `Alloc generation`  | The GC generation number when the object is allocated                               |
+| `Free generation`   | The GC generation number when the object is freed. It's empty for retained objects. |
+| `Memsize`           | The memory size of the object in bytes                                              |
+| `Count`             | Number of objects allocated with the same conditions                                |
 
 ## Name
 

data/ext/majo/allocation_info.c

@@ -2,13 +2,12 @@
 
 static void majo_allocation_info_mark(void *ptr)
 {
-  // TODO
   majo_allocation_info *info = (majo_allocation_info*)ptr;
+  rb_gc_mark(info->result);
 }
 
 static void majo_allocation_info_free(majo_allocation_info *info) {
-  // TODO
-  ruby_xfree(info);
+  free(info);
 }
 
 static size_t majo_allocation_info_memsize(const void *ptr) {
@@ -85,6 +84,12 @@ allocation_info_method_id(VALUE self) {
   return info->mid;
 }
 
+static VALUE
+allocation_info_singleton_p(VALUE self) {
+  majo_allocation_info *info = majo_check_allocation_info(self);
+  return info->singleton_p ? Qtrue : Qfalse;
+}
+
 static VALUE
 allocation_info_alloc_generation(VALUE self) {
   majo_allocation_info *info = majo_check_allocation_info(self);
@@ -94,6 +99,9 @@ allocation_info_alloc_generation(VALUE self) {
 static VALUE
 allocation_info_free_generation(VALUE self) {
   majo_allocation_info *info = majo_check_allocation_info(self);
+  if (info->free_generation == 0) {
+    return Qnil;
+  }
   return SIZET2NUM(info->free_generation);
 }
 
@@ -111,6 +119,7 @@ majo_init_allocation_info() {
   rb_define_method(rb_cMajo_AllocationInfo, "path", allocation_info_path, 0);
   rb_define_method(rb_cMajo_AllocationInfo, "class_path", allocation_info_class_path, 0);
   rb_define_method(rb_cMajo_AllocationInfo, "method_id", allocation_info_method_id, 0);
+  rb_define_method(rb_cMajo_AllocationInfo, "singleton?", allocation_info_singleton_p, 0);
   rb_define_method(rb_cMajo_AllocationInfo, "line", allocation_info_line, 0);
   rb_define_method(rb_cMajo_AllocationInfo, "object_class_path", allocation_info_object_class_path, 0);
   rb_define_method(rb_cMajo_AllocationInfo, "alloc_generation", allocation_info_alloc_generation, 0);

data/ext/majo/allocation_info.h

@@ -7,10 +7,13 @@ typedef struct {
   const char *object_class_path;
   unsigned long line;
   VALUE mid;
+  bool singleton_p;
 
   size_t alloc_generation;
   size_t free_generation;
   size_t memsize;
+
+  VALUE result;
 } majo_allocation_info;
 
 VALUE

data/ext/majo/attached_object.c

@@ -0,0 +1,26 @@
+#include "majo.h"
+
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR == 1
+
+static ID id_attached;
+
+VALUE
+majo_attached_object(VALUE klass) {
+  if (!FL_TEST(klass, FL_SINGLETON)) {
+    rb_raise(rb_eTypeError, "`%"PRIsVALUE"' is not a singleton class", klass);
+  }
+
+  return rb_attr_get(klass, id_attached);
+}
+
+void
+majo_init_attached_object() {
+  id_attached = rb_intern_const("__attached__");
+}
+
+#else
+
+void
+majo_init_attached_object() {}
+
+#endif

data/ext/majo/attached_object.h

@@ -0,0 +1,13 @@
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR == 1
+
+VALUE
+majo_attached_object(VALUE klass);
+
+#else
+
+#define majo_attached_object(klass) rb_class_attached_object(klass)
+
+#endif
+
+void
+majo_init_attached_object();

data/ext/majo/majo.c

@@ -36,10 +36,23 @@ internal_object_p(VALUE obj)
   }
 }
 
+static const char*
+to_class_path(VALUE klass, st_table *str_table)
+{
+  if (FL_TEST(klass, FL_SINGLETON)) {
+    return to_class_path(majo_attached_object(klass), str_table);
+  }
+
+  VALUE class_path = (RTEST(klass) && !OBJ_FROZEN(klass)) ? rb_class_path_cached(klass) : Qnil;
+  const char *class_path_cstr = RTEST(class_path) ? majo_make_unique_str(str_table, RSTRING_PTR(class_path), RSTRING_LEN(class_path)) : 0;
+  return class_path_cstr;
+}
+
 static void
 newobj_i(VALUE tpval, void *data)
 {
-  majo_result *arg = (majo_result *)data;
+  VALUE res = (VALUE)data;
+  majo_result *arg = majo_check_result(res);
 
   rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
   VALUE obj = rb_tracearg_object(tparg);
@@ -53,22 +66,19 @@ newobj_i(VALUE tpval, void *data)
   VALUE mid = rb_tracearg_method_id(tparg);
   VALUE klass = rb_tracearg_defined_class(tparg);
 
-  // TODO: when the st already has an entry for the value
   majo_allocation_info *info = (majo_allocation_info *)malloc(sizeof(majo_allocation_info));
 
   const char *path_cstr = RTEST(path) ? majo_make_unique_str(arg->str_table, RSTRING_PTR(path), RSTRING_LEN(path)) : 0;
-
-  VALUE class_path = (RTEST(klass) && !OBJ_FROZEN(klass)) ? rb_class_path_cached(klass) : Qnil;
-  const char *class_path_cstr = RTEST(class_path) ? majo_make_unique_str(arg->str_table, RSTRING_PTR(class_path), RSTRING_LEN(class_path)) : 0;
+  const char *class_path_cstr = to_class_path(klass, arg->str_table);
 
   VALUE obj_class = rb_obj_class(obj);
-  VALUE obj_class_path = (RTEST(obj_class) && !OBJ_FROZEN(obj_class)) ? rb_class_path_cached(obj_class) : Qnil;
-  const char *obj_class_path_cstr = RTEST(obj_class_path) ? majo_make_unique_str(arg->str_table, RSTRING_PTR(obj_class_path), RSTRING_LEN(obj_class_path)) : 0;
-
+  const char *obj_class_path_cstr = to_class_path(obj_class, arg->str_table);
 
+  info->result = res;
   info->path = path_cstr;
   info->line = NUM2INT(line);
   info->mid = mid;
+  info->singleton_p = FL_TEST(klass, FL_SINGLETON);
   info->object_class_path = obj_class_path_cstr;
 
   info->class_path = class_path_cstr;
@@ -84,12 +94,14 @@ freeobj_i(VALUE tpval, void *data)
   st_data_t obj = (st_data_t)rb_tracearg_object(tparg);
   st_data_t v;
 
-  // TODO refcount of the strings
   if (st_delete(arg->object_table, &obj, &v)) {
     majo_allocation_info *info = (majo_allocation_info *)v;
     size_t gc_count = rb_gc_count();
-    // Reject it for majo
-    if (info->alloc_generation < gc_count-1) {
+    int lifetime = (int)(gc_count - info->alloc_generation - 1);
+    if (
+      (NIL_P(arg->upper_lifetime) || lifetime <= NUM2INT(arg->upper_lifetime)) &&
+      (NIL_P(arg->lower_lifetime) || NUM2INT(arg->lower_lifetime) <= lifetime)
+    ) {
       info->memsize = rb_obj_memsize_of((VALUE)obj);
       info->free_generation = gc_count;
 
@@ -103,14 +115,16 @@ freeobj_i(VALUE tpval, void *data)
 }
 
 static VALUE
-start(VALUE self) {
+start(VALUE self, VALUE upper_lifetime, VALUE lower_lifetime) {
   VALUE res = majo_new_result();
   majo_result *arg = majo_check_result(res);
+  arg->upper_lifetime = upper_lifetime;
+  arg->lower_lifetime = lower_lifetime;
 
   VALUE stack = rb_ivar_get(rb_mMajo, running_tracer_stack);
   rb_ary_push(stack, res);
 
-  arg->newobj_trace = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, arg);
+  arg->newobj_trace = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, (void *)res);
   arg->freeobj_trace = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_FREEOBJ, freeobj_i, arg);
 
   rb_tracepoint_enable(arg->newobj_trace);
@@ -137,7 +151,7 @@ Init_majo(void)
 {
   rb_mMajo = rb_define_module("Majo");
 
-  rb_define_module_function(rb_mMajo, "__start", start, 0);
+  rb_define_module_function(rb_mMajo, "__start", start, 2);
   rb_define_module_function(rb_mMajo, "__stop", stop, 0);
 
   running_tracer_stack = rb_intern("running_tracer_stack");
@@ -145,4 +159,5 @@ Init_majo(void)
 
   majo_init_result();
   majo_init_allocation_info();
+  majo_init_attached_object();
 }

data/ext/majo/majo.h

@@ -4,6 +4,7 @@
 #include <stdbool.h>
 
 #include "ruby.h"
+#include "ruby/version.h"
 #include "ruby/debug.h"
 #include "ruby/internal/gc.h"
 
@@ -12,6 +13,7 @@
 #include "allocation_info.h"
 #include "result.h"
 #include "unique_str.h"
+#include "attached_object.h"
 
 extern VALUE rb_mMajo;
 extern VALUE rb_cMajo_Result;

data/ext/majo/result.c

@@ -5,16 +5,40 @@ static void majo_result_mark(void *ptr)
   majo_result *arg = (majo_result*)ptr;
   rb_gc_mark(arg->newobj_trace);
   rb_gc_mark(arg->freeobj_trace);
+  rb_gc_mark(arg->retained);
+  rb_gc_mark(arg->upper_lifetime);
+  rb_gc_mark(arg->lower_lifetime);
+}
+
+static int
+free_st_key(st_data_t key, st_data_t value, st_data_t data)
+{
+    free((void *)key);
+    return ST_CONTINUE;
+}
+
+static int
+free_st_value(st_data_t key, st_data_t value, st_data_t data)
+{
+    free((void *)value);
+    return ST_CONTINUE;
 }
 
 static void majo_result_free(majo_result *arg) {
-  // TODO
-  ruby_xfree(arg);
+  st_foreach(arg->object_table, free_st_value, 0);
+  st_free_table(arg->object_table);
+
+  st_foreach(arg->str_table, free_st_key, 0);
+  st_free_table(arg->str_table);
+
+  rb_darray_free(arg->olds);
+
+  free(arg);
 }
 
 static size_t majo_result_memsize(const void *ptr) {
-  // TODO
-  return sizeof(majo_result);
+  majo_result *res = (majo_result*)ptr;
+  return sizeof(majo_result) + st_memsize(res->object_table) + st_memsize(res->str_table) + rb_darray_capa(res->olds) * sizeof(majo_allocation_info);
 }
 
 static rb_data_type_t result_type = {
@@ -29,6 +53,7 @@ static VALUE result_alloc(VALUE klass) {
   arg->object_table = st_init_numtable();
   arg->str_table = st_init_strtable();
   arg->olds = NULL;
+  arg->retained = rb_ary_new();
 
   return obj;
 }
@@ -48,7 +73,7 @@ majo_result_append_info(majo_result *res, majo_allocation_info info) {
   rb_darray_append(&res->olds, info);
 }
 
-VALUE
+static VALUE
 majo_result_allocations(VALUE self) {
   majo_result *res = majo_check_result(self);
   VALUE ary = rb_ary_new_capa(rb_darray_size(res->olds));
@@ -62,10 +87,37 @@ majo_result_allocations(VALUE self) {
   return ary;
 }
 
+static VALUE
+majo_result_retained(VALUE self) {
+  majo_result *res = majo_check_result(self);
+  return res->retained;
+}
+
+static VALUE
+majo_result_store_retained_object(VALUE self, VALUE obj) {
+  majo_result *res = majo_check_result(self);
+
+  st_data_t value;
+  if (st_lookup(res->object_table, (st_data_t)obj, &value)) {
+    majo_allocation_info *info = (majo_allocation_info *)value;
+    int lifetime = (int)(rb_gc_count() - info->alloc_generation - 1);
+    if (NIL_P(res->upper_lifetime) || lifetime <= NUM2INT(res->upper_lifetime)) {
+      info->memsize = rb_obj_memsize_of(obj);
+
+      VALUE info_r = majo_new_allocation_info(info);
+      rb_ary_push(res->retained, info_r);
+    }
+  }
+
+  return Qnil;
+}
+
 void
 majo_init_result() {
   rb_cMajo_Result = rb_define_class_under(rb_mMajo, "Result", rb_cObject);
   rb_define_alloc_func(rb_cMajo_Result, result_alloc);
 
   rb_define_method(rb_cMajo_Result, "allocations", majo_result_allocations, 0);
+  rb_define_method(rb_cMajo_Result, "retained", majo_result_retained, 0);
+  rb_define_method(rb_cMajo_Result, "store_retained_object", majo_result_store_retained_object, 1);
 }

data/ext/majo/result.h

@@ -7,6 +7,10 @@ typedef struct {
   rb_darray(majo_allocation_info) olds;
   VALUE newobj_trace;
   VALUE freeobj_trace;
+  VALUE retained;
+
+  VALUE upper_lifetime;
+  VALUE lower_lifetime;
 } majo_result;
 
 VALUE

data/lib/majo/formatter/color.rb

@@ -8,32 +8,60 @@ module Majo
       end
 
       def call
+        allocs = result.allocations
+        retained = result.retained
+
         <<~RESULT
-          Total #{total_memory} bytes (#{total_objects} objects)
+          Total #{total_memory(allocs)} bytes (#{total_objects(allocs)} objects)
+          Total retained #{total_memory(retained)} bytes (#{total_objects(retained)} objects)
 
           Memory by file
           #{bar}
-          #{format_two_columns(memory_by_file)}
+          #{format_two_columns(memory_by_file(allocs))}
 
           Memory by location
           #{bar}
-          #{format_two_columns(memory_by_location)}
+          #{format_two_columns(memory_by_location(allocs))}
 
           Memory by class
           #{bar}
-          #{format_two_columns(memory_by_class)}
+          #{format_two_columns(memory_by_class(allocs))}
 
           Objects by file
           #{bar}
-          #{format_two_columns(objects_by_file)}
+          #{format_two_columns(objects_by_file(allocs))}
 
           Objects by location
           #{bar}
-          #{format_two_columns(objects_by_location)}
+          #{format_two_columns(objects_by_location(allocs))}
 
           Objects by class
           #{bar}
-          #{format_two_columns(objects_by_class)}
+          #{format_two_columns(objects_by_class(allocs))}
+
+          Retained Memory by file
+          #{bar}
+          #{format_two_columns(memory_by_file(retained))}
+
+          Retained Memory by location
+          #{bar}
+          #{format_two_columns(memory_by_location(retained))}
+
+          Retained Memory by class
+          #{bar}
+          #{format_two_columns(memory_by_class(retained))}
+
+          Retained Objects by file
+          #{bar}
+          #{format_two_columns(objects_by_file(retained))}
+
+          Retained Objects by location
+          #{bar}
+          #{format_two_columns(objects_by_location(retained))}
+
+          Retained Objects by class
+          #{bar}
+          #{format_two_columns(objects_by_class(retained))}
         RESULT
       end
 
@@ -45,45 +73,45 @@ module Majo
         cyan '-----------------------------------'
       end
 
-      def total_objects
+      def total_objects(allocs)
         allocs.size
       end
 
-      def total_memory
+      def total_memory(allocs)
         allocs.sum(&:memsize)
       end
 
-      def memory_by_file
+      def memory_by_file(allocs)
         allocs.group_by(&:path).map do |path, allocations|
           [allocations.sum(&:memsize), path]
         end.sort_by(&:first).reverse
       end
 
-      def memory_by_location
+      def memory_by_location(allocs)
         allocs.group_by { |a| "#{a.path}:#{a.line}" }.map do |location, allocations|
           [allocations.sum(&:memsize), location]
         end.sort_by(&:first).reverse
       end
 
-      def memory_by_class
+      def memory_by_class(allocs)
         allocs.group_by(&:object_class_path).map do |class_path, allocations|
           [allocations.sum(&:memsize), class_path]
         end.sort_by(&:first).reverse
       end
 
-      def objects_by_file
+      def objects_by_file(allocs)
         allocs.group_by(&:path).map do |path, allocations|
           [allocations.size, path]
         end.sort_by(&:first).reverse
       end
 
-      def objects_by_location
+      def objects_by_location(allocs)
         allocs.group_by { |a| "#{a.path}:#{a.line}" }.map do |location, allocations|
           [allocations.size, location]
         end.sort_by(&:first).reverse
       end
 
-      def objects_by_class
+      def objects_by_class(allocs)
         allocs.group_by(&:object_class_path).map do |class_path, allocations|
           [allocations.size, class_path]
         end.sort_by(&:first).reverse
@@ -95,10 +123,6 @@ module Majo
         max_length = data.max_by { |row| row[0].to_s.size }[0].to_s.size
         data.map { |row| "#{blue(row[0].to_s.rjust(max_length))}  #{row[1]}" }.join("\n")
       end
-
-      def allocs
-        @allocs ||= result.allocations
-      end
     end
   end
 end

data/lib/majo/formatter/csv.rb

@@ -9,15 +9,15 @@ module Majo
 
       def call
         ::CSV.generate do |csv|
-          csv << ['Object class path', 'Class path', 'Method ID', 'Path', 'Line', 'Alloc generation', 'Free generation', 'Memsize', "Count"]
+          csv << ['Object class path', 'Class path', 'Method ID', 'Singleton method', 'Path', 'Line', 'Alloc generation', 'Free generation', 'Memsize', "Count"]
           groups.each do |row, count|
-            csv << [row.object_class_path, row.class_path, row.method_id, row.path, row.line, row.alloc_generation, row.free_generation, row.memsize, count]
+            csv << [row.object_class_path, row.class_path, row.method_id, row.singleton?, row.path, row.line, row.alloc_generation, row.free_generation, row.memsize, count]
           end
         end
       end
 
       def groups
-        @result.allocations.tally
+        [*@result.allocations, *@result.retained].tally
       end
     end
   end

data/lib/majo/result.rb

@@ -28,7 +28,7 @@ module Majo
 
     def with_output(out)
       case
-      when out.is_a?(IO)
+      when out.is_a?(IO) || (defined?(StringIO) && out.is_a?(StringIO))
         yield out
       when out.is_a?(String)
         File.open(out, "w") { |io| yield io }

data/lib/majo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Majo
-  VERSION = "0.0.4"
+  VERSION = "1.0.0"
 end

data/lib/majo.rb

@@ -10,22 +10,27 @@ require_relative 'majo/formatter'
 module Majo
   class Error < StandardError; end
 
-  def self.start
+  def self.start(upper_lifetime: nil, lower_lifetime: 1)
     GC.start
     GC.start
     GC.start
-    __start
+    __start(upper_lifetime, lower_lifetime)
   end
 
   def self.stop
     GC.start
     GC.start
     GC.start
-    __stop
+    res = __stop
+
+    # Collect retained objcects
+    ObjectSpace.each_object do |obj|
+      res.store_retained_object(obj)
+    end
   end
 
-  def self.run
-    r = start
+  def self.run(upper_lifetime: nil, lower_lifetime: 1)
+    r = start(upper_lifetime:, lower_lifetime:)
     yield
     r
   ensure

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: majo
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Masataka Pocke Kuwabara
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-22 00:00:00.000000000 Z
+date: 2024-07-26 00:00:00.000000000 Z
 dependencies: []
 description: A memory profiler focusing on long-lived objects.
 email:
@@ -19,11 +20,15 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ARCHITECTURE.md
+- CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile
 - ext/majo/allocation_info.c
 - ext/majo/allocation_info.h
+- ext/majo/attached_object.c
+- ext/majo/attached_object.h
 - ext/majo/darray.h
 - ext/majo/extconf.rb
 - ext/majo/majo.c
@@ -48,6 +53,8 @@ licenses:
 metadata:
   homepage_uri: https://github.com/pocke/majo
   source_code_uri: https://github.com/pocke/majo
+  changelog_uri: https://github.com/pocke/majo/blob/master/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -62,7 +69,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.0.dev
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: A memory profiler focusing on long-lived objects.
 test_files: []