Move the firstInSequence/lastInSequence fields to BucketsHashStore

* Other strategies do not need them.

Author: eregon

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

@@ -58,7 +58,7 @@ public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode {
         protected RubyHash allocate(RubyClass rubyClass) {
             final Shape shape = getLanguage().hashShape;
             final EmptyHashStore store = EmptyHashStore.NULL_HASH_STORE;
-            final RubyHash hash = new RubyHash(rubyClass, shape, getContext(), store, 0, null, null, nil, nil, false);
+            final RubyHash hash = new RubyHash(rubyClass, shape, getContext(), store, 0, nil, nil, false);
             AllocationTracing.trace(hash, this);
             return hash;
         }
@@ -109,7 +109,7 @@ protected Object construct(RubyClass hashClass, Object[] args,
             }
 
             final Shape shape = getLanguage().hashShape;
-            return new RubyHash(hashClass, shape, getContext(), newStore, size, null, null, nil, nil, false);
+            return new RubyHash(hashClass, shape, getContext(), newStore, size, nil, nil, false);
         }
 
         @Specialization(guards = "!isSmallArrayOfPairs(args, getLanguage())")

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

@@ -27,8 +27,6 @@ public static RubyHash newEmptyHash(RubyContext context, RubyLanguage language)
                 context,
                 EmptyHashStore.NULL_HASH_STORE,
                 0,
-                null,
-                null,
                 nil,
                 nil,
                 false);

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

@@ -46,8 +46,6 @@ public class RubyHash extends RubyDynamicObject implements ObjectGraphNode {
     public Object defaultValue;
     public Object store;
     public int size;
-    public Entry firstInSequence;
-    public Entry lastInSequence;
     public boolean compareByIdentity;
     public boolean ruby2_keywords = false;
 
@@ -57,8 +55,6 @@ public RubyHash(
             RubyContext context,
             Object store,
             int size,
-            Entry firstInSequence,
-            Entry lastInSequence,
             Object defaultBlock,
             Object defaultValue,
             boolean compareByIdentity) {
@@ -67,8 +63,6 @@ public RubyHash(
         this.defaultValue = defaultValue;
         this.store = store;
         this.size = size;
-        this.firstInSequence = firstInSequence;
-        this.lastInSequence = lastInSequence;
         this.compareByIdentity = compareByIdentity;
 
         if (context.isPreInitializing()) {
@@ -79,7 +73,7 @@ public RubyHash(
     @TruffleBoundary
     public void getAdjacentObjects(Set<Object> reachable) {
         if (store instanceof BucketsHashStore) {
-            BucketsHashStore.getAdjacentObjects(reachable, firstInSequence);
+            ((BucketsHashStore) store).getAdjacentObjects(reachable);
         } else {
             ObjectGraph.addProperty(reachable, store);
         }

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

@@ -55,9 +55,13 @@
 public class BucketsHashStore {
 
     private final Entry[] entries;
+    private Entry firstInSequence;
+    private Entry lastInSequence;
 
-    public BucketsHashStore(Entry[] entries) {
+    public BucketsHashStore(Entry[] entries, Entry firstInSequence, Entry lastInSequence) {
         this.entries = entries;
+        this.firstInSequence = firstInSequence;
+        this.lastInSequence = lastInSequence;
     }
 
     // region Constants
@@ -121,49 +125,52 @@ static int getBucketIndex(int hashed, int bucketsCount) {
     }
 
     @TruffleBoundary
-    private static void resize(RubyHash hash) {
-        final int bucketsCount = capacityGreaterThan(hash.size) * OVERALLOCATE_FACTOR;
+    private void resize(RubyHash hash, int size) {
+        final int bucketsCount = capacityGreaterThan(size) * OVERALLOCATE_FACTOR;
         final Entry[] newEntries = new Entry[bucketsCount];
 
-        Entry entry = hash.firstInSequence;
+        final Entry firstInSequence = this.firstInSequence;
+        Entry lastInSequence = null;
+        Entry entry = firstInSequence;
 
         while (entry != null) {
             final int bucketIndex = getBucketIndex(entry.getHashed(), bucketsCount);
             appendToLookupChain(newEntries, entry, bucketIndex);
 
             entry.setNextInLookup(null);
+            lastInSequence = entry;
             entry = entry.getNextInSequence();
         }
 
-        hash.store = new BucketsHashStore(newEntries);
+        hash.store = new BucketsHashStore(newEntries, firstInSequence, lastInSequence);
     }
 
-    public static void getAdjacentObjects(Set<Object> reachable, Entry firstInSequence) {
-        Entry entry = firstInSequence;
+    public void getAdjacentObjects(Set<Object> reachable) {
+        Entry entry = this.firstInSequence;
         while (entry != null) {
             ObjectGraph.addProperty(reachable, entry.getKey());
             ObjectGraph.addProperty(reachable, entry.getValue());
             entry = entry.getNextInSequence();
         }
     }
 
-    private static void removeFromSequenceChain(RubyHash hash, Entry entry) {
+    private void removeFromSequenceChain(Entry entry) {
         final Entry previousInSequence = entry.getPreviousInSequence();
         final Entry nextInSequence = entry.getNextInSequence();
 
         if (previousInSequence == null) {
-            assert hash.firstInSequence == entry;
-            hash.firstInSequence = nextInSequence;
+            assert this.firstInSequence == entry;
+            this.firstInSequence = nextInSequence;
         } else {
-            assert hash.firstInSequence != entry;
+            assert this.firstInSequence != entry;
             previousInSequence.setNextInSequence(nextInSequence);
         }
 
         if (nextInSequence == null) {
-            assert hash.lastInSequence == entry;
-            hash.lastInSequence = previousInSequence;
+            assert this.lastInSequence == entry;
+            this.lastInSequence = previousInSequence;
         } else {
-            assert hash.lastInSequence != entry;
+            assert this.lastInSequence != entry;
             nextInSequence.setPreviousInSequence(previousInSequence);
         }
     }
@@ -243,20 +250,20 @@ protected boolean set(RubyHash hash, Object key, Object value, boolean byIdentit
                 result.getPreviousEntry().setNextInLookup(newEntry);
             }
 
-            final Entry lastInSequence = hash.lastInSequence;
+            final Entry lastInSequence = this.lastInSequence;
             if (appending.profile(lastInSequence == null)) {
-                hash.firstInSequence = newEntry;
+                this.firstInSequence = newEntry;
             } else {
                 lastInSequence.setNextInSequence(newEntry);
                 newEntry.setPreviousInSequence(lastInSequence);
             }
-            hash.lastInSequence = newEntry;
+            this.lastInSequence = newEntry;
 
             final int newSize = (hash.size += 1);
             assert verify(hash);
 
             if (resize.profile(newSize / (double) entries.length > LOAD_FACTOR)) {
-                resize(hash);
+                resize(hash, newSize);
                 assert ((BucketsHashStore) hash.store).verify(hash); // store changed!
             }
             return true;
@@ -281,7 +288,7 @@ protected Object delete(RubyHash hash, Object key,
             return null;
         }
 
-        removeFromSequenceChain(hash, entry);
+        removeFromSequenceChain(entry);
         removeFromLookupChain(entries, lookupResult.getIndex(), entry, lookupResult.getPreviousEntry());
         hash.size -= 1;
         assert verify(hash);
@@ -294,7 +301,7 @@ protected Object deleteLast(RubyHash hash, Object key,
         assert verify(hash);
 
         final Entry[] entries = this.entries;
-        final Entry lastEntry = hash.lastInSequence;
+        final Entry lastEntry = this.lastInSequence;
         if (key != lastEntry.getKey()) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
             throw CompilerDirectives
@@ -311,15 +318,15 @@ protected Object deleteLast(RubyHash hash, Object key,
         }
         assert entry.getNextInSequence() == null;
 
-        if (singleEntry.profile(hash.firstInSequence == entry)) {
+        if (singleEntry.profile(this.firstInSequence == entry)) {
             assert entry.getPreviousInSequence() == null;
-            hash.firstInSequence = null;
-            hash.lastInSequence = null;
+            this.firstInSequence = null;
+            this.lastInSequence = null;
         } else {
             assert entry.getPreviousInSequence() != null;
             final Entry previousInSequence = entry.getPreviousInSequence();
             previousInSequence.setNextInSequence(null);
-            hash.lastInSequence = previousInSequence;
+            this.lastInSequence = previousInSequence;
         }
 
         removeFromLookupChain(entries, index, entry, previousEntry);
@@ -336,7 +343,7 @@ protected Object eachEntry(RubyHash hash, EachEntryCallback callback, Object sta
         assert verify(hash);
         loopProfile.profileCounted(hash.size);
         int i = 0;
-        Entry entry = hash.firstInSequence;
+        Entry entry = this.firstInSequence;
         try {
             while (loopProfile.inject(entry != null)) {
                 callback.accept(i++, entry.getKey(), entry.getValue(), state);
@@ -370,7 +377,7 @@ protected void replace(RubyHash hash, RubyHash dest,
 
         Entry firstInSequence = null;
         Entry lastInSequence = null;
-        Entry entry = hash.firstInSequence;
+        Entry entry = this.firstInSequence;
 
         while (entry != null) {
             final Entry newEntry = new Entry(entry.getHashed(), entry.getKey(), entry.getValue());
@@ -388,10 +395,8 @@ protected void replace(RubyHash hash, RubyHash dest,
             entry = entry.getNextInSequence();
         }
 
-        dest.store = new BucketsHashStore(newEntries);
+        dest.store = new BucketsHashStore(newEntries, firstInSequence, lastInSequence);
         dest.size = hash.size;
-        dest.firstInSequence = firstInSequence;
-        dest.lastInSequence = lastInSequence;
         dest.defaultBlock = hash.defaultBlock;
         dest.defaultValue = hash.defaultValue;
         dest.compareByIdentity = hash.compareByIdentity;
@@ -406,21 +411,18 @@ protected RubyArray shift(RubyHash hash,
         assert verify(hash);
 
         final Entry[] entries = this.entries;
-        final Entry first = hash.firstInSequence;
+        final Entry first = this.firstInSequence;
         assert first.getPreviousInSequence() == null;
 
         final Object key = first.getKey();
         final Object value = first.getValue();
 
-        hash.firstInSequence = first.getNextInSequence();
-
-        if (first.getNextInSequence() != null) {
-            first.getNextInSequence().setPreviousInSequence(null);
-            hash.firstInSequence = first.getNextInSequence();
-        }
-
-        if (hash.lastInSequence == first) {
-            hash.lastInSequence = null;
+        final Entry second = first.getNextInSequence();
+        this.firstInSequence = second;
+        if (second == null) {
+            this.lastInSequence = null;
+        } else {
+            second.setPreviousInSequence(null);
         }
 
         final int index = getBucketIndex(first.getHashed(), entries.length);
@@ -452,7 +454,7 @@ protected void rehash(RubyHash hash,
         final Entry[] entries = this.entries;
         Arrays.fill(entries, null);
 
-        Entry entry = hash.firstInSequence;
+        Entry entry = this.firstInSequence;
         while (entry != null) {
             final int newHash = hashNode.execute(entry.getKey(), hash.compareByIdentity);
             entry.setHashed(newHash);
@@ -474,7 +476,7 @@ protected void rehash(RubyHash hash,
                             newHash,
                             bucketEntry.getKey(),
                             bucketEntry.getHashed())) {
-                        removeFromSequenceChain(hash, entry);
+                        removeFromSequenceChain(entry);
                         size--;
                         break;
                     }
@@ -498,8 +500,8 @@ public boolean verify(RubyHash hash) {
 
         final Entry[] entries = this.entries;
         final int size = hash.size;
-        final Entry firstInSequence = hash.firstInSequence;
-        final Entry lastInSequence = hash.lastInSequence;
+        final Entry firstInSequence = this.firstInSequence;
+        final Entry lastInSequence = this.lastInSequence;
         assert lastInSequence == null || lastInSequence.getNextInSequence() == null;
 
         Entry foundFirst = null;
@@ -603,10 +605,8 @@ public Object execute(VirtualFrame frame) {
                     coreLibrary().hashClass,
                     getLanguage().hashShape,
                     getContext(),
-                    new BucketsHashStore(new Entry[bucketsCount]),
+                    new BucketsHashStore(new Entry[bucketsCount], null, null),
                     0,
-                    null,
-                    null,
                     nil,
                     nil,
                     false);

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

@@ -86,8 +86,6 @@ protected void replace(RubyHash hash, RubyHash dest,
         propagateSharing.executePropagate(dest, hash);
         dest.store = EmptyHashStore.NULL_HASH_STORE;
         dest.size = 0;
-        dest.firstInSequence = null;
-        dest.lastInSequence = null;
         dest.defaultBlock = hash.defaultBlock;
         dest.defaultValue = hash.defaultValue;
         dest.compareByIdentity = hash.compareByIdentity;
@@ -110,8 +108,6 @@ public boolean verify(RubyHash hash) {
         assert hash.store == this;
         assert hash.store == NULL_HASH_STORE;
         assert hash.size == 0;
-        assert hash.firstInSequence == null;
-        assert hash.lastInSequence == null;
         return true;
     }
 

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

@@ -72,8 +72,6 @@ public abstract Object lookupOrDefault(Object store, Frame frame, RubyHash hash,
     public void clear(Object store, RubyHash hash) {
         hash.store = EmptyHashStore.NULL_HASH_STORE;
         hash.size = 0;
-        hash.firstInSequence = null;
-        hash.lastInSequence = null;
     }
 
     /** Removes the entry for the key from the hash, and returns the associated value. If the hash does not have an

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

@@ -150,10 +150,8 @@ private static void promoteToBuckets(RubyHash hash, Object[] store, int size) {
             BucketsHashStore.appendToLookupChain(buckets, entry, bucketIndex);
         }
 
-        hash.store = new BucketsHashStore(buckets);
+        hash.store = new BucketsHashStore(buckets, firstInSequence, lastInSequence);
         hash.size = size;
-        hash.firstInSequence = firstInSequence;
-        hash.lastInSequence = lastInSequence;
     }
 
     // endregion
@@ -317,8 +315,6 @@ protected static void replace(Object[] store, RubyHash hash, RubyHash dest,
         int size = hash.size;
         dest.store = storeCopy;
         dest.size = size;
-        dest.firstInSequence = null;
-        dest.lastInSequence = null;
         dest.defaultBlock = hash.defaultBlock;
         dest.defaultValue = hash.defaultValue;
         dest.compareByIdentity = hash.compareByIdentity;
@@ -377,11 +373,6 @@ protected static boolean verify(Object[] store, RubyHash hash) {
         final int size = hash.size;
         assert store.length == TOTAL_ELEMENTS : store.length;
 
-        final Entry firstInSequence = hash.firstInSequence;
-        final Entry lastInSequence = hash.lastInSequence;
-        assert firstInSequence == null;
-        assert lastInSequence == null;
-
         for (int i = 0; i < size * ELEMENTS_PER_ENTRY; i++) {
             assert store[i] != null;
         }
@@ -534,8 +525,6 @@ public Object execute(VirtualFrame frame) {
                     getContext(),
                     store,
                     size,
-                    null,
-                    null,
                     nil,
                     nil,
                     false);