Fix global symbols table handling.

The global symbols table is now implemented as a concurrent_set.  We
handle it in a way similar to the fstring table.

Author: wks

concurrent_set.c

@@ -444,17 +444,18 @@ rb_mmtk_concurrent_set_foreach_with_replace_range(VALUE set_obj, size_t begin, s
     int deleted = 0;
 
     for (size_t i = begin; i < end; i++) {
+        struct concurrent_set_entry *entry = &set->entries[i];
         VALUE key = set->entries[i].key;
 
         switch (key) {
           case CONCURRENT_SET_EMPTY:
           case CONCURRENT_SET_DELETED:
             continue;
           case CONCURRENT_SET_MOVED:
-            rb_bug("rb_concurrent_set_foreach_with_replace_range: moved entry");
+            rb_bug("rb_mmtk_concurrent_set_foreach_with_replace_range: moved entry");
             break;
           default: {
-            int ret = callback(&set->entries[i].key, data);
+            int ret = callback(&entry->key, data);
             switch (ret) {
               case ST_STOP:
                 return;

internal/mmtk.h

@@ -31,6 +31,10 @@ typedef uint32_t MMTk_AllocationSemantics;
 
 #define MMTK_HIDDEN_SIZE_MASK 281474976710655
 
+#define MMTK_WEAK_CONCURRENT_SET_KIND_FSTRING 0
+
+#define MMTK_WEAK_CONCURRENT_SET_KIND_GLOBAL_SYMBOLS 1
+
 typedef struct st_table st_table;
 
 typedef struct RubyBindingOptions {
@@ -103,8 +107,8 @@ typedef struct MMTk_RubyUpcalls {
     void (*update_frozen_strings_table)(void);
     size_t (*get_cc_refinement_table_size)(void);
     void (*update_cc_refinement_table)(void);
-    MMTk_ObjectReference (*get_fstring_table_obj)(void);
-    struct st_table *(*get_global_symbols_table)(void);
+    MMTk_NullableObjectReference (*get_fstring_table_obj)(void);
+    MMTk_NullableObjectReference (*get_global_symbols_table_obj)(void);
     size_t (*st_get_num_entries)(const struct st_table *table);
     void (*st_get_size_info)(const struct st_table *table,
                              size_t *entries_start,
@@ -122,6 +126,7 @@ typedef struct MMTk_RubyUpcalls {
     void (*concurrent_set_update_entries_range)(MMTk_ObjectReference set,
                                                 size_t begin,
                                                 size_t end,
+                                                uint8_t kind,
                                                 struct MMTk_ConcurrentSetStats *stats);
     void (*before_updating_jit_code)(void);
     void (*after_updating_jit_code)(void);

internal/symbol.h

@@ -19,6 +19,10 @@
 /* symbol.c */
 void rb_sym_global_symbols_mark(void);
 void rb_sym_global_symbols_update_references(void);
+#if USE_MMTK
+size_t rb_mmtk_get_sym_set_num_entries(void);
+VALUE rb_mmtk_get_sym_set(void);
+#endif
 VALUE rb_to_symbol_type(VALUE obj);
 VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc);
 VALUE rb_sym_intern_ascii(const char *ptr, long len);
@@ -33,6 +37,9 @@ ID rb_make_internal_id(void);
 ID rb_make_temporary_id(size_t n);
 bool rb_obj_is_symbol_table(VALUE obj);
 void rb_sym_global_symbol_table_foreach_weak_reference(int (*callback)(VALUE *key, void *data), void *data);
+#if USE_MMTK
+void rb_mmtk_sym_global_symbol_table_foreach_weak_reference_range(size_t begin, size_t end, int (*callback)(VALUE *key, void *data), void *data);
+#endif
 void rb_gc_free_dsymbol(VALUE);
 int rb_static_id_valid_p(ID id);
 

mmtk_support.c

@@ -7,6 +7,7 @@
 #include "internal/gc.h"
 #include "internal/imemo.h"
 #include "internal/string.h"
+#include "internal/symbol.h"
 #include "internal/thread.h"
 #include "internal/variable.h"
 #include "ruby/ruby.h"
@@ -1272,27 +1273,18 @@ rb_mmtk_update_overloaded_cme_table(void)
 
 //////// Global symbols table
 
-extern rb_symbols_t ruby_global_symbols;
-
 size_t
 rb_mmtk_get_global_symbols_table_size(void)
 {
-    return ruby_global_symbols.str_sym->num_entries;
+    return rb_mmtk_get_sym_set_num_entries();
 }
 
 void
 rb_mmtk_update_global_symbols_table(void)
 {
-    // String-to-symbol table.
-    // Keys are the strings, hasshed by content (rb_str_hash).
-    // Values are symbol objects.  A symbol holds a reference to its
-    // corresponding string, so if the value is live, the key must be live.
-    // We need to remove entries for dead symbols.
-    rb_mmtk_update_weak_table(ruby_global_symbols.str_sym,
-                              false,
-                              RB_MMTK_VALUES_WEAK_REF,
-                              NULL,
-                              NULL);
+    // The global symbols table is a weak set of symbols.
+    // It is backed by a concurrent_set.
+    rb_gc_vm_weak_table_foreach(rb_mmtk_update_table_i, rb_mmtk_update_table_replace_i, NULL, false, RB_GC_VM_GLOBAL_SYMBOLS_TABLE);
 }
 
 //////// Finalizer and id2ref tables
@@ -1920,10 +1912,10 @@ rb_mmtk_get_fstring_table_obj_wrapper(void)
     return (MMTk_ObjectReference)rb_mmtk_get_fstring_table_obj();
 }
 
-static st_table*
-rb_mmtk_get_global_symbols_table(void)
+static MMTk_ObjectReference
+rb_mmtk_get_global_symbols_table_obj(void)
 {
-    return ruby_global_symbols.str_sym;
+    return (MMTk_ObjectReference)rb_mmtk_get_sym_set();
 }
 
 static size_t
@@ -1944,7 +1936,11 @@ rb_mmtk_concurrent_set_update_entries_range_i(VALUE *key, void *data)
     MMTk_ConcurrentSetStats *stats = (MMTk_ConcurrentSetStats*)data;
     VALUE old_key = *key;
 
-    assert(!rb_special_const_p(old_key));
+    if (rb_special_const_p(old_key)) {
+        // The global symbols table may contain integers which encode static symbols.
+        // We skip them.
+        return ST_CONTINUE;
+    }
 
     if (mmtk_is_reachable((MMTk_ObjectReference)old_key)) {
         stats->live++;
@@ -1961,9 +1957,24 @@ rb_mmtk_concurrent_set_update_entries_range_i(VALUE *key, void *data)
 }
 
 static void
-rb_mmtk_concurrent_set_update_entries_range(MMTk_ObjectReference set_obj, size_t begin, size_t end, MMTk_ConcurrentSetStats *stats)
+rb_mmtk_concurrent_set_update_entries_range(MMTk_ObjectReference set_obj, size_t begin, size_t end, uint8_t kind, MMTk_ConcurrentSetStats *stats)
 {
-    rb_mmtk_concurrent_set_foreach_with_replace_range((VALUE)set_obj, begin, end, rb_mmtk_concurrent_set_update_entries_range_i, stats);
+    int (*callback)(VALUE*, void*) = rb_mmtk_concurrent_set_update_entries_range_i;
+    void *data = stats;
+
+    switch (kind) {
+        case MMTK_WEAK_CONCURRENT_SET_KIND_GLOBAL_SYMBOLS: {
+            // Global symbols table need special handling.
+            // rb_mmtk_sym_global_symbol_table_foreach_weak_reference_range will handle static symbols.
+            assert((VALUE)set_obj == rb_mmtk_get_sym_set());
+            rb_mmtk_sym_global_symbol_table_foreach_weak_reference_range(begin, end, callback, data);
+            break;
+        }
+        default: {
+            rb_mmtk_concurrent_set_foreach_with_replace_range((VALUE)set_obj, begin, end, callback, data);
+            break;
+        }
+    }
 }
 
 MMTk_RubyUpcalls ruby_upcalls = {
@@ -2008,7 +2019,7 @@ MMTk_RubyUpcalls ruby_upcalls = {
     rb_mmtk_update_cc_refinement_table,
     // Get tables for specialized processing
     rb_mmtk_get_fstring_table_obj_wrapper,
-    rb_mmtk_get_global_symbols_table,
+    rb_mmtk_get_global_symbols_table_obj,
     // Detailed st_table info queries and operations
     rb_mmtk_st_get_num_entries,
     rb_mmtk_st_get_size_info,

symbol.c

@@ -412,6 +412,22 @@ rb_sym_global_symbols_update_references(void)
     symbols->ids = rb_gc_location(symbols->ids);
 }
 
+#if USE_MMTK
+size_t
+rb_mmtk_get_sym_set_num_entries(void)
+{
+    rb_symbols_t *symbols = &ruby_global_symbols;
+    return rb_mmtk_concurrent_set_get_num_entries(symbols->sym_set);
+}
+
+VALUE
+rb_mmtk_get_sym_set(void)
+{
+    rb_symbols_t *symbols = &ruby_global_symbols;
+    return symbols->sym_set;
+}
+#endif
+
 WARN_UNUSED_RESULT(static ID lookup_str_id(VALUE str));
 WARN_UNUSED_RESULT(static VALUE lookup_id_str(ID id));
 
@@ -951,6 +967,21 @@ rb_sym_global_symbol_table_foreach_weak_reference(int (*callback)(VALUE *key, vo
     rb_concurrent_set_foreach_with_replace(ruby_global_symbols.sym_set, rb_sym_global_symbol_table_foreach_weak_reference_i, &foreach_data);
 }
 
+#if USE_MMTK
+void
+rb_mmtk_sym_global_symbol_table_foreach_weak_reference_range(size_t begin, size_t end, int (*callback)(VALUE *key, void *data), void *data)
+{
+    if (!ruby_global_symbols.sym_set) return;
+
+    struct global_symbol_table_foreach_weak_reference_data foreach_data = {
+        .callback = callback,
+        .data = data,
+    };
+
+    rb_mmtk_concurrent_set_foreach_with_replace_range(ruby_global_symbols.sym_set, begin, end, rb_sym_global_symbol_table_foreach_weak_reference_i, &foreach_data);
+}
+#endif
+
 void
 rb_gc_free_dsymbol(VALUE sym)
 {