majo 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 30b12103910ff82b8073d3882debca86928bc05d03e318b8c640e0c3b6f4c6ee
+  data.tar.gz: 851e43d87d7ba4020b5eb04487ae9859522bba5bd7f7a6765d02432efe2b8d74
+SHA512:
+  metadata.gz: ee86c8d4f321e54646ec82ee79168a8071ff641be47f9fd006ab70c9f254fbd958e6667c1e9dde36b00e911eee17d970a09a785dd53912f9bc4383101e649957
+  data.tar.gz: 3b707eee86c906409bd26f9b15e0e35aa1e6516e566b7d0f7e526b4fc76d74478110f75aa77b23041133d8b966999882c46d60515617121d7eec9cd41d9c3ac1

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics:
+  Enabled: false

data/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, Masataka Pocke Kuwabara
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,31 @@
+# Majo
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/majo`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/pocke/majo.

data/Rakefile

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.test_files = Dir['test/**/*_test.rb']
+  test.verbose = true
+end
+
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new("majo")
+
+CLEAN.add("{ext,lib}/**/*.{o,so,bundle}", "pkg")
+
+task test: :compile
+task default: %i[rubocop test]

data/ext/majo/allocation_info.c

@@ -0,0 +1,119 @@
+#include "majo.h"
+
+static void majo_allocation_info_mark(void *ptr)
+{
+  // TODO
+  majo_allocation_info *info = (majo_allocation_info*)ptr;
+}
+
+static void majo_allocation_info_free(majo_allocation_info *info) {
+  // TODO
+  ruby_xfree(info);
+}
+
+static size_t majo_allocation_info_memsize(const void *ptr) {
+  return sizeof(majo_allocation_info);
+}
+
+static rb_data_type_t allocation_info_type = {
+  "Majo::AllocationInfo",
+  {majo_allocation_info_mark, (RUBY_DATA_FUNC)majo_allocation_info_free, majo_allocation_info_memsize},
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+static VALUE
+allocation_info_alloc(VALUE klass) {
+  majo_allocation_info *info;
+  VALUE obj = TypedData_Make_Struct(klass, majo_allocation_info, &allocation_info_type, info);
+  return obj;
+}
+
+VALUE
+majo_new_allocation_info(majo_allocation_info *info) {
+  majo_allocation_info *new_info;
+  VALUE obj = TypedData_Make_Struct(rb_cMajo_AllocationInfo, majo_allocation_info, &allocation_info_type, new_info);
+  *new_info = *info;
+  return obj;
+}
+
+majo_allocation_info *
+majo_check_allocation_info(VALUE obj) {
+  return rb_check_typeddata(obj, &allocation_info_type);
+}
+
+static VALUE
+allocation_info_path(VALUE self) {
+  majo_allocation_info *info = majo_check_allocation_info(self);
+  if (info->path) {
+    return rb_str_new2(info->path);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE
+allocation_info_class_path(VALUE self) {
+  majo_allocation_info *info = majo_check_allocation_info(self);
+  if (info->class_path) {
+    return rb_str_new2(info->class_path);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE
+allocation_info_object_class_path(VALUE self) {
+  majo_allocation_info *info = majo_check_allocation_info(self);
+  if (info->object_class_path) {
+    return rb_str_new2(info->object_class_path);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE
+allocation_info_line(VALUE self) {
+  majo_allocation_info *info = majo_check_allocation_info(self);
+  return LONG2NUM(info->line);
+}
+
+
+static VALUE
+allocation_info_method_id(VALUE self) {
+  majo_allocation_info *info = majo_check_allocation_info(self);
+  return info->mid;
+}
+
+static VALUE
+allocation_info_alloc_generation(VALUE self) {
+  majo_allocation_info *info = majo_check_allocation_info(self);
+  return SIZET2NUM(info->alloc_generation);
+}
+
+static VALUE
+allocation_info_free_generation(VALUE self) {
+  majo_allocation_info *info = majo_check_allocation_info(self);
+  return SIZET2NUM(info->free_generation);
+}
+
+static VALUE
+allocation_info_memsize(VALUE self) {
+  majo_allocation_info *info = majo_check_allocation_info(self);
+  return SIZET2NUM(info->memsize);
+}
+
+void
+majo_init_allocation_info() {
+  rb_cMajo_AllocationInfo = rb_define_class_under(rb_mMajo, "AllocationInfo", rb_cObject);
+  rb_define_alloc_func(rb_cMajo_AllocationInfo, allocation_info_alloc);
+
+  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, "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);
+  rb_define_method(rb_cMajo_AllocationInfo, "free_generation", allocation_info_free_generation, 0);
+  rb_define_method(rb_cMajo_AllocationInfo, "memsize", allocation_info_memsize, 0);
+}

data/ext/majo/allocation_info.h

@@ -0,0 +1,22 @@
+#ifndef MAJO_ALLOCATION_INFO_H
+#define MAJO_ALLOCATION_INFO_H
+
+typedef struct {
+  const char *path;
+  const char *class_path;
+  const char *object_class_path;
+  unsigned long line;
+  VALUE mid;
+
+  size_t alloc_generation;
+  size_t free_generation;
+  size_t memsize;
+} majo_allocation_info;
+
+VALUE
+majo_new_allocation_info(majo_allocation_info *info);
+
+void
+majo_init_allocation_info();
+
+#endif

data/ext/majo/darray.h

@@ -0,0 +1,218 @@
+// This file is copied from https://github.com/ruby/ruby and modified for this project.
+//
+// ----
+//
+// Copyright (C) 1993-2013 Yukihiro Matsumoto.
+// Copyright (C) 2024 Masataka Kuwabara.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+// SUCH DAMAGE.
+
+#ifndef RUBY_DARRAY_H
+#define RUBY_DARRAY_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+// Type for a dynamic array. Use to declare a dynamic array.
+// It is a pointer so it fits in st_table nicely. Designed
+// to be fairly type-safe.
+//
+// NULL is a valid empty dynamic array.
+//
+// Example:
+//      rb_darray(char) char_array = NULL;
+//      rb_darray_append(&char_array, 'e');
+//      printf("pushed %c\n", *rb_darray_ref(char_array, 0));
+//      rb_darray_free(char_array);
+//
+#define rb_darray(T) struct { rb_darray_meta_t meta; T data[]; } *
+
+// Copy an element out of the array. Warning: not bounds checked.
+//
+// T rb_darray_get(rb_darray(T) ary, size_t idx);
+//
+#define rb_darray_get(ary, idx) ((ary)->data[(idx)])
+
+// Assign to an element. Warning: not bounds checked.
+//
+// void rb_darray_set(rb_darray(T) ary, size_t idx, T element);
+//
+#define rb_darray_set(ary, idx, element) ((ary)->data[(idx)] = (element))
+
+// Get a pointer to an element. Warning: not bounds checked.
+//
+// T *rb_darray_ref(rb_darray(T) ary, size_t idx);
+//
+#define rb_darray_ref(ary, idx) (&((ary)->data[(idx)]))
+
+/* Copy a new element into the array. ptr_to_ary is evaluated multiple times.
+ *
+ * void rb_darray_append(rb_darray(T) *ptr_to_ary, T element);
+ */
+#define rb_darray_append(ptr_to_ary, element) \
+    rb_darray_append_impl(ptr_to_ary, element)
+
+#define rb_darray_append_impl(ptr_to_ary, element) do {  \
+    rb_darray_ensure_space((ptr_to_ary), \
+                           sizeof(**(ptr_to_ary)), \
+                           sizeof((*(ptr_to_ary))->data[0])); \
+    rb_darray_set(*(ptr_to_ary), \
+                  (*(ptr_to_ary))->meta.size, \
+                  (element)); \
+    (*(ptr_to_ary))->meta.size++; \
+} while (0)
+
+// Iterate over items of the array in a for loop
+//
+#define rb_darray_foreach(ary, idx_name, elem_ptr_var) \
+    for (size_t idx_name = 0; idx_name < rb_darray_size(ary) && ((elem_ptr_var) = rb_darray_ref(ary, idx_name)); ++idx_name)
+
+// Iterate over valid indices in the array in a for loop
+//
+#define rb_darray_for(ary, idx_name) \
+    for (size_t idx_name = 0; idx_name < rb_darray_size(ary); ++idx_name)
+
+/* Make a dynamic array of a certain size. All bytes backing the elements are set to zero.
+ * Return 1 on success and 0 on failure.
+ *
+ * Note that NULL is a valid empty dynamic array.
+ *
+ * void rb_darray_make(rb_darray(T) *ptr_to_ary, size_t size);
+ */
+#define rb_darray_make(ptr_to_ary, size) \
+    rb_darray_make_impl((ptr_to_ary), size, sizeof(**(ptr_to_ary)), sizeof((*(ptr_to_ary))->data[0]))
+
+/* Resize the darray to a new capacity. The new capacity must be greater than
+ * or equal to the size of the darray.
+ *
+ * void rb_darray_resize_capa(rb_darray(T) *ptr_to_ary, size_t capa);
+ */
+#define rb_darray_resize_capa(ptr_to_ary, capa) \
+    rb_darray_resize_capa_impl((ptr_to_ary), capa, sizeof(**(ptr_to_ary)), sizeof((*(ptr_to_ary))->data[0]))
+
+#define rb_darray_data_ptr(ary) ((ary)->data)
+
+typedef struct rb_darray_meta {
+    size_t size;
+    size_t capa;
+} rb_darray_meta_t;
+
+/* Set the size of the array to zero without freeing the backing memory.
+ * Allows reusing the same array. */
+static inline void
+rb_darray_clear(void *ary)
+{
+    rb_darray_meta_t *meta = ary;
+    if (meta) {
+        meta->size = 0;
+    }
+}
+
+// Get the size of the dynamic array.
+//
+static inline size_t
+rb_darray_size(const void *ary)
+{
+    const rb_darray_meta_t *meta = ary;
+    return meta ? meta->size : 0;
+}
+
+// Get the capacity of the dynamic array.
+//
+static inline size_t
+rb_darray_capa(const void *ary)
+{
+    const rb_darray_meta_t *meta = ary;
+    return meta ? meta->capa : 0;
+}
+
+/* Free the dynamic array. */
+static inline void
+rb_darray_free(void *ary)
+{
+    free(ary);
+}
+
+/* Internal function. Resizes the capacity of a darray. The new capacity must
+ * be greater than or equal to the size of the darray. */
+static inline void
+rb_darray_resize_capa_impl(void *ptr_to_ary, size_t new_capa, size_t header_size, size_t element_size)
+{
+    rb_darray_meta_t **ptr_to_ptr_to_meta = ptr_to_ary;
+    rb_darray_meta_t *meta = *ptr_to_ptr_to_meta;
+
+    rb_darray_meta_t *new_ary = realloc(meta, new_capa * element_size + header_size);
+
+    if (meta == NULL) {
+        /* First allocation. Initialize size. On subsequence allocations
+         * realloc takes care of carrying over the size. */
+        new_ary->size = 0;
+    }
+
+    RUBY_ASSERT(new_ary->size <= new_capa);
+
+    new_ary->capa = new_capa;
+
+    // We don't have access to the type of the dynamic array in function context.
+    // Write out result with memcpy to avoid strict aliasing issue.
+    memcpy(ptr_to_ary, &new_ary, sizeof(new_ary));
+}
+
+// Internal function
+// Ensure there is space for one more element.
+// Note: header_size can be bigger than sizeof(rb_darray_meta_t) when T is __int128_t, for example.
+static inline void
+rb_darray_ensure_space(void *ptr_to_ary, size_t header_size, size_t element_size)
+{
+    rb_darray_meta_t **ptr_to_ptr_to_meta = ptr_to_ary;
+    rb_darray_meta_t *meta = *ptr_to_ptr_to_meta;
+    size_t current_capa = rb_darray_capa(meta);
+    if (rb_darray_size(meta) < current_capa) return;
+
+    // Double the capacity
+    size_t new_capa = current_capa == 0 ? 1 : current_capa * 2;
+
+    rb_darray_resize_capa_impl(ptr_to_ary, new_capa, header_size, element_size);
+}
+
+static inline void
+rb_darray_make_impl(void *ptr_to_ary, size_t array_size, size_t header_size, size_t element_size)
+{
+    rb_darray_meta_t **ptr_to_ptr_to_meta = ptr_to_ary;
+    if (array_size == 0) {
+        *ptr_to_ptr_to_meta = NULL;
+        return;
+    }
+
+    rb_darray_meta_t *meta = calloc(array_size * element_size + header_size, 1);
+
+    meta->size = array_size;
+    meta->capa = array_size;
+
+    // We don't have access to the type of the dynamic array in function context.
+    // Write out result with memcpy to avoid strict aliasing issue.
+    memcpy(ptr_to_ary, &meta, sizeof(meta));
+}
+
+#endif /* RUBY_DARRAY_H */

data/ext/majo/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("majo")

data/ext/majo/majo.c

@@ -0,0 +1,148 @@
+#include "majo.h"
+
+VALUE rb_mMajo;
+VALUE rb_cMajo_Result;
+VALUE rb_cMajo_AllocationInfo;
+
+ID running_tracer_stack;
+
+static bool
+internal_object_p(VALUE obj)
+{
+  switch (TYPE(obj)) {
+    case T_OBJECT:
+    case T_CLASS:
+    case T_MODULE:
+    case T_FLOAT:
+    case T_STRING:
+    case T_REGEXP:
+    case T_ARRAY:
+    case T_HASH:
+    case T_STRUCT:
+    case T_BIGNUM:
+    case T_FILE:
+    case T_DATA:
+    case T_MATCH:
+    case T_COMPLEX:
+    case T_RATIONAL:
+    case T_NIL:
+    case T_TRUE:
+    case T_FALSE:
+    case T_SYMBOL:
+    case T_FIXNUM:
+      return false;
+    default:
+      return true;
+  }
+}
+
+static void
+newobj_i(VALUE tpval, void *data)
+{
+  majo_result *arg = (majo_result *)data;
+
+  rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+  VALUE obj = rb_tracearg_object(tparg);
+
+  if (internal_object_p(obj)) {
+    return;
+  }
+
+  VALUE path = rb_tracearg_path(tparg);
+  VALUE line = rb_tracearg_lineno(tparg);
+  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;
+
+  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;
+
+
+  info->path = path_cstr;
+  info->line = NUM2INT(line);
+  info->mid = mid;
+  info->object_class_path = obj_class_path_cstr;
+
+  info->class_path = class_path_cstr;
+  info->alloc_generation = rb_gc_count();
+  st_insert(arg->object_table, (st_data_t)obj, (st_data_t)info);
+}
+
+static void
+freeobj_i(VALUE tpval, void *data)
+{
+  majo_result *arg = (majo_result *)data;
+  rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+  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) {
+      info->memsize = rb_obj_memsize_of((VALUE)obj);
+      info->free_generation = gc_count;
+
+      VALUE obj = rb_tracearg_object(tparg);
+      if (!internal_object_p(obj)) {
+        majo_result_append_info(arg, *info);
+      }
+    }
+    free(info);
+  }
+}
+
+static VALUE
+start(VALUE self) {
+  VALUE res = majo_new_result();
+  majo_result *arg = majo_check_result(res);
+
+  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->freeobj_trace = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_FREEOBJ, freeobj_i, arg);
+
+  rb_tracepoint_enable(arg->newobj_trace);
+  rb_tracepoint_enable(arg->freeobj_trace);
+
+  return res;
+}
+
+static VALUE
+stop(VALUE self)
+{
+  VALUE stack = rb_ivar_get(rb_mMajo, running_tracer_stack);
+  VALUE res = rb_ary_pop(stack);
+  majo_result *arg = majo_check_result(res);
+
+  rb_tracepoint_disable(arg->newobj_trace);
+  rb_tracepoint_disable(arg->freeobj_trace);
+
+  return res;
+}
+
+void
+Init_majo(void)
+{
+  rb_mMajo = rb_define_module("Majo");
+
+  rb_define_module_function(rb_mMajo, "__start", start, 0);
+  rb_define_module_function(rb_mMajo, "__stop", stop, 0);
+
+  running_tracer_stack = rb_intern("running_tracer_stack");
+  rb_ivar_set(rb_mMajo, running_tracer_stack, rb_ary_new());
+
+  majo_init_result();
+  majo_init_allocation_info();
+}

data/ext/majo/majo.h

@@ -0,0 +1,23 @@
+#ifndef MAJO_H
+#define MAJO_H 1
+
+#include <stdbool.h>
+
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "ruby/internal/gc.h"
+
+#include "darray.h"
+
+#include "allocation_info.h"
+#include "result.h"
+#include "unique_str.h"
+
+extern VALUE rb_mMajo;
+extern VALUE rb_cMajo_Result;
+extern VALUE rb_cMajo_AllocationInfo;
+
+// Exposing the internal functions
+size_t rb_obj_memsize_of(VALUE);
+
+#endif

data/ext/majo/result.c

@@ -0,0 +1,71 @@
+#include "majo.h"
+
+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);
+}
+
+static void majo_result_free(majo_result *arg) {
+  // TODO
+  ruby_xfree(arg);
+}
+
+static size_t majo_result_memsize(const void *ptr) {
+  // TODO
+  return sizeof(majo_result);
+}
+
+static rb_data_type_t result_type = {
+  "Majo::Result",
+  {majo_result_mark, (RUBY_DATA_FUNC)majo_result_free, majo_result_memsize},
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE result_alloc(VALUE klass) {
+  majo_result *arg;
+  VALUE obj = TypedData_Make_Struct(klass, majo_result, &result_type, arg);
+  arg->object_table = st_init_numtable();
+  arg->str_table = st_init_strtable();
+  arg->olds = NULL;
+
+  return obj;
+}
+
+VALUE
+majo_new_result() {
+  return rb_class_new_instance(0, NULL, rb_cMajo_Result);
+}
+
+majo_result *
+majo_check_result(VALUE obj) {
+  return rb_check_typeddata(obj, &result_type);
+}
+
+void
+majo_result_append_info(majo_result *res, majo_allocation_info info) {
+  rb_darray_append(&res->olds, info);
+}
+
+VALUE
+majo_result_allocations(VALUE self) {
+  majo_result *res = majo_check_result(self);
+  VALUE ary = rb_ary_new_capa(rb_darray_size(res->olds));
+
+  majo_allocation_info *info_ptr;
+  rb_darray_foreach(res->olds, i, info_ptr) {
+    VALUE v = majo_new_allocation_info(info_ptr);
+    rb_ary_push(ary, v);
+  }
+
+  return ary;
+}
+
+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);
+}

data/ext/majo/result.h

@@ -0,0 +1,24 @@
+#ifndef MAJO_RESULT_H
+#define MAJO_RESULT_H
+
+typedef struct {
+  st_table *object_table; /* obj (VALUE) -> allocation_info */
+  st_table *str_table;    /* cstr -> refcount */
+  rb_darray(majo_allocation_info) olds;
+  VALUE newobj_trace;
+  VALUE freeobj_trace;
+} majo_result;
+
+VALUE
+majo_new_result();
+
+majo_result *
+majo_check_result(VALUE obj);
+
+void
+majo_result_append_info(majo_result *res, majo_allocation_info info);
+
+void
+majo_init_result();
+
+#endif

data/ext/majo/unique_str.c

@@ -0,0 +1,73 @@
+// This file is copied from https://github.com/ruby/ruby and modified for this project.
+//
+// ----
+//
+// Copyright (C) 1993-2013 Yukihiro Matsumoto.
+// Copyright (C) 2024 Masataka Kuwabara.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+// SUCH DAMAGE.
+
+#include "majo.h"
+
+const char *
+majo_make_unique_str(st_table *tbl, const char *str, long len)
+{
+  if (!str) {
+    return NULL;
+  }
+  else {
+    st_data_t n;
+    char *result;
+
+    if (st_lookup(tbl, (st_data_t)str, &n)) {
+      st_insert(tbl, (st_data_t)str, n+1);
+      st_get_key(tbl, (st_data_t)str, &n);
+      result = (char *)n;
+    }
+    else {
+      result = (char *)malloc(len+1);
+      strncpy(result, str, len);
+      result[len] = 0;
+      st_add_direct(tbl, (st_data_t)result, 1);
+    }
+    return result;
+  }
+}
+
+void
+majo_delete_unique_str(st_table *tbl, const char *str)
+{
+  if (str) {
+    st_data_t n;
+
+    st_lookup(tbl, (st_data_t)str, &n);
+    if (n == 1) {
+      n = (st_data_t)str;
+      st_delete(tbl, &n, 0);
+      free((char *)n);
+    }
+    else {
+      st_insert(tbl, (st_data_t)str, n-1);
+    }
+  }
+}

data/ext/majo/unique_str.h

@@ -0,0 +1,10 @@
+#ifndef MAJO_UNIQUE_STR_H
+#define MAJO_UNIQUE_STR_H
+
+const char *
+majo_make_unique_str(st_table *tbl, const char *str, long len);
+
+void
+majo_delete_unique_str(st_table *tbl, const char *str);
+
+#endif

data/lib/majo/allocation_info.rb

@@ -0,0 +1,23 @@
+module Majo
+  class AllocationInfo
+    def inspect
+      "#<Majo::AllocationInfo #{object_class_path} #{class_path}##{method_id} #{path}:#{line} gen#{alloc_generation}..#{free_generation}>"
+    end
+
+    def hash
+      path.hash ^ class_path.hash ^ method_id.hash ^ line.hash ^ object_class_path.hash ^ alloc_generation.hash ^ free_generation.hash ^ memsize.hash
+    end
+
+    def eql?(other)
+      other.is_a?(AllocationInfo) &&
+        path == other.path &&
+        class_path == other.class_path &&
+        method_id == other.method_id &&
+        line == other.line &&
+        object_class_path == other.object_class_path &&
+        alloc_generation == other.alloc_generation &&
+        free_generation == other.free_generation &&
+        memsize == other.memsize
+    end
+  end
+end

data/lib/majo/formatter/color.rb

@@ -0,0 +1,92 @@
+module Majo
+  module Formatter
+    class Color
+      def initialize(result)
+        @result = result
+      end
+
+      def call
+        <<~RESULT
+          Total #{total_memory} bytes (#{total_objects} objects)
+
+          Memory by file
+          #{format_two_columns(memory_by_file)}
+
+          Memory by location
+          #{format_two_columns(memory_by_location)}
+
+          Memory by class
+          #{format_two_columns(memory_by_class)}
+
+          Objects by file
+          #{format_two_columns(objects_by_file)}
+
+          Objects by location
+          #{format_two_columns(objects_by_location)}
+
+          Objects by class
+          #{format_two_columns(objects_by_class)}
+        RESULT
+      end
+
+      private
+
+      attr_reader :result
+
+      def total_objects
+        allocs.size
+      end
+
+      def total_memory
+        allocs.sum(&:memsize)
+      end
+
+      def memory_by_file
+        allocs.group_by(&:path).map do |path, allocations|
+          [allocations.sum(&:memsize), path]
+        end.sort_by(&:first).reverse
+      end
+
+      def memory_by_location
+        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
+        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
+        allocs.group_by(&:path).map do |path, allocations|
+          [allocations.size, path]
+        end.sort_by(&:first).reverse
+      end
+
+      def objects_by_location
+        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
+        allocs.group_by(&:object_class_path).map do |class_path, allocations|
+          [allocations.size, class_path]
+        end.sort_by(&:first).reverse
+      end
+
+      def format_two_columns(data)
+        return "" if data.empty?
+
+        max_length = data.max_by { |row| row[0].to_s.size }[0].size
+        data.map { |row| "#{row[0].to_s.ljust(max_length)} #{row[1]}" }.join("\n")
+      end
+
+      def allocs
+        @allocs ||= result.allocations
+      end
+    end
+  end
+end

data/lib/majo/formatter/csv.rb

@@ -0,0 +1,24 @@
+require 'csv'
+
+module Majo
+  module Formatter
+    class CSV
+      def initialize(result)
+        @result = result
+      end
+
+      def call
+        ::CSV.generate do |csv|
+          csv << ['Object class path', 'Class path', 'Method ID', '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]
+          end
+        end
+      end
+
+      def groups
+        @result.allocations.tally
+      end
+    end
+  end
+end

data/lib/majo/formatter.rb

@@ -0,0 +1,6 @@
+module Majo
+  module Formatter
+    autoload :Color, 'majo/formatter/color'
+    autoload :CSV, 'majo/formatter/csv'
+  end
+end

data/lib/majo/result.rb

@@ -0,0 +1,34 @@
+module Majo
+  class Result
+    def report(out: $stdout, formatter: nil)
+      fmt =
+        case formatter
+        when nil, :color
+          Formatter::Color
+        when :csv
+          Formatter::CSV
+        else
+          raise "unknown formatter: #{formatter.inspect}"
+        end
+
+      with_output(out) do |io|
+        io.puts fmt.new(self).call
+      end
+    end
+
+    private
+
+    def with_output(out)
+      case
+      when out.is_a?(IO)
+        yield out
+      when out.is_a?(String)
+        File.open(out, "w") { |io| yield io }
+      when out.respond_to?(:to_path)
+        File.open(out.to_path, "w") { |io| yield io }
+      else
+        raise ArgumentError, "out must be an IO or a String"
+      end
+    end
+  end
+end

data/lib/majo/version.rb

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

data/lib/majo.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'majo.so'
+require_relative "majo/version"
+require_relative 'majo/allocation_info'
+require_relative 'majo/result'
+require_relative 'majo/formatter'
+
+module Majo
+  class Error < StandardError; end
+
+  def self.start
+    GC.start
+    GC.start
+    GC.start
+    __start
+  end
+
+  def self.stop
+    GC.start
+    GC.start
+    GC.start
+    __stop
+  end
+
+  def self.run
+    r = start
+    yield
+    r
+  ensure
+    stop
+  end
+end

data/sig/majo.rbs

@@ -0,0 +1,4 @@
+module Majo
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: majo
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Masataka Pocke Kuwabara
+bindir: exe
+cert_chain: []
+date: 2024-07-22 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email:
+- kuwabara@pocke.me
+executables: []
+extensions:
+- ext/majo/extconf.rb
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- LICENSE
+- README.md
+- Rakefile
+- ext/majo/allocation_info.c
+- ext/majo/allocation_info.h
+- ext/majo/darray.h
+- ext/majo/extconf.rb
+- ext/majo/majo.c
+- ext/majo/majo.h
+- ext/majo/result.c
+- ext/majo/result.h
+- ext/majo/unique_str.c
+- ext/majo/unique_str.h
+- lib/majo.rb
+- lib/majo/allocation_info.rb
+- lib/majo/formatter.rb
+- lib/majo/formatter/color.rb
+- lib/majo/formatter/csv.rb
+- lib/majo/result.rb
+- lib/majo/version.rb
+- sig/majo.rbs
+homepage: https://github.com/pocke/majo
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/pocke/majo
+  source_code_uri: https://github.com/pocke/majo
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.0.dev
+specification_version: 4
+summary: ''
+test_files: []