data_structures_rmolinari 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a41b03a0d46982d64fc1ec5648174df24c6c9b0593ff93354ad90fc65ff84e8e
-  data.tar.gz: 544aa69540c9cef54c4eb6402b260bafbbeddf7dc5e770bf428976c11161c58e
+  metadata.gz: 5d10fb46bf10f119b95239cf8e3ed06585804d37ccb9b7b1da0c7139dfcb31b9
+  data.tar.gz: dc393fb3e3f597df278832b3c4faae08866ef93ad747ee0a30fca19345fa6c8a
 SHA512:
-  metadata.gz: 19efca577bb0c3c9524cf09b6f63c0e06beab70bfd20d1dbafa5034009be9bcb965ac5b8cee0ba0a39ecdcb646c401a54b363852a4572613941f7a34da174593
-  data.tar.gz: 05606e9c142a9bcb69a9fd555586b0ad8fe76bf7572af3dd82003de673d78b671b9a5edf1e5d4a2e4c7d5c6d5e41bef2ed1679573600725b74a25d4f3665c6ee
+  metadata.gz: 6ec16b3eb2a1f4deccf8a8c45cb20c9558a0267049236389de53444124feeefe282751f964f2cf1875e1fccd5fccc6ad5fea4edd0098fed7b358bc6051666b4e
+  data.tar.gz: 0435cf6031c7e40bf9706a7c8d7b493e7e31f7667131be682de59ad5dcd26a5151add0d03cee83b23da6fa6f0c132c964ef551341dc94ff5d17cffddc2b48f2a

data/README.md

@@ -7,14 +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.
 
 It is distributed under the MIT license.
 
-## Usage
-
-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
 
@@ -210,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.
  */
 
 /*

data/ext/shared.c

@@ -1,3 +1,4 @@
+#include "ruby.h"
 #include "shared.h"
 
 /*

data/ext/shared.h

@@ -2,7 +2,6 @@
 #define SHARED_H
 
 #include <stddef.h>
-#include "ruby.h"
 
 #define mShared rb_define_module("Shared")
 #define eSharedDataError rb_const_get(mShared, rb_intern_const("DataError"))
@@ -12,13 +11,11 @@
 //#define debug(...) printf(__VA_ARGS__)
 #define debug(...)
 
-/* What we might think of as vector[index]. It is assignable */
+/* What we might think of as vector[index] for a CC vec(foo). It is assignable */
 #define lval(vector, index) (*get(vector, index))
 
 /*
  * Binary tree arithmetic for an implicit tree in an array, 1-based.
- *
- * TODO: into shared header
  */
 #define TREE_ROOT 1
 size_t midpoint(size_t left, size_t right);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data_structures_rmolinari
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Rory Molinari
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-03 00:00:00.000000000 Z
+date: 2023-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: must_be