Improving compaction heuristics + Some other tweaks while looking at compaction. (#74)

Author: VSadov

src/coreclr/gc/satori/SatoriAllocator.cpp

@@ -104,6 +104,7 @@ class SatoriAllocator
     DECLSPEC_ALIGN(64)
     volatile int32_t m_singePageAdders;
 
+    void UpdateAllocStatsAndHelpIfNeeded(SatoriAllocationContext * context);
     SatoriObject* AllocRegular(SatoriAllocationContext* context, size_t size, uint32_t flags);
     SatoriObject* AllocRegularShared(SatoriAllocationContext* context, size_t size, uint32_t flags);
     SatoriObject* AllocLarge(SatoriAllocationContext* context, size_t size, uint32_t flags);

src/coreclr/gc/satori/SatoriAllocator.h

@@ -104,6 +104,8 @@ void SatoriObject::DirtyCardsForContent()
 void SatoriObject::Validate()
 {
 #ifdef _DEBUG
+    // min object size is the same as min free size because any hole
+    // must be able to fit a free obj for parseability reasons
     _ASSERTE(this->Size() >= Satori::MIN_FREE_SIZE);
 
     if (ContainingRegion()->IsEscapeTrackedByCurrentThread())

src/coreclr/gc/satori/SatoriObject.cpp

@@ -55,6 +55,7 @@ class SatoriObject : public Object
 
     size_t Size();
     size_t FreeObjSize();
+    size_t FreeObjCapacity();
     bool SameRegion(SatoriRegion* otherRegion);
     bool IsFree();
     bool IsExternal();
@@ -111,4 +112,20 @@ class SatoriObject : public Object
     static void Initialize();
 };
 
+
+class SatoriFreeListObject : public SatoriObject
+{
+private:
+    uint32_t       m_Length;
+#if defined(HOST_64BIT)
+    uint32_t       m_uAlignpad;
+#endif // HOST_64BIT
+
+public:
+    SatoriFreeListObject() = delete;
+    ~SatoriFreeListObject() = delete;
+
+    SatoriFreeListObject* m_nextInFreeList;
+};
+
 #endif

src/coreclr/gc/satori/SatoriObject.h

@@ -53,10 +53,16 @@ FORCEINLINE size_t SatoriObject::FreeObjSize()
     _ASSERTE(IsFree());
     size_t size = Satori::MIN_FREE_SIZE;
     size += (size_t)((ArrayBase*)this)->GetNumComponents();
-    size = ALIGN_UP(size, Satori::OBJECT_ALIGNMENT);
+    _ASSERTE(size == ALIGN_UP(size, Satori::OBJECT_ALIGNMENT));
     return size;
 }
 
+FORCEINLINE size_t SatoriObject::FreeObjCapacity()
+{
+    _ASSERTE(IsFree());
+    return (size_t)((ArrayBase*)this)->GetNumComponents();
+}
+
 inline size_t SatoriObject::Start()
 {
     return (size_t)this;

src/coreclr/gc/satori/SatoriObject.inl

@@ -324,6 +324,7 @@ void SatoriPage::WipeGroupsForRange(size_t start, size_t end)
 
     size_t firstGroup = firstByteOffset / Satori::BYTES_PER_CARD_GROUP;
     size_t lastGroup = lastByteOffset / Satori::BYTES_PER_CARD_GROUP;
+    // this resets both states and tickets
     memset((void*)&m_cardGroups[firstGroup * 2], Satori::CardState::BLANK, (lastGroup - firstGroup + 1) * 2);
 }
 

src/coreclr/gc/satori/SatoriPage.cpp

@@ -121,9 +121,9 @@ class SatoriPage
     void ResetCardsForRange(size_t start, size_t end, bool isTenured);
 
     volatile int8_t& CardState();
-    volatile int8_t& ScanTicket();
+    volatile uint8_t& ScanTicket();
     volatile int8_t& CardGroupState(size_t i);
-    volatile int8_t& CardGroupScanTicket(size_t i);
+    volatile uint8_t& CardGroupScanTicket(size_t i);
 
     size_t CardGroupCount();
     int8_t* CardsForGroup(size_t i);
@@ -148,7 +148,7 @@ class SatoriPage
         struct
         {
             int8_t m_cardState;
-            int8_t m_scanTicket;
+            uint8_t m_scanTicket;
             size_t m_end;
             size_t m_initialCommit;
             size_t m_firstRegion;
@@ -170,6 +170,8 @@ class SatoriPage
 
             // computed size,
             // 2 byte per card group (4 per region granule)
+            //   one signed byte for a state, which has negative values.
+            //   and one unsigned for a ticket, which is a wrap-around counter.
             // 2048 bytes per 1Gb
             DECLSPEC_ALIGN(128)
             int8_t m_cardGroups[1];

src/coreclr/gc/satori/SatoriPage.h

@@ -63,7 +63,7 @@ inline volatile int8_t& SatoriPage::CardState()
 }
 
 // order is unimportant, but we want to read it only once when we read it, thus volatile.
-inline volatile int8_t& SatoriPage::ScanTicket()
+inline volatile uint8_t& SatoriPage::ScanTicket()
 {
     return m_scanTicket;
 }
@@ -75,9 +75,9 @@ inline volatile int8_t& SatoriPage::CardGroupState(size_t i)
 }
 
 // order is unimportant, but we want to read it once when we read it, thus volatile.
-inline volatile int8_t& SatoriPage::CardGroupScanTicket(size_t i)
+inline volatile uint8_t& SatoriPage::CardGroupScanTicket(size_t i)
 {
-    return m_cardGroups[i * 2 + 1];
+    return (uint8_t&)m_cardGroups[i * 2 + 1];
 }
 
 inline size_t SatoriPage::CardGroupCount()

src/coreclr/gc/satori/SatoriPage.inl

@@ -153,6 +153,50 @@ class SatoriQueue
         return result;
     }
 
+    // same as TryPop, but on empty pushes the item.
+    // emptines is checked under a lock.
+    T* PopOrPush(T* item)
+    {
+        _ASSERTE(item->m_next == nullptr);
+        _ASSERTE(item->m_prev == nullptr);
+        _ASSERTE(item->m_containingQueue == nullptr);
+
+        T* result;
+        {
+            SatoriLockHolder holder(&m_lock);
+            result = m_head;
+            if (result == nullptr)
+            {
+                // push the item and return nullptr.
+                _ASSERTE(m_tail == nullptr);
+                m_count++;
+                item->m_containingQueue = this;
+                m_tail = item;
+                m_head = item;
+                return nullptr;
+            }
+
+            // pop the result
+            T* next = result->m_next;
+            m_count--;
+            m_head = next;
+            result->m_containingQueue = nullptr;
+            if (next == nullptr)
+            {
+                m_tail = nullptr;
+            }
+            else
+            {
+                next->m_prev = nullptr;
+            }
+        }
+
+        _ASSERTE(result->m_prev == nullptr);
+        result->m_next = nullptr;
+
+        return result;
+    }
+
     T* TryPopWithTryEnter()
     {
         if (IsEmpty())