data_structures_rmolinari 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7682f6d3b0779f347ce0797f55f33b9d7dcc7bd9c2039fc2fd6f865eb72e085a
-  data.tar.gz: d717e5e36f79ddc4ecb605a59b475b7114359dea7476445590deb300f7915bd4
+  metadata.gz: 5d10fb46bf10f119b95239cf8e3ed06585804d37ccb9b7b1da0c7139dfcb31b9
+  data.tar.gz: dc393fb3e3f597df278832b3c4faae08866ef93ad747ee0a30fca19345fa6c8a
 SHA512:
-  metadata.gz: c3ffd9a4f67f55b7a2df1c949cf2288c06fcae416d5ff03a10307a1b79c3dae1daa74e2576d5e190c989adeea47b046426fad8c3c64199aadf22ba500b317f36
-  data.tar.gz: 8380d6117f2955da9362395f8315f5121b4f7afba2f69aabb1981a01b675cbbed81d07c10b5745409080c2588c92df3d676ec36efa128571234a74dceef0e20d
+  metadata.gz: 6ec16b3eb2a1f4deccf8a8c45cb20c9558a0267049236389de53444124feeefe282751f964f2cf1875e1fccd5fccc6ad5fea4edd0098fed7b358bc6051666b4e
+  data.tar.gz: 0435cf6031c7e40bf9706a7c8d7b493e7e31f7667131be682de59ad5dcd26a5151add0d03cee83b23da6fa6f0c132c964ef551341dc94ff5d17cffddc2b48f2a

data/README.md

@@ -7,12 +7,11 @@ participating in the Advent of Code (https://adventofcode.com/).
 The implementations are based on the expository descriptions and pseudo-code I found as I read about each structure and so are not
 as fast as possible.
 
-The code is available as a gem: https://rubygems.org/gems/data_structures_rmolinari.
+The code lives in the `DataStructuresRMolinari` module to avoid polluting the global namespace.
 
-## Usage
+It is distributed under the MIT license.
 
-The right way to organize the code is not obvious to me. For now the data structures are all defined in the module
-`DataStructuresRMolinari` to avoid polluting the global namespace.
+It is available as a gem: https://rubygems.org/gems/data_structures_rmolinari.
 
 # Implementations
 
@@ -166,13 +165,13 @@ SegmentTree = DataStructuresRMolinari::SegmentTree # namespace module
 
 data = [1, -3, 2, 1, 5, -9]
 
-# Get a segment tree instance that will answer "max over this subinterval" questions about data.
+# Get a segment tree instance that will answer "max over this subinterval?" questions about data.
 # Here we get one using the ruby implementation of the generic functionality.
 #
-# We offer :index_of_max as an alternative to :max. This will construct an instance that answers
-# questions of the form "an index of the maximum value over this subinterval".
+# Put :index_of_max in place of :map to get an instance that returns "an index of the maximum value
+# over this subinterval".
 #
-# To use the version written in C, put :c instead of :ruby.
+# To use the generic code written in C, put :c instead of :ruby.
 seg_tree = SegmentTree.construct(data, :max, :ruby)
 
 seg_tree.max_on(0, 2) # => 2
@@ -208,8 +207,10 @@ The implementation uses the remarkable Convenient Containers library from Jackso
 the pure Ruby `SegmentTreeTemplate` class.
 
 A benchmark suggests that a long sequence of `max_on` operations against a max-val Segment Tree is about 4 times as fast with C as
-with Ruby. I'm a bit suprised the improvment isn't larger, but remember that the C code must still interact with the Ruby objects in
-the underlying data array, and must combine them, etc., via Ruby lambdas.
+with Ruby. The speedup factor is lowered to a little over 2 when the Ruby code is run with YJIT (under Ruby 3.1.3).
+
+I'm a bit suprised the improvement isn't larger, but remember that the C code must still interact with the Ruby objects
+in the underlying data array, and must access and combine them via Ruby lambdas.
 
 # References
 - [Allan] Allan, J., _CC: Convenient Containers_, https://github.com/JacksonAllan/CC, (retrieved 2023-02-01).

data/ext/c_disjoint_union/disjoint_union.c

@@ -69,6 +69,11 @@ typedef struct du_data {
   size_t subset_count;
 } disjoint_union_data;
 
+/************************************************************
+ * Memory Management
+ *
+ */
+
 /*
  * Create one (on the heap).
  */
@@ -98,9 +103,76 @@ static void disjoint_union_free(void *ptr) {
 }
 
 /************************************************************
- * The disjoint union operations
+ * How much memory (roughly) does a disjoint_union_data instance consume?
+ *
+ * I guess the Ruby runtime can use this information when deciding how agressive to be during garbage collection and such.
+ */
+static size_t disjoint_union_memsize(const void *ptr) {
+  if (ptr) {
+    const disjoint_union_data *du = ptr;
+
+    // See https://github.com/JacksonAllan/CC/issues/3
+    return sizeof( cc_vec_hdr_ty ) + cap( du->pairs ) * CC_EL_SIZE( *(du->pairs) );
+  } else {
+    return 0;
+  }
+}
+
+// There is no need for a mark() function as we don't hold any Ruby objects ourselves.
+
+/*
+ * A configuration struct that tells the Ruby runtime how to deal with a disjoint_union_data object.
+ *
+ * https://docs.ruby-lang.org/en/master/extension_rdoc.html#label-Encapsulate+C+data+into+a+Ruby+object
+ */
+static const rb_data_type_t disjoint_union_type = {
+  .wrap_struct_name = "disjoint_union",
+  { // help for the Ruby garbage collector
+    .dmark = NULL, // dmark, for marking other Ruby objects. We don't hold any other objects so this can be NULL
+    .dfree = disjoint_union_free, // how to free the memory associated with an object
+    .dsize = disjoint_union_memsize, // roughly how much space does the object consume?
+  },
+  .data = NULL, // a data field we could use for something here if we wanted. Ruby ignores it
+  .flags = 0  // GC-related flag values.
+};
+
+/*
+ * End memory management functions
  ************************************************************/
 
+/************************************************************
+ * Wrapping and unwrapping things for the Ruby runtime
+ *
+ */
+
+/*
+ * Unwrap a Ruby-side disjoint union object to get the C struct inside.
+ */
+static disjoint_union_data *unwrapped(VALUE self) {
+  disjoint_union_data *disjoint_union;
+  TypedData_Get_Struct((self), disjoint_union_data, &disjoint_union_type, disjoint_union);
+  return disjoint_union;
+}
+
+/*
+ * This is for CDisjointUnion.allocate on the Ruby side
+ */
+static VALUE disjoint_union_alloc(VALUE klass) {
+  // Get one on the heap
+  disjoint_union_data *disjoint_union = create_disjoint_union();
+  // Wrap it up into a Ruby object
+  return TypedData_Wrap_Struct(klass, &disjoint_union_type, disjoint_union);
+}
+
+/*
+ * End wrapping and unwrapping functions.
+ ************************************************************/
+
+/************************************************************
+ * The Disjoint Union API here on the C side
+ *
+ */
+
 /*
  * Is the given element already a member of the universe?
  */
@@ -114,13 +186,6 @@ static int present_p(disjoint_union_data *disjoint_union, size_t element) {
 static void assert_membership(disjoint_union_data *disjoint_union, size_t element) {
   if (!present_p(disjoint_union, element)) {
     rb_raise(eSharedDataError, "Value %zu is not part of the universe", element);
-    /* rb_raise( */
-    /*          eSharedDataError, */
-    /*          "Value %zu is not part of the universe, size = %zu, forest_val = %lu", */
-    /*          element, */
-    /*          size(disjoint_union->pairs), */
-    /*          get(disjoint_union->pairs, element)->parent */
-    /*          ); */
   }
 }
 
@@ -206,59 +271,15 @@ static void unite(disjoint_union_data *disjoint_union, size_t elt1, size_t elt2)
   link_roots(disjoint_union, root1, root2);
 }
 
-
-/**
- * Wrapping and unwrapping things for the Ruby runtime
- *
- */
-
-// How much memory (roughly) does a disjoint_union_data instance consume? I guess the Ruby runtime can use this information when
-// deciding how agressive to be during garbage collection and such.
-static size_t disjoint_union_memsize(const void *ptr) {
-  if (ptr) {
-    const disjoint_union_data *du = ptr;
-
-    // See https://github.com/JacksonAllan/CC/issues/3
-    return sizeof( cc_vec_hdr_ty ) + cap( du->pairs ) * CC_EL_SIZE( *(du->pairs) );
-  } else {
-    return 0;
-  }
-}
-
-/*
- * A configuration struct that tells the Ruby runtime how to deal with a disjoint_union_data object.
- *
- * https://docs.ruby-lang.org/en/master/extension_rdoc.html#label-Encapsulate+C+data+into+a+Ruby+object
- */
-static const rb_data_type_t disjoint_union_type = {
-  .wrap_struct_name = "disjoint_union",
-  { // help for the Ruby garbage collector
-    .dmark = NULL, // dmark, for marking other Ruby objects. We don't hold any other objects so this can be NULL
-    .dfree = disjoint_union_free, // how to free the memory associated with an object
-    .dsize = disjoint_union_memsize, // roughly how much space does the object consume?
-  },
-  .data = NULL, // a data field we could use for something here if we wanted. Ruby ignores it
-  .flags = 0  // GC-related flag values.
-};
-
 /*
- * Unwrap a Ruby-side disjoint union object to get the C struct inside.
- */
-static disjoint_union_data *unwrapped(VALUE self) {
-  disjoint_union_data *disjoint_union;
-  TypedData_Get_Struct((self), disjoint_union_data, &disjoint_union_type, disjoint_union);
-  return disjoint_union;
-}
+ * End C impelementaion of the Segment Tree API
+ ************************************************************/
 
-/*
- * This is for CDisjointUnion.allocate on the Ruby side
+/************************************************************
+ * The wrappers around the C functionality.
+ *
+ * These become Ruby methods via rb_define_method() below.
  */
-static VALUE disjoint_union_alloc(VALUE klass) {
-  // Get one on the heap
-  disjoint_union_data *disjoint_union = create_disjoint_union();
-  // Wrap it up into a Ruby object
-  return TypedData_Wrap_Struct(klass, &disjoint_union_type, disjoint_union);
-}
 
 /*
  * A single parameter is optional. If given it should be a non-negative integer and specifies the initial size, s, of the universe
@@ -286,17 +307,6 @@ static VALUE disjoint_union_init(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
-/**
- * And now the simple wrappers around the Disjoint Union C functionality. In each case we
- *   - unwrap a 'VALUE self',
- *     - i.e., the CDisjointUnion instance on the Ruby side;
- *   - munge any other arguments into longs;
- *   - call the appropriate C function to act on the struct; and
- *   - return an appropriate VALUE for the Ruby runtime can use.
- *
- * We make them into methods on CDisjointUnion in the Init_CDisjointUnion function, below.
- */
-
 /*
  * Add a new subset to the universe containing the element +new_v+.
  *

data/ext/c_disjoint_union/extconf.rb

@@ -1,17 +1,5 @@
 require 'mkmf'
 
-abort 'missing malloc()' unless have_func "malloc"
-abort 'missing realloc()' unless have_func "realloc"
+require_relative '../extconf_shared.rb'
 
-if try_cflags('-O3')
-  append_cflags('-O3')
-end
-
-extension_name = "c_disjoint_union"
-dir_config(extension_name)
-
-$srcs = ["disjoint_union.c", "../shared.c"]
-$INCFLAGS << " -I$(srcdir)/.."
-$VPATH << "$(srcdir)/.."
-
-create_makefile("data_structures_rmolinari/c_disjoint_union")
+generate_makefile('disjoint_union')

data/ext/c_segment_tree_template/extconf.rb

@@ -1,17 +1,4 @@
 require 'mkmf'
+require_relative '../extconf_shared.rb'
 
-abort 'missing malloc()' unless have_func "malloc"
-abort 'missing realloc()' unless have_func "realloc"
-
-if try_cflags('-O3')
-  append_cflags('-O3')
-end
-
-extension_name = "c_segment_tree_template"
-dir_config(extension_name)
-
-$srcs = ["segment_tree_template.c", "../shared.c"]
-$INCFLAGS << " -I$(srcdir)/.."
-$VPATH << "$(srcdir)/.."
-
-create_makefile("data_structures_rmolinari/c_segment_tree_template")
+generate_makefile('segment_tree_template')

data/ext/c_segment_tree_template/segment_tree_template.c

@@ -190,11 +190,11 @@ static void setup(segment_tree_data* seg_tree, VALUE combine, VALUE single_cell_
   VALUE idCall = rb_intern("call");
 
   if (!rb_obj_respond_to(combine, idCall, TRUE)) {
-    rb_raise(rb_eArgError, "wrong type argument %"PRIsVALUE" (should be callable)", rb_obj_class(combine));
+    rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be callable)", rb_obj_class(combine));
   }
 
   if (!rb_obj_respond_to(single_cell_array_val, idCall, TRUE)) {
-    rb_raise(rb_eArgError, "wrong type argument %"PRIsVALUE" (should be callable)", rb_obj_class(single_cell_array_val));
+    rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be callable)", rb_obj_class(single_cell_array_val));
   }
 
   seg_tree->combine_lambda = combine;
@@ -215,7 +215,6 @@ static void setup(segment_tree_data* seg_tree, VALUE combine, VALUE single_cell_
   build(seg_tree, TREE_ROOT, 0, seg_tree->size - 1);
 }
 
-
 /*
  * Determine the value for the subarray A(left, right).
  *
@@ -297,8 +296,10 @@ static void update_val_at(segment_tree_data *seg_tree, size_t idx, size_t tree_i
  * End C implementation of the Segment Tree API
  ************************************************************/
 
-/**
- * And now the wrappers around the C functionality.
+/************************************************************
+ * The wrappers around the C functionality.
+ *
+ * These become Ruby methods via rb_define_method() below.
  */
 
 /*