made compact hashes the default, bucket hashes are strategy that require explicit config

Author: moste00

src/main/java/org/truffleruby/core/hash/HashLiteralNode.java

@@ -14,6 +14,7 @@
 import org.truffleruby.core.hash.library.EmptyHashStore;
 import org.truffleruby.core.hash.library.PackedHashStoreLibrary;
 import org.truffleruby.core.hash.library.PackedHashStoreLibraryFactory;
+import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyContextSourceNode;
 import org.truffleruby.language.RubyNode;
 
@@ -29,10 +30,14 @@ protected HashLiteralNode(RubyNode[] keyValues) {
         this.keyValues = keyValues;
     }
 
-    private static final boolean bigHashTypeIsCompactHash;
-    static {
-        String type = System.getProperty("BigHashStrategy");
-        bigHashTypeIsCompactHash = type != null && type.equalsIgnoreCase("compact");
+    public static final class BigHashConfiguredStrategy extends RubyBaseNode {
+        private BigHashConfiguredStrategy() {
+            isBuckets = getContext().getOptions().BIG_HASH_STRATEGY;
+        }
+
+        // dummy instance, so we can call getContext instance method, never used
+        private static final BigHashConfiguredStrategy bh = new BigHashConfiguredStrategy();
+        public static boolean isBuckets;
     }
 
     public static HashLiteralNode create(RubyNode[] keyValues) {
@@ -41,9 +46,9 @@ public static HashLiteralNode create(RubyNode[] keyValues) {
         } else if (keyValues.length <= PackedHashStoreLibrary.MAX_ENTRIES * 2) {
             return PackedHashStoreLibraryFactory.SmallHashLiteralNodeGen.create(keyValues);
         } else {
-            return bigHashTypeIsCompactHash
-                    ? new CompactHashStore.CompactHashLiteralNode(keyValues)
-                    : new BucketsHashStore.GenericHashLiteralNode(keyValues);
+            return BigHashConfiguredStrategy.isBuckets
+                    ? new BucketsHashStore.GenericHashLiteralNode(keyValues)
+                    : new CompactHashStore.CompactHashLiteralNode(keyValues);
         }
     }
 

src/main/java/org/truffleruby/core/hash/library/PackedHashStoreLibrary.java

@@ -63,12 +63,6 @@ public final class PackedHashStoreLibrary {
     private static final int ELEMENTS_PER_ENTRY = 3;
     public static final int TOTAL_ELEMENTS = MAX_ENTRIES * ELEMENTS_PER_ENTRY;
 
-    private static final boolean bigHashTypeIsCompact;
-    static {
-        String hashType = System.getProperty("BigHashStrategy");
-        bigHashTypeIsCompact = hashType != null && hashType.equalsIgnoreCase("compact");
-    }
-
     // region Utilities
 
     public static Object[] createStore() {
@@ -241,14 +235,19 @@ static boolean set(Object[] store, RubyHash hash, Object key, Object value, bool
                 return true;
             }
 
-            if (bigHashTypeIsCompact) {
-                promoteToCompact(hash, store, size);
-            } else {
-                promoteToBuckets(hash, store, size);
-            }
+            promoteToBigHash(store, hash, size);
+
             hashes.set(hash.store, hash, key2, value, byIdentity);
             return true;
         }
+
+        private static void promoteToBigHash(Object[] store, RubyHash hash, int size) {
+            if (HashLiteralNode.BigHashConfiguredStrategy.isBuckets) {
+                promoteToBuckets(hash, store, size);
+            } else {
+                promoteToCompact(hash, store, size);
+            }
+        }
     }
 
     @ExportMessage

src/main/java/org/truffleruby/options/Options.java

@@ -93,6 +93,8 @@ public final class Options {
     public final boolean EXCEPTIONS_WARN_OUT_OF_MEMORY;
     /** --backtraces-interleave-java=false */
     public final boolean BACKTRACES_INTERLEAVE_JAVA;
+    /** --buckets-big-hash=false */
+    public final boolean BIG_HASH_STRATEGY;
     /** --backtraces-on-interrupt=false */
     public final boolean BACKTRACE_ON_INTERRUPT;
     /** --backtraces-sigalrm=!EMBEDDED */
@@ -247,6 +249,7 @@ public Options(Env env, OptionValues options, LanguageOptions languageOptions) {
         EXCEPTIONS_WARN_STACKOVERFLOW = options.get(OptionsCatalog.EXCEPTIONS_WARN_STACKOVERFLOW_KEY);
         EXCEPTIONS_WARN_OUT_OF_MEMORY = options.get(OptionsCatalog.EXCEPTIONS_WARN_OUT_OF_MEMORY_KEY);
         BACKTRACES_INTERLEAVE_JAVA = options.get(OptionsCatalog.BACKTRACES_INTERLEAVE_JAVA_KEY);
+        BIG_HASH_STRATEGY = options.get(OptionsCatalog.BIG_HASH_STRATEGY_KEY);
         BACKTRACE_ON_INTERRUPT = options.get(OptionsCatalog.BACKTRACE_ON_INTERRUPT_KEY);
         BACKTRACE_ON_SIGALRM = options.hasBeenSet(OptionsCatalog.BACKTRACE_ON_SIGALRM_KEY) ? options.get(OptionsCatalog.BACKTRACE_ON_SIGALRM_KEY) : !EMBEDDED;
         BACKTRACE_ON_RAISE = options.get(OptionsCatalog.BACKTRACE_ON_RAISE_KEY);
@@ -378,6 +381,8 @@ public Object fromDescriptor(OptionDescriptor descriptor) {
                 return EXCEPTIONS_WARN_OUT_OF_MEMORY;
             case "ruby.backtraces-interleave-java":
                 return BACKTRACES_INTERLEAVE_JAVA;
+            case "ruby.buckets-big-hash":
+                return BIG_HASH_STRATEGY;
             case "ruby.backtraces-on-interrupt":
                 return BACKTRACE_ON_INTERRUPT;
             case "ruby.backtraces-sigalrm":

src/options.yml

@@ -117,6 +117,9 @@ EXPERT:
     EXCEPTIONS_WARN_OUT_OF_MEMORY: [exceptions-warn-out-of-memory, boolean, true, Warn when an out-of-memory error is thrown]
     BACKTRACES_INTERLEAVE_JAVA: [backtraces-interleave-java, boolean, false, Interleave Java stacktraces into the Ruby backtrace]
     BACKTRACES_OMIT_UNUSED: [backtraces-omit-unused, boolean, true, Omit backtraces that should be unused as they have pure rescue expressions]
+    
+    # Big Hash Strategy
+    BIG_HASH_STRATEGY: [buckets-big-hash, boolean, false, 'Whether to use chaining-style bukcets hash store for hash tables exceeding the small hash limit']
 
     # Print backtraces at key events
     BACKTRACE_ON_INTERRUPT: [backtraces-on-interrupt, boolean, false, Show the backtraces of all Threads on Ctrl+C]

src/shared/java/org/truffleruby/shared/options/OptionsCatalog.java

@@ -64,6 +64,7 @@ public final class OptionsCatalog {
     public static final OptionKey<Boolean> EXCEPTIONS_WARN_OUT_OF_MEMORY_KEY = new OptionKey<>(true);
     public static final OptionKey<Boolean> BACKTRACES_INTERLEAVE_JAVA_KEY = new OptionKey<>(false);
     public static final OptionKey<Boolean> BACKTRACES_OMIT_UNUSED_KEY = new OptionKey<>(true);
+    public static final OptionKey<Boolean> BIG_HASH_STRATEGY_KEY = new OptionKey<>(false);
     public static final OptionKey<Boolean> BACKTRACE_ON_INTERRUPT_KEY = new OptionKey<>(false);
     public static final OptionKey<Boolean> BACKTRACE_ON_SIGALRM_KEY = new OptionKey<>(!EMBEDDED_KEY.getDefaultValue());
     public static final OptionKey<Boolean> BACKTRACE_ON_RAISE_KEY = new OptionKey<>(false);
@@ -519,6 +520,14 @@ public final class OptionsCatalog {
             .usageSyntax("")
             .build();
 
+    public static final OptionDescriptor BIG_HASH_STRATEGY = OptionDescriptor
+            .newBuilder(BIG_HASH_STRATEGY_KEY, "ruby.buckets-big-hash")
+            .help("Whether to use chaining-style bukcets hash store for hash tables exceeding the small hash limit")
+            .category(OptionCategory.EXPERT)
+            .stability(OptionStability.EXPERIMENTAL)
+            .usageSyntax("")
+            .build();
+
     public static final OptionDescriptor BACKTRACE_ON_INTERRUPT = OptionDescriptor
             .newBuilder(BACKTRACE_ON_INTERRUPT_KEY, "ruby.backtraces-on-interrupt")
             .help("Show the backtraces of all Threads on Ctrl+C")
@@ -1425,6 +1434,8 @@ public static OptionDescriptor fromName(String name) {
                 return BACKTRACES_INTERLEAVE_JAVA;
             case "ruby.backtraces-omit-unused":
                 return BACKTRACES_OMIT_UNUSED;
+            case "ruby.buckets-big-hash":
+                return BIG_HASH_STRATEGY;
             case "ruby.backtraces-on-interrupt":
                 return BACKTRACE_ON_INTERRUPT;
             case "ruby.backtraces-sigalrm":
@@ -1680,6 +1691,7 @@ public static OptionDescriptor[] allDescriptors() {
             EXCEPTIONS_WARN_OUT_OF_MEMORY,
             BACKTRACES_INTERLEAVE_JAVA,
             BACKTRACES_OMIT_UNUSED,
+            BIG_HASH_STRATEGY,
             BACKTRACE_ON_INTERRUPT,
             BACKTRACE_ON_SIGALRM,
             BACKTRACE_ON_RAISE,