google-protobuf 3.23.4-x64-mingw-ucrt → 3.24.0.rc.2-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f2a3993a54877815d730b927bcec6474375a6a57a6e358752df74cf2d307e41
-  data.tar.gz: 3ca3548db84484bb991bca4e28dceb5670f9aa615c55b3082649da3ce691c4a0
+  metadata.gz: 75b6a09437df43ad9e4c670a7357a6f2643b892c8365e1ba813a53c36685194a
+  data.tar.gz: 8e5ff18868cb5b8b05dba40f68c2d3f44a35669f8bcd9923fd2cf4954f26bb7a
 SHA512:
-  metadata.gz: ab9826318435bcc893040cf9bbcc0c8bfc1b0d172a5c5a46e6fa19f5b18d8b03c6a31a0058df336097448895fe91a434c662fde17a5480511136b1c09b057b2d
-  data.tar.gz: 2e88574e69608dce1c8f03cac0764c4a55c5eca908b65c7a9cbf532290a6f2b91584ead3460ccfe611d4afe0df260d4a4d4cb8d547e78e4e2f8b28cced779692
+  metadata.gz: 483f75e7a5f3fb767ffc93765ef63a25e731292cc1e9caebcdc6b05878b1e0215125fc7ed02922ba985a2552fc08d7d2c6580799b4b49c813c42d914d54014c5
+  data.tar.gz: a3715a8b18e215c2238bf204fadc058d76eec53807102cc0b641032841833e9ed2e5ee010522bc8ac599cc34cc6e098d8be487b39be560b3115e98f03854de11

data/ext/google/protobuf_c/convert.h

@@ -31,8 +31,6 @@
 #ifndef RUBY_PROTOBUF_CONVERT_H_
 #define RUBY_PROTOBUF_CONVERT_H_
 
-#include <ruby/ruby.h>
-
 #include "protobuf.h"
 #include "ruby-upb.h"
 

data/ext/google/protobuf_c/defs.c

@@ -73,6 +73,8 @@ static VALUE rb_str_maybe_null(const char* s) {
 // -----------------------------------------------------------------------------
 
 typedef struct {
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
   VALUE def_to_descriptor;  // Hash table of def* -> Ruby descriptor.
   upb_DefPool* symtab;
 } DescriptorPool;
@@ -97,7 +99,7 @@ static void DescriptorPool_free(void* _self) {
 static const rb_data_type_t DescriptorPool_type = {
     "Google::Protobuf::DescriptorPool",
     {DescriptorPool_mark, DescriptorPool_free, NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static DescriptorPool* ruby_to_DescriptorPool(VALUE val) {
@@ -125,11 +127,9 @@ static VALUE DescriptorPool_alloc(VALUE klass) {
   self->def_to_descriptor = Qnil;
   ret = TypedData_Wrap_Struct(klass, &DescriptorPool_type, self);
 
-  self->def_to_descriptor = rb_hash_new();
+  RB_OBJ_WRITE(ret, &self->def_to_descriptor, rb_hash_new());
   self->symtab = upb_DefPool_New();
-  ObjectCache_Add(self->symtab, ret);
-
-  return ret;
+  return ObjectCache_TryAdd(self->symtab, ret);
 }
 
 /*
@@ -601,7 +601,7 @@ upb_CType ruby_to_fieldtype(VALUE type) {
 
 #define CONVERT(upb, ruby)                \
   if (SYM2ID(type) == rb_intern(#ruby)) { \
-    return kUpb_CType_##upb;                \
+    return kUpb_CType_##upb;              \
   }
 
   CONVERT(Float, float);
@@ -624,7 +624,7 @@ upb_CType ruby_to_fieldtype(VALUE type) {
 
 static VALUE descriptortype_to_ruby(upb_FieldType type) {
   switch (type) {
-#define CONVERT(upb, ruby)        \
+#define CONVERT(upb, ruby)   \
   case kUpb_FieldType_##upb: \
     return ID2SYM(rb_intern(#ruby));
     CONVERT(Float, float);
@@ -709,7 +709,7 @@ static VALUE FieldDescriptor_label(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   switch (upb_FieldDef_Label(self->fielddef)) {
 #define CONVERT(upb, ruby) \
-  case kUpb_Label_##upb:    \
+  case kUpb_Label_##upb:   \
     return ID2SYM(rb_intern(#ruby));
 
     CONVERT(Optional, optional);
@@ -1091,7 +1091,7 @@ static VALUE EnumDescriptor_name(VALUE _self) {
 static VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   const char* name_str = rb_id2name(SYM2ID(name));
-  const upb_EnumValueDef *ev =
+  const upb_EnumValueDef* ev =
       upb_EnumDef_FindValueByName(self->enumdef, name_str);
   if (ev) {
     return INT2NUM(upb_EnumValueDef_Number(ev));
@@ -1110,7 +1110,8 @@ static VALUE EnumDescriptor_lookup_name(VALUE _self, VALUE name) {
 static VALUE EnumDescriptor_lookup_value(VALUE _self, VALUE number) {
   EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
   int32_t val = NUM2INT(number);
-  const upb_EnumValueDef* ev = upb_EnumDef_FindValueByNumber(self->enumdef, val);
+  const upb_EnumValueDef* ev =
+      upb_EnumDef_FindValueByNumber(self->enumdef, val);
   if (ev) {
     return ID2SYM(rb_intern(upb_EnumValueDef_Name(ev)));
   } else {

data/ext/google/protobuf_c/defs.h

@@ -31,8 +31,6 @@
 #ifndef RUBY_PROTOBUF_DEFS_H_
 #define RUBY_PROTOBUF_DEFS_H_
 
-#include <ruby/ruby.h>
-
 #include "protobuf.h"
 #include "ruby-upb.h"
 

data/ext/google/protobuf_c/map.c

@@ -93,7 +93,6 @@ VALUE Map_GetRubyWrapper(upb_Map* map, upb_CType key_type, TypeInfo value_type,
   if (val == Qnil) {
     val = Map_alloc(cMap);
     Map* self;
-    ObjectCache_Add(map, val);
     TypedData_Get_Struct(val, Map, &Map_type, self);
     self->map = map;
     self->arena = arena;
@@ -103,6 +102,7 @@ VALUE Map_GetRubyWrapper(upb_Map* map, upb_CType key_type, TypeInfo value_type,
       const upb_MessageDef* val_m = self->value_type_info.def.msgdef;
       self->value_type_class = Descriptor_DefToClass(val_m);
     }
+    return ObjectCache_TryAdd(map, val);
   }
 
   return val;
@@ -319,7 +319,9 @@ static VALUE Map_init(int argc, VALUE* argv, VALUE _self) {
 
   self->map = upb_Map_New(Arena_get(self->arena), self->key_type,
                           self->value_type_info.type);
-  ObjectCache_Add(self->map, _self);
+  VALUE stored = ObjectCache_TryAdd(self->map, _self);
+  (void)stored;
+  PBRUBY_ASSERT(stored == _self);
 
   if (init_arg != Qnil) {
     Map_merge_into_self(_self, init_arg);

data/ext/google/protobuf_c/map.h

@@ -31,8 +31,6 @@
 #ifndef RUBY_PROTOBUF_MAP_H_
 #define RUBY_PROTOBUF_MAP_H_
 
-#include <ruby/ruby.h>
-
 #include "protobuf.h"
 #include "ruby-upb.h"
 

data/ext/google/protobuf_c/message.c

@@ -108,7 +108,9 @@ void Message_InitPtr(VALUE self_, upb_Message* msg, VALUE arena) {
   Message* self = ruby_to_Message(self_);
   self->msg = msg;
   RB_OBJ_WRITE(self_, &self->arena, arena);
-  ObjectCache_Add(msg, self_);
+  VALUE stored = ObjectCache_TryAdd(msg, self_);
+  (void)stored;
+  PBRUBY_ASSERT(stored == self_);
 }
 
 VALUE Message_GetArena(VALUE msg_rb) {

data/ext/google/protobuf_c/message.h

@@ -31,8 +31,6 @@
 #ifndef RUBY_PROTOBUF_MESSAGE_H_
 #define RUBY_PROTOBUF_MESSAGE_H_
 
-#include <ruby/ruby.h>
-
 #include "protobuf.h"
 #include "ruby-upb.h"
 

data/ext/google/protobuf_c/protobuf.c

@@ -195,7 +195,8 @@ const rb_data_type_t Arena_type = {
     .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
-static void* ruby_upb_allocfunc(upb_alloc* alloc, void* ptr, size_t oldsize, size_t size) {
+static void *ruby_upb_allocfunc(upb_alloc *alloc, void *ptr, size_t oldsize,
+                                size_t size) {
   if (size == 0) {
     xfree(ptr);
     return NULL;
@@ -252,164 +253,40 @@ void Arena_register(VALUE module) {
 // Object Cache
 // -----------------------------------------------------------------------------
 
-// A pointer -> Ruby Object cache that keeps references to Ruby wrapper
-// objects.  This allows us to look up any Ruby wrapper object by the address
-// of the object it is wrapping. That way we can avoid ever creating two
-// different wrapper objects for the same C object, which saves memory and
-// preserves object identity.
-//
-// We use WeakMap for the cache. For Ruby <2.7 we also need a secondary Hash
-// to store WeakMap keys because Ruby <2.7 WeakMap doesn't allow non-finalizable
-// keys.
-//
-// We also need the secondary Hash if sizeof(long) < sizeof(VALUE), because this
-// means it may not be possible to fit a pointer into a Fixnum. Keys are
-// pointers, and if they fit into a Fixnum, Ruby doesn't collect them, but if
-// they overflow and require allocating a Bignum, they could get collected
-// prematurely, thus removing the cache entry. This happens on 64-bit Windows,
-// on which pointers are 64 bits but longs are 32 bits. In this case, we enable
-// the secondary Hash to hold the keys and prevent them from being collected.
-
-#if RUBY_API_VERSION_CODE >= 20700 && SIZEOF_LONG >= SIZEOF_VALUE
-#define USE_SECONDARY_MAP 0
-#else
-#define USE_SECONDARY_MAP 1
-#endif
-
-#if USE_SECONDARY_MAP
-
-// Maps Numeric -> Object. The object is then used as a key into the WeakMap.
-// This is needed for Ruby <2.7 where a number cannot be a key to WeakMap.
-// The object is used only for its identity; it does not contain any data.
-VALUE secondary_map = Qnil;
-
-// Mutations to the map are under a mutex, because SeconaryMap_MaybeGC()
-// iterates over the map which cannot happen in parallel with insertions, or
-// Ruby will throw:
-//   can't add a new key into hash during iteration (RuntimeError)
-VALUE secondary_map_mutex = Qnil;
-
-// Lambda that will GC entries from the secondary map that are no longer present
-// in the primary map.
-VALUE gc_secondary_map_lambda = Qnil;
-ID length;
-
-extern VALUE weak_obj_cache;
-
-static void SecondaryMap_Init() {
-  rb_gc_register_address(&secondary_map);
-  rb_gc_register_address(&gc_secondary_map_lambda);
-  rb_gc_register_address(&secondary_map_mutex);
-  secondary_map = rb_hash_new();
-  gc_secondary_map_lambda = rb_eval_string(
-      "->(secondary, weak) {\n"
-      "  secondary.delete_if { |k, v| !weak.key?(v) }\n"
-      "}\n");
-  secondary_map_mutex = rb_mutex_new();
-  length = rb_intern("length");
-}
-
-// The secondary map is a regular Hash, and will never shrink on its own.
-// The main object cache is a WeakMap that will automatically remove entries
-// when the target object is no longer reachable, but unless we manually
-// remove the corresponding entries from the secondary map, it will grow
-// without bound.
-//
-// To avoid this unbounded growth we periodically remove entries from the
-// secondary map that are no longer present in the WeakMap. The logic of
-// how often to perform this GC is an artbirary tuning parameter that
-// represents a straightforward CPU/memory tradeoff.
-//
-// Requires: secondary_map_mutex is held.
-static void SecondaryMap_MaybeGC() {
-  PBRUBY_ASSERT(rb_mutex_locked_p(secondary_map_mutex) == Qtrue);
-  size_t weak_len = NUM2ULL(rb_funcall(weak_obj_cache, length, 0));
-  size_t secondary_len = RHASH_SIZE(secondary_map);
-  if (secondary_len < weak_len) {
-    // Logically this case should not be possible: a valid entry cannot exist in
-    // the weak table unless there is a corresponding entry in the secondary
-    // table. It should *always* be the case that secondary_len >= weak_len.
-    //
-    // However ObjectSpace::WeakMap#length (and therefore weak_len) is
-    // unreliable: it overreports its true length by including non-live objects.
-    // However these non-live objects are not yielded in iteration, so we may
-    // have previously deleted them from the secondary map in a previous
-    // invocation of SecondaryMap_MaybeGC().
-    //
-    // In this case, we can't measure any waste, so we just return.
-    return;
-  }
-  size_t waste = secondary_len - weak_len;
-  // GC if we could remove at least 2000 entries or 20% of the table size
-  // (whichever is greater).  Since the cost of the GC pass is O(N), we
-  // want to make sure that we condition this on overall table size, to
-  // avoid O(N^2) CPU costs.
-  size_t threshold = PBRUBY_MAX(secondary_len * 0.2, 2000);
-  if (waste > threshold) {
-    rb_funcall(gc_secondary_map_lambda, rb_intern("call"), 2, secondary_map,
-               weak_obj_cache);
-  }
-}
-
-// Requires: secondary_map_mutex is held by this thread iff create == true.
-static VALUE SecondaryMap_Get(VALUE key, bool create) {
-  PBRUBY_ASSERT(!create || rb_mutex_locked_p(secondary_map_mutex) == Qtrue);
-  VALUE ret = rb_hash_lookup(secondary_map, key);
-  if (ret == Qnil && create) {
-    SecondaryMap_MaybeGC();
-    ret = rb_class_new_instance(0, NULL, rb_cObject);
-    rb_hash_aset(secondary_map, key, ret);
-  }
-  return ret;
-}
-
-#endif
-
-// Requires: secondary_map_mutex is held by this thread iff create == true.
-static VALUE ObjectCache_GetKey(const void *key, bool create) {
-  VALUE key_val = (VALUE)key;
-  PBRUBY_ASSERT((key_val & 3) == 0);
-  VALUE ret = LL2NUM(key_val >> 2);
-#if USE_SECONDARY_MAP
-  ret = SecondaryMap_Get(ret, create);
-#endif
-  return ret;
-}
-
 // Public ObjectCache API.
 
 VALUE weak_obj_cache = Qnil;
 ID item_get;
-ID item_set;
+ID item_try_add;
+
+static void ObjectCache_Init(VALUE protobuf) {
+  item_get = rb_intern("get");
+  item_try_add = rb_intern("try_add");
 
-static void ObjectCache_Init() {
   rb_gc_register_address(&weak_obj_cache);
-  VALUE klass = rb_eval_string("ObjectSpace::WeakMap");
-  weak_obj_cache = rb_class_new_instance(0, NULL, klass);
-  item_get = rb_intern("[]");
-  item_set = rb_intern("[]=");
-#if USE_SECONDARY_MAP
-  SecondaryMap_Init();
+#if SIZEOF_LONG >= SIZEOF_VALUE
+  VALUE cache_class = rb_const_get(protobuf, rb_intern("ObjectCache"));
+#else
+  VALUE cache_class = rb_const_get(protobuf, rb_intern("LegacyObjectCache"));
 #endif
+
+  weak_obj_cache = rb_class_new_instance(0, NULL, cache_class);
+  rb_const_set(protobuf, rb_intern("OBJECT_CACHE"), weak_obj_cache);
+  rb_const_set(protobuf, rb_intern("SIZEOF_LONG"), INT2NUM(SIZEOF_LONG));
+  rb_const_set(protobuf, rb_intern("SIZEOF_VALUE"), INT2NUM(SIZEOF_VALUE));
 }
 
-void ObjectCache_Add(const void *key, VALUE val) {
-  PBRUBY_ASSERT(ObjectCache_Get(key) == Qnil);
-#if USE_SECONDARY_MAP
-  rb_mutex_lock(secondary_map_mutex);
-#endif
-  VALUE key_rb = ObjectCache_GetKey(key, true);
-  rb_funcall(weak_obj_cache, item_set, 2, key_rb, val);
-#if USE_SECONDARY_MAP
-  rb_mutex_unlock(secondary_map_mutex);
-#endif
-  PBRUBY_ASSERT(ObjectCache_Get(key) == val);
+VALUE ObjectCache_TryAdd(const void *key, VALUE val) {
+  VALUE key_val = (VALUE)key;
+  PBRUBY_ASSERT((key_val & 3) == 0);
+  return rb_funcall(weak_obj_cache, item_try_add, 2, LL2NUM(key_val), val);
 }
 
 // Returns the cached object for this key, if any. Otherwise returns Qnil.
 VALUE ObjectCache_Get(const void *key) {
-  VALUE key_rb = ObjectCache_GetKey(key, false);
-  return rb_funcall(weak_obj_cache, item_get, 1, key_rb);
+  VALUE key_val = (VALUE)key;
+  PBRUBY_ASSERT((key_val & 3) == 0);
+  return rb_funcall(weak_obj_cache, item_get, 1, LL2NUM(key_val));
 }
 
 /*
@@ -459,11 +336,10 @@ VALUE Google_Protobuf_deep_copy(VALUE self, VALUE obj) {
 // This must be named "Init_protobuf_c" because the Ruby module is named
 // "protobuf_c" -- the VM looks for this symbol in our .so.
 __attribute__((visibility("default"))) void Init_protobuf_c() {
-  ObjectCache_Init();
-
   VALUE google = rb_define_module("Google");
   VALUE protobuf = rb_define_module_under(google, "Protobuf");
 
+  ObjectCache_Init(protobuf);
   Arena_register(protobuf);
   Defs_register(protobuf);
   RepeatedField_register(protobuf);

data/ext/google/protobuf_c/protobuf.h

@@ -31,8 +31,22 @@
 #ifndef __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__
 #define __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__
 
+// Ruby 3+ defines NDEBUG itself, see: https://bugs.ruby-lang.org/issues/18777
+#ifdef NDEBUG
+#include <ruby.h>
+#else
+#include <ruby.h>
+#undef NDEBUG
+#endif
+
+#include <ruby/version.h>
+
+#if RUBY_API_VERSION_CODE < 20700
+#error Protobuf requires Ruby >= 2.7
+#endif
+
+#include <assert.h>  // Must be included after the NDEBUG logic above.
 #include <ruby/encoding.h>
-#include <ruby/ruby.h>
 #include <ruby/vm.h>
 
 #include "defs.h"
@@ -76,10 +90,9 @@ void Arena_Pin(VALUE arena, VALUE obj);
 // being collected (though in Ruby <2.7 is it effectively strong, due to
 // implementation limitations).
 
-// Adds an entry to the cache. The "arena" parameter must give the arena that
-// "key" was allocated from.  In Ruby <2.7.0, it will be used to remove the key
-// from the cache when the arena is destroyed.
-void ObjectCache_Add(const void* key, VALUE val);
+// Tries to add a new entry to the cache, returning the newly installed value or
+// the pre-existing entry.
+VALUE ObjectCache_TryAdd(const void* key, VALUE val);
 
 // Returns the cached object for this key, if any. Otherwise returns Qnil.
 VALUE ObjectCache_Get(const void* key);
@@ -110,7 +123,9 @@ extern VALUE cTypeError;
   do {                      \
   } while (false && (expr))
 #else
-#define PBRUBY_ASSERT(expr) assert(expr)
+#define PBRUBY_ASSERT(expr) \
+  if (!(expr))              \
+  rb_bug("Assertion failed at %s:%d, expr: %s", __FILE__, __LINE__, #expr)
 #endif
 
 #define PBRUBY_MAX(x, y) (((x) > (y)) ? (x) : (y))

data/ext/google/protobuf_c/repeated_field.c

@@ -87,7 +87,6 @@ VALUE RepeatedField_GetRubyWrapper(upb_Array* array, TypeInfo type_info,
   if (val == Qnil) {
     val = RepeatedField_alloc(cRepeatedField);
     RepeatedField* self;
-    ObjectCache_Add(array, val);
     TypedData_Get_Struct(val, RepeatedField, &RepeatedField_type, self);
     self->array = array;
     self->arena = arena;
@@ -95,11 +94,14 @@ VALUE RepeatedField_GetRubyWrapper(upb_Array* array, TypeInfo type_info,
     if (self->type_info.type == kUpb_CType_Message) {
       self->type_class = Descriptor_DefToClass(type_info.def.msgdef);
     }
+    val = ObjectCache_TryAdd(array, val);
   }
 
   PBRUBY_ASSERT(ruby_to_RepeatedField(val)->type_info.type == type_info.type);
   PBRUBY_ASSERT(ruby_to_RepeatedField(val)->type_info.def.msgdef ==
                 type_info.def.msgdef);
+  PBRUBY_ASSERT(ruby_to_RepeatedField(val)->array == array);
+
   return val;
 }
 
@@ -613,7 +615,8 @@ VALUE RepeatedField_init(int argc, VALUE* argv, VALUE _self) {
 
   self->type_info = TypeInfo_FromClass(argc, argv, 0, &self->type_class, &ary);
   self->array = upb_Array_New(arena, self->type_info.type);
-  ObjectCache_Add(self->array, _self);
+  VALUE stored_val = ObjectCache_TryAdd(self->array, _self);
+  PBRUBY_ASSERT(stored_val == _self);
 
   if (ary != Qnil) {
     if (!RB_TYPE_P(ary, T_ARRAY)) {

data/ext/google/protobuf_c/repeated_field.h

@@ -31,8 +31,6 @@
 #ifndef RUBY_PROTOBUF_REPEATED_FIELD_H_
 #define RUBY_PROTOBUF_REPEATED_FIELD_H_
 
-#include <ruby/ruby.h>
-
 #include "protobuf.h"
 #include "ruby-upb.h"