google-protobuf 4.26.0.rc.2-x64-mingw-ucrt → 4.26.0-x64-mingw-ucrt

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69e7d9301eabb162f35dc17a962edbd78e0571620358b3770d52378d48e68396
-  data.tar.gz: 59f2f96709693ab0bb32c3ad15d457f94fb40aeb7e9f0118df2c9748bb14f467
+  metadata.gz: 5bcc433ff55cc0d439112bae2abaab5ea349c9971a033ed9dbd6d215aba3ccbb
+  data.tar.gz: ad784796b452b3f1cb03415b19f30c6a5e5c09da60b7e9528bf58995dfdbcf09
 SHA512:
-  metadata.gz: 7e153b2ccdae2d2c7ba8b7950a1418ab68563b33ce650eb1eeddf9f84749294f0a7a916c3209b368302cba1440174ef3aac174a8bb40890218e2f28db8b4d3c7
-  data.tar.gz: c1f8ad2f4661609266382e11d268be475612b09bed8d36cfb2484efce6b9b0b28949fa8d682a4c714527ad287667cffc9d0c292315136eb9b30bf000a48609c7
+  metadata.gz: d22bc29c41188d13ef3a223e5b468048c7b95bf789175714dd5cbe938707830d8e8abef5679517960bdc7aba1907e43be9dff13bfe15ae2ef7132fcc69ddc4d3
+  data.tar.gz: 3fbf8a3b1525f3337d0f955a8f9f4ea35aa31954f05474388bf161601bab120c14bf8a39a7233315665ced00d984ce81b883ab4c92a5c2e2e45ead8e3798e93d

data/ext/google/protobuf_c/map.c

@@ -38,9 +38,11 @@ static void Map_mark(void* _self) {
   rb_gc_mark(self->arena);
 }
 
+static size_t Map_memsize(const void* _self) { return sizeof(Map); }
+
 const rb_data_type_t Map_type = {
     "Google::Protobuf::Map",
-    {Map_mark, RUBY_DEFAULT_FREE, NULL},
+    {Map_mark, RUBY_DEFAULT_FREE, Map_memsize},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 

data/ext/google/protobuf_c/message.c

@@ -44,9 +44,11 @@ static void Message_mark(void* _self) {
   rb_gc_mark(self->arena);
 }
 
+static size_t Message_memsize(const void* _self) { return sizeof(Message); }
+
 static rb_data_type_t Message_type = {
     "Google::Protobuf::Message",
-    {Message_mark, RUBY_DEFAULT_FREE, NULL},
+    {Message_mark, RUBY_DEFAULT_FREE, Message_memsize},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 

data/ext/google/protobuf_c/protobuf.c

@@ -164,11 +164,23 @@ static void Arena_free(void *data) {
   xfree(arena);
 }
 
+static size_t Arena_memsize(const void *data) {
+  const Arena *arena = data;
+  size_t fused_count;
+  size_t memsize = upb_Arena_SpaceAllocated(arena->arena, &fused_count);
+  if (fused_count > 1) {
+    // If other arena were fused we attribute an equal
+    // share of memory usage to each one.
+    memsize /= fused_count;
+  }
+  return memsize + sizeof(Arena);
+}
+
 static VALUE cArena;
 
 const rb_data_type_t Arena_type = {
     "Google::Protobuf::Internal::Arena",
-    {Arena_mark, Arena_free, NULL},
+    {Arena_mark, Arena_free, Arena_memsize},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
@@ -241,16 +253,17 @@ static void ObjectCache_Init(VALUE protobuf) {
   item_try_add = rb_intern("try_add");
 
   rb_gc_register_address(&weak_obj_cache);
+  VALUE internal = rb_const_get(protobuf, rb_intern("Internal"));
 #if SIZEOF_LONG >= SIZEOF_VALUE
-  VALUE cache_class = rb_const_get(protobuf, rb_intern("ObjectCache"));
+  VALUE cache_class = rb_const_get(internal, rb_intern("ObjectCache"));
 #else
-  VALUE cache_class = rb_const_get(protobuf, rb_intern("LegacyObjectCache"));
+  VALUE cache_class = rb_const_get(internal, 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));
+  rb_const_set(internal, rb_intern("OBJECT_CACHE"), weak_obj_cache);
+  rb_const_set(internal, rb_intern("SIZEOF_LONG"), INT2NUM(SIZEOF_LONG));
+  rb_const_set(internal, rb_intern("SIZEOF_VALUE"), INT2NUM(SIZEOF_VALUE));
 }
 
 static VALUE ObjectCache_GetKey(const void *key) {

data/ext/google/protobuf_c/ruby-upb.c

@@ -4085,9 +4085,10 @@ static upb_ArenaRoot _upb_Arena_FindRoot(upb_Arena* a) {
   return (upb_ArenaRoot){.root = ai, .tagged_count = poc};
 }
 
-size_t upb_Arena_SpaceAllocated(upb_Arena* arena) {
+size_t upb_Arena_SpaceAllocated(upb_Arena* arena, size_t* fused_count) {
   upb_ArenaInternal* ai = _upb_Arena_FindRoot(arena).root;
   size_t memsize = 0;
+  size_t local_fused_count = 0;
 
   while (ai != NULL) {
     upb_MemBlock* block = upb_Atomic_Load(&ai->blocks, memory_order_relaxed);
@@ -4096,8 +4097,10 @@ size_t upb_Arena_SpaceAllocated(upb_Arena* arena) {
       block = upb_Atomic_Load(&block->next, memory_order_relaxed);
     }
     ai = upb_Atomic_Load(&ai->next, memory_order_relaxed);
+    local_fused_count++;
   }
 
+  if (fused_count) *fused_count = local_fused_count;
   return memsize;
 }
 

data/ext/google/protobuf_c/ruby-upb.h

@@ -349,7 +349,7 @@ void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
 
 // Must be last.
 
-#define _kUpb_Status_MaxMessage 127
+#define _kUpb_Status_MaxMessage 511
 
 typedef struct {
   bool ok;
@@ -780,7 +780,7 @@ UPB_API bool upb_Arena_Fuse(upb_Arena* a, upb_Arena* b);
 bool upb_Arena_IncRefFor(upb_Arena* a, const void* owner);
 void upb_Arena_DecRefFor(upb_Arena* a, const void* owner);
 
-size_t upb_Arena_SpaceAllocated(upb_Arena* a);
+size_t upb_Arena_SpaceAllocated(upb_Arena* a, size_t* fused_count);
 uint32_t upb_Arena_DebugRefCount(upb_Arena* a);
 
 UPB_API_INLINE upb_Arena* upb_Arena_New(void) {

data/lib/google/protobuf/ffi/object_cache.rb

@@ -18,13 +18,13 @@ module Google
 
     def self.cache_implementation
       if interpreter_supports_non_finalized_keys_in_weak_map? and SIZEOF_LONG >= SIZEOF_VALUE
-        Google::Protobuf::ObjectCache
+        Google::Protobuf::Internal::ObjectCache
       else
-        Google::Protobuf::LegacyObjectCache
+        Google::Protobuf::Internal::LegacyObjectCache
       end
     end
 
     public
     OBJECT_CACHE = cache_implementation.new
   end
-end
+end

data/lib/google/protobuf/internal/object_cache.rb

@@ -0,0 +1,99 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2023 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+module Google
+  module Protobuf
+    module Internal
+      # 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. If sizeof(long) > sizeof(VALUE), we also
+      # need a secondary Hash to store WeakMap keys, because our pointer keys may
+      # need to be stored as Bignum instead of Fixnum.  Since WeakMap is weak for
+      # both keys and values, a Bignum key will cause the WeakMap entry to be
+      # collected immediately unless there is another reference to the Bignum.
+      # 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.
+      class ObjectCache
+        def initialize
+          @map = ObjectSpace::WeakMap.new
+          @mutex = Mutex.new
+        end
+
+        def get(key)
+          @map[key]
+        end
+
+        def try_add(key, value)
+          @map[key] || @mutex.synchronize do
+            @map[key] ||= value
+          end
+        end
+      end
+
+      class LegacyObjectCache
+        def initialize
+          @secondary_map = {}
+          @map = ObjectSpace::WeakMap.new
+          @mutex = Mutex.new
+        end
+
+        def get(key)
+          value = if secondary_key = @secondary_map[key]
+            @map[secondary_key]
+          else
+            @mutex.synchronize do
+              @map[(@secondary_map[key] ||= Object.new)]
+            end
+          end
+
+          # 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.
+          cutoff = (@secondary_map.size * 0.2).ceil
+          cutoff = 2_000 if cutoff < 2_000
+          if (@secondary_map.size - @map.size) > cutoff
+            purge
+          end
+
+          value
+        end
+
+        def try_add(key, value)
+          if secondary_key = @secondary_map[key]
+            if old_value = @map[secondary_key]
+              return old_value
+            end
+          end
+
+          @mutex.synchronize do
+            secondary_key ||= (@secondary_map[key] ||= Object.new)
+            @map[secondary_key] ||= value
+          end
+        end
+
+        private
+
+        def purge
+          @mutex.synchronize do
+            @secondary_map.each do |key, secondary_key|
+              unless @map.key?(secondary_key)
+                @secondary_map.delete(key)
+              end
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/google/protobuf.rb

@@ -7,7 +7,7 @@
 
 # require mixins before we hook them into the java & c code
 require 'google/protobuf/message_exts'
-require 'google/protobuf/object_cache'
+require 'google/protobuf/internal/object_cache'
 
 # We define these before requiring the platform-specific modules.
 # That way the module init can grab references to these.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google-protobuf
 version: !ruby/object:Gem::Version
-  version: 4.26.0.rc.2
+  version: 4.26.0
 platform: x64-mingw-ucrt
 authors:
 - Protobuf Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-06 00:00:00.000000000 Z
+date: 2024-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler-dock
@@ -156,8 +156,8 @@ files:
 - lib/google/protobuf/ffi/oneof_descriptor.rb
 - lib/google/protobuf/ffi/repeated_field.rb
 - lib/google/protobuf/field_mask_pb.rb
+- lib/google/protobuf/internal/object_cache.rb
 - lib/google/protobuf/message_exts.rb
-- lib/google/protobuf/object_cache.rb
 - lib/google/protobuf/plugin_pb.rb
 - lib/google/protobuf/repeated_field.rb
 - lib/google/protobuf/source_context_pb.rb
@@ -173,7 +173,7 @@ homepage: https://developers.google.com/protocol-buffers
 licenses:
 - BSD-3-Clause
 metadata:
-  source_code_uri: https://github.com/protocolbuffers/protobuf/tree/v4.26.0-rc2/ruby
+  source_code_uri: https://github.com/protocolbuffers/protobuf/tree/v4.26.0/ruby
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -188,9 +188,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.4.dev
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.3.26
 signing_key: 

data/lib/google/protobuf/object_cache.rb

@@ -1,97 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2023 Google Inc.  All rights reserved.
-#
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file or at
-# https://developers.google.com/open-source/licenses/bsd
-
-module Google
-  module Protobuf
-    # 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. If sizeof(long) > sizeof(VALUE), we also
-    # need a secondary Hash to store WeakMap keys, because our pointer keys may
-    # need to be stored as Bignum instead of Fixnum.  Since WeakMap is weak for
-    # both keys and values, a Bignum key will cause the WeakMap entry to be
-    # collected immediately unless there is another reference to the Bignum.
-    # 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.
-    class ObjectCache
-      def initialize
-        @map = ObjectSpace::WeakMap.new
-        @mutex = Mutex.new
-      end
-
-      def get(key)
-        @map[key]
-      end
-
-      def try_add(key, value)
-        @map[key] || @mutex.synchronize do
-          @map[key] ||= value
-        end
-      end
-    end
-
-    class LegacyObjectCache
-      def initialize
-        @secondary_map = {}
-        @map = ObjectSpace::WeakMap.new
-        @mutex = Mutex.new
-      end
-
-      def get(key)
-        value = if secondary_key = @secondary_map[key]
-          @map[secondary_key]
-        else
-          @mutex.synchronize do
-            @map[(@secondary_map[key] ||= Object.new)]
-          end
-        end
-
-        # 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.
-        cutoff = (@secondary_map.size * 0.2).ceil
-        cutoff = 2_000 if cutoff < 2_000
-        if (@secondary_map.size - @map.size) > cutoff
-          purge
-        end
-
-        value
-      end
-
-      def try_add(key, value)
-        if secondary_key = @secondary_map[key]
-          if old_value = @map[secondary_key]
-            return old_value
-          end
-        end
-
-        @mutex.synchronize do
-          secondary_key ||= (@secondary_map[key] ||= Object.new)
-          @map[secondary_key] ||= value
-        end
-      end
-
-      private
-
-      def purge
-        @mutex.synchronize do
-          @secondary_map.each do |key, secondary_key|
-            unless @map.key?(secondary_key)
-              @secondary_map.delete(key)
-            end
-          end
-        end
-        nil
-      end
-    end
-  end
-end