Improve SSA dominator computation memory usage (#14965)

* Improve SSA DF computation memory usage

DF(b) can be stored in a vector instead of a hashtable (set). Nothing needs a O(1) membership test, the duplicates that may be generated during DF construction can be easily avoided by observing that:
* each block in the graph is processed exactly once
* during processing the block is added to the relevant DF vectors, at the end of each vector. If the same DF vector is encountered multiple times then checking if the block is already a member is trivial.

* Use the same block BitVec for topo sort and IDom

* Add BitVecOps::TryAddElemD

Makes the code more readable and avoids the duplicated IsShort test that a separate IsMember/AddElemD may generate.

* Improve SSA IDF computation memory usage

Like DF(b), IDF(b) can be stored in a vector if duplicates are avoided. This can be done by using a BitVector like TopologicalSort and ComputeImmediateDom already do. It's cheaper than using a hashtable (even though it requires a "clear" for every block that has a frontier).

Also, storing IDF(b) into a vector makes it easier to track newly added blocks - they're at the end of the vector. Using a separate "delta" set is no longer needed.

Author: mikedn

src/jit/bitsetasshortlong.h

@@ -42,6 +42,7 @@ class BitSetOps</*BitSetType*/ BitSetShortLongRep,
     static void UnionDLong(Env env, BitSetShortLongRep& bs1, BitSetShortLongRep bs2);
     static void DiffDLong(Env env, BitSetShortLongRep& bs1, BitSetShortLongRep bs2);
     static void AddElemDLong(Env env, BitSetShortLongRep& bs, unsigned i);
+    static bool TryAddElemDLong(Env env, BitSetShortLongRep& bs, unsigned i);
     static void RemoveElemDLong(Env env, BitSetShortLongRep& bs, unsigned i);
     static void ClearDLong(Env env, BitSetShortLongRep& bs);
     static BitSetShortLongRep MakeUninitArrayBits(Env env);
@@ -276,6 +277,23 @@ class BitSetOps</*BitSetType*/ BitSetShortLongRep,
         return res;
     }
 
+    static bool TryAddElemD(Env env, BitSetShortLongRep& bs, unsigned i)
+    {
+        assert(i < BitSetTraits::GetSize(env));
+        if (IsShort(env))
+        {
+            size_t mask  = ((size_t)1) << i;
+            size_t bits  = (size_t)bs;
+            bool   added = (bits & mask) == 0;
+            bs           = (BitSetShortLongRep)(bits | mask);
+            return added;
+        }
+        else
+        {
+            return TryAddElemDLong(env, bs, i);
+        }
+    }
+
     static bool IsMember(Env env, const BitSetShortLongRep bs, unsigned i)
     {
         assert(i < BitSetTraits::GetSize(env));
@@ -644,6 +662,21 @@ void BitSetOps</*BitSetType*/ BitSetShortLongRep,
     bs[index] |= mask;
 }
 
+template <typename Env, typename BitSetTraits>
+bool BitSetOps</*BitSetType*/ BitSetShortLongRep,
+               /*Brand*/ BSShortLong,
+               /*Env*/ Env,
+               /*BitSetTraits*/ BitSetTraits>::TryAddElemDLong(Env env, BitSetShortLongRep& bs, unsigned i)
+{
+    assert(!IsShort(env));
+    unsigned index = i / BitsInSizeT;
+    size_t   mask  = ((size_t)1) << (i % BitsInSizeT);
+    size_t   bits  = bs[index];
+    bool     added = (bits & mask) == 0;
+    bs[index]      = bits | mask;
+    return added;
+}
+
 template <typename Env, typename BitSetTraits>
 void BitSetOps</*BitSetType*/ BitSetShortLongRep,
                /*Brand*/ BSShortLong,

src/jit/block.h

@@ -1202,9 +1202,15 @@ struct JitPtrKeyFuncs<BasicBlock> : public JitKeyFuncsDefEquals<const BasicBlock
 // A set of blocks.
 typedef JitHashTable<BasicBlock*, JitPtrKeyFuncs<BasicBlock>, bool> BlkSet;
 
+// A vector of blocks.
+typedef jitstd::vector<BasicBlock*> BlkVector;
+
 // A map of block -> set of blocks, can be used as sparse block trees.
 typedef JitHashTable<BasicBlock*, JitPtrKeyFuncs<BasicBlock>, BlkSet*> BlkToBlkSetMap;
 
+// A map of block -> vector of blocks, can be used as sparse block trees.
+typedef JitHashTable<BasicBlock*, JitPtrKeyFuncs<BasicBlock>, BlkVector> BlkToBlkVectorMap;
+
 // Map from Block to Block.  Used for a variety of purposes.
 typedef JitHashTable<BasicBlock*, JitPtrKeyFuncs<BasicBlock>, BasicBlock*> BlockToBlockMap;
 

src/jit/compiler.h

@@ -25,6 +25,8 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 #include "jit.h"
 #include "opcode.h"
 #include "varset.h"
+#include "jitstd.h"
+#include "jithashtable.h"
 #include "gentree.h"
 #include "lir.h"
 #include "block.h"
@@ -33,10 +35,8 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 #include "instr.h"
 #include "regalloc.h"
 #include "sm.h"
-#include "jithashtable.h"
 #include "cycletimer.h"
 #include "blockset.h"
-#include "jitstd.h"
 #include "arraystack.h"
 #include "hashbv.h"
 #include "fp.h"

src/jit/gentree.h

@@ -24,6 +24,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 #include "ssaconfig.h" // For "SsaConfig::RESERVED_SSA_NUM"
 #include "reglist.h"
 #include "valuenumtype.h"
+#include "jitstd.h"
 #include "jithashtable.h"
 #include "nodeinfo.h"
 #include "simd.h"

src/jit/jithashtable.h

@@ -264,13 +264,50 @@ class JitHashTable
         }
         else
         {
-            Node* pNewNode = new (m_alloc) Node(k, v, m_table[index]);
+            Node* pNewNode = new (m_alloc) Node(m_table[index], k, v);
             m_table[index] = pNewNode;
             m_tableCount++;
             return false;
         }
     }
 
+    //------------------------------------------------------------------------
+    // Emplace: Associates the specified key with a value constructed in-place
+    // using the supplied args if the key is not already present.
+    //
+    // Arguments:
+    //    k - the key
+    //    args - the args used to construct the value
+    //
+    // Return Value:
+    //    A pointer to the existing or newly constructed value.
+    //
+    template <class... Args>
+    Value* Emplace(Key k, Args&&... args)
+    {
+        CheckGrowth();
+
+        assert(m_tableSizeInfo.prime != 0);
+
+        unsigned index = GetIndexForKey(k);
+
+        Node* n = m_table[index];
+        while ((n != nullptr) && !KeyFuncs::Equals(k, n->m_key))
+        {
+            n = n->m_next;
+        }
+
+        if (n == nullptr)
+        {
+            n = new (m_alloc) Node(m_table[index], k, jitstd::forward<Args>(args)...);
+
+            m_table[index] = n;
+            m_tableCount++;
+        }
+
+        return &n->m_val;
+    }
+
     //------------------------------------------------------------------------
     // Remove: Remove the specified key and its associated value.
     //
@@ -592,7 +629,7 @@ class JitHashTable
         // Assumptions:
         //    This must not be the "end" iterator.
         //
-        const Value& GetValue() const
+        Value& GetValue() const
         {
             assert(m_node != nullptr);
 
@@ -721,7 +758,8 @@ class JitHashTable
         Key   m_key;
         Value m_val;
 
-        Node(Key k, Value v, Node* next) : m_next(next), m_key(k), m_val(v)
+        template <class... Args>
+        Node(Node* next, Key k, Args&&... args) : m_next(next), m_key(k), m_val(jitstd::forward<Args>(args)...)
         {
         }