swb: annotate BaseDictionary (partial)

Expand `Pointer/PointerNoBarrier/WriteBarrierPtr/NoWriteBarrierPtr`
to template on `Allocator`. By default they use Recycler and behave the
same as before. When used with Arena or other custom allocators,
`Pointer/WriteBarrierPtr` will not trigger write barrier (and also allow
`operator&` for minimum impact on existing code).

Added `WriteBarrier` functions to trigger or ignore write barrier
appropriately.

Added `SetArray` function to assign array data to a field. When used with
Recycler and the element type needs write barrier, it triggers write
barrier on the array content.

This change does not handle individual `Item` write barrier yet.

Author: Jianchun Xu

lib/Common/DataStructures/BaseDictionary.h

@@ -90,9 +90,9 @@ namespace JsUtil
         friend class Js::RemoteDictionary<BaseDictionary>;
         template <typename ValueOrKey> struct ComparerType { typedef Comparer<ValueOrKey> Type; }; // Used by diagnostics to access Comparer type
 
-        int* buckets;
-        EntryType* entries;
-        AllocatorType* alloc;
+        Pointer(int, TAllocator) buckets;
+        Pointer(EntryType, TAllocator) entries;
+        PointerNoBarrier(AllocatorType) alloc;
         int size;
         uint bucketCount;
         int count;
@@ -860,9 +860,14 @@ namespace JsUtil
             int initSize = max(capacity, 4);
             uint initBucketCount = SizePolicy::GetBucketSize(initSize);
             AssertMsg(initBucketCount > 0, "Size returned by policy should be greater than 0");
-            Allocate(&buckets, &entries, initBucketCount, initSize);
 
-            // Allocation can throw - assign the size only after allocation has succeeded.
+            int* newBuckets = nullptr;
+            EntryType* newEntries = nullptr;
+            Allocate(&newBuckets, &newEntries, initBucketCount, initSize);
+
+            // Allocation can throw - assign only after allocation has succeeded.
+            SetArray<TAllocator>(this->buckets, newBuckets, initBucketCount);
+            SetArray<TAllocator, EntryType, ValueType>(this->entries, newEntries, initSize);
             this->bucketCount = initBucketCount;
             this->size = initSize;
             Assert(this->freeCount == 0);
@@ -1037,10 +1042,10 @@ namespace JsUtil
             if (stats)
                 stats->Resize(newSize, /*emptyBuckets=*/ newSize - size);
 #endif
-            buckets = newBuckets;
+            SetArray<TAllocator>(this->buckets, newBuckets, newBucketCount);
+            SetArray<TAllocator, EntryType, ValueType>(this->entries, newEntries, newSize);
             bucketCount = newBucketCount;
             size = newSize;
-            entries = newEntries;
         }
 
         __ecount(bucketCount) int *AllocateBuckets(DECLSPEC_GUARD_OVERFLOW const uint bucketCount)

lib/Common/Exceptions/Throw.cpp

@@ -37,6 +37,7 @@ namespace Memory {
 using namespace Memory;
 #include "Memory/Allocator.h"
 #include "Memory/HeapAllocator.h"
+#include "Memory/RecyclerPointers.h"
 
 // Data structure
 #include "DataStructures/Comparer.h"

lib/Common/Memory/Allocator.h

@@ -27,9 +27,10 @@ enum PageHeapMode
 
 namespace Memory
 {
-
-    template<typename> class WriteBarrierPtr;
-    template<typename> class NoWriteBarrierPtr;
+    class Recycler;
+    class RecyclerNonLeafAllocator;
+    template<typename, class Allocator=Recycler> class WriteBarrierPtr;
+    template<typename, class Allocator=Recycler> class NoWriteBarrierPtr;
 
 #ifdef TRACK_ALLOC
 struct TrackAllocData

lib/Common/Memory/RecyclerPointers.h

@@ -6,6 +6,142 @@
 
 namespace Memory
 {
+// Dummy tag classes to mark yes/no write barrier policy
+struct _write_barrier_policy {};
+struct _no_write_barrier_policy {};
+
+// Type write barrier policy
+//
+// By default following potentially contains GC pointers and use write barrier policy:
+//      pointer, WriteBarrierPtr, _write_barrier_policy
+//
+template <class T>
+struct TypeWriteBarrierPolicy { typedef _no_write_barrier_policy Policy; };
+template <class T>
+struct TypeWriteBarrierPolicy<T*> { typedef _write_barrier_policy Policy; };
+template <class T>
+struct TypeWriteBarrierPolicy<WriteBarrierPtr<T>> { typedef _write_barrier_policy Policy; };
+template <>
+struct TypeWriteBarrierPolicy<_write_barrier_policy> { typedef _write_barrier_policy Policy; };
+
+// Combine AllocatorType and data type write barrier policy
+// Recycler allocator type + _write_barrier_policy data type => _write_barrier_policy
+//
+template <class AllocatorType, class TPolicy>
+struct AllocatorTypeWriteBarrierPolicy { typedef _no_write_barrier_policy Policy; };
+template <>
+struct AllocatorTypeWriteBarrierPolicy<Recycler, _write_barrier_policy>
+{
+    typedef _write_barrier_policy Policy;
+};
+
+// Combine Allocator + Data write barrier policy
+// RecyclerNonLeafAllocator, * => _write_barrier_policy
+//
+template <class Allocator, class T>
+struct AllocatorWriteBarrierPolicy
+{
+    typedef typename AllocatorInfo<Allocator, void>::AllocatorType AllocatorType;
+    typedef typename TypeWriteBarrierPolicy<T>::Policy TPolicy;
+    typedef typename AllocatorTypeWriteBarrierPolicy<AllocatorType, TPolicy>::Policy Policy;
+};
+template <class T>
+struct AllocatorWriteBarrierPolicy<RecyclerNonLeafAllocator, T>
+{
+    typedef _write_barrier_policy Policy;
+};
+
+// Actual WriteBarrierPolicy behavior
+//
+template <class Policy>
+struct WriteBarrierPolicy
+{
+    template <class Allocator, class T>
+    static void WriteBarrier(WriteBarrierPtr<T, Allocator> * address) {}
+
+    template <class T>
+    static void WriteBarrier(T * address, size_t count) {}
+};
+
+#ifdef RECYCLER_WRITE_BARRIER
+template <>
+struct WriteBarrierPolicy<_write_barrier_policy>
+{
+    template <class Allocator, class T>
+    static void WriteBarrier(WriteBarrierPtr<T, Allocator> * address)
+    {
+        RecyclerWriteBarrierManager::WriteBarrier(address);
+    }
+
+    template <class T>
+    static void WriteBarrier(T * address, size_t count)
+    {
+        RecyclerWriteBarrierManager::WriteBarrier(address, sizeof(T) * count);
+    }
+};
+#endif
+
+// Check if "operator&" is allowed on given WriteBarrierPtr type at compile time.
+// Not allowed on WriteBarrierPtr<T, RecyclerFamilyAllocator>.
+//
+template <class Policy>
+void CheckAddressOperator()
+{
+    static_assert(false, "Might need to set barrier for this operation, and use AddressOf instead.");
+}
+template <>
+inline void CheckAddressOperator<_no_write_barrier_policy>()
+{
+}
+template <class Allocator, class T, class PolicyType = WriteBarrierPtr<T, Allocator>>
+void CheckAddressOperator(WriteBarrierPtr<T, Allocator> * p)
+{
+    typedef typename AllocatorWriteBarrierPolicy<Allocator, PolicyType>::Policy Policy;
+    CheckAddressOperator<Policy>();
+}
+
+// Trigger write barrier on changing a WriteBarrierPtr if Allocator type is one of
+// recycler allocators. Ignore otherwise.
+//
+template <class Allocator, class T, class PolicyType = WriteBarrierPtr<T, Allocator>>
+void WriteBarrier(WriteBarrierPtr<T, Allocator> * address)
+{
+    typedef typename AllocatorWriteBarrierPolicy<Allocator, PolicyType>::Policy Policy;
+    return WriteBarrierPolicy<Policy>::WriteBarrier(address);
+}
+
+// Trigger write barrier on changing array content if Allocator and element type
+// determines write barrier is needed. Ignore otherwise.
+//
+template <class Allocator, class T, class PolicyType = T>
+void WriteBarrier(T * address, size_t count)
+{
+    typedef typename AllocatorWriteBarrierPolicy<Allocator, PolicyType>::Policy Policy;
+    return WriteBarrierPolicy<Policy>::WriteBarrier(address, count);
+}
+
+// Set an array field (naked pointer or NoWriteBarrierPtr) to an allocated array.
+// Used when the field does not use write barrier. Will not trigger write barrier
+// on the array content.
+//
+template <class Allocator, class T, class PolicyType = T>
+void SetArray(T*& dst, T* src, size_t srcCount)
+{
+    dst = src;
+}
+
+// Set an array field (WriteBarrierPtr) to an allocated array.
+// Used when the field uses write barrier. Will trigger write barrier on the array
+// content if Allocator and element type determines write barrier is needed.
+//
+template <class Allocator, class T, class PolicyType = T>
+void SetArray(WriteBarrierPtr<T, Allocator>& dst, T* src, size_t srcCount)
+{
+    dst = src;
+    WriteBarrier<Allocator, T, PolicyType>(dst, srcCount);
+}
+
+
 template <typename T>
 class NoWriteBarrierField
 {
@@ -31,7 +167,7 @@ class NoWriteBarrierField
     T value;
 };
 
-template <typename T>
+template <typename T, class Allocator>
 class NoWriteBarrierPtr
 {
 public:
@@ -80,7 +216,7 @@ class WriteBarrierObjectConstructorTrigger
     Recycler* recycler;
 };
 
-template <typename T>
+template <typename T, class Allocator>
 class WriteBarrierPtr
 {
 public:
@@ -100,12 +236,12 @@ class WriteBarrierPtr
 
     T const** operator&() const
     {
-        static_assert(false, "Might need to set barrier for this operation, and use AddressOf instead.");
+        CheckAddressOperator(this);
         return &ptr;
     }
     T** operator&()
     {
-        static_assert(false, "Might need to set barrier for this operation, and use AddressOf instead.");
+        CheckAddressOperator(this);
         return &ptr;
     }
 
@@ -122,9 +258,7 @@ class WriteBarrierPtr
     void WriteBarrierSet(T * ptr)
     {
         NoWriteBarrierSet(ptr);
-#ifdef RECYCLER_WRITE_BARRIER
-        RecyclerWriteBarrierManager::WriteBarrier(this);
-#endif
+        WriteBarrier(this);
     }
 
     WriteBarrierPtr& operator=(WriteBarrierPtr const& other)
@@ -136,23 +270,17 @@ class WriteBarrierPtr
     static void MoveArray(WriteBarrierPtr * dst, WriteBarrierPtr * src, size_t count)
     {
         memmove((void *)dst, src, sizeof(WriteBarrierPtr) * count);
-#ifdef RECYCLER_WRITE_BARRIER
-        RecyclerWriteBarrierManager::WriteBarrier(dst, count);
-#endif
+        WriteBarrier<Allocator>(dst, count);
     }
     static void CopyArray(WriteBarrierPtr * dst, size_t dstCount, T const* src, size_t srcCount)
     {
         js_memcpy_s((void *)dst, sizeof(WriteBarrierPtr) * dstCount, src, sizeof(T *) * srcCount);
-#ifdef RECYCLER_WRITE_BARRIER
-        RecyclerWriteBarrierManager::WriteBarrier(dst, dstCount);
-#endif
+        WriteBarrier<Allocator>(dst, dstCount);
     }
     static void CopyArray(WriteBarrierPtr * dst, size_t dstCount, WriteBarrierPtr const* src, size_t srcCount)
     {
         js_memcpy_s((void *)dst, sizeof(WriteBarrierPtr) * dstCount, src, sizeof(WriteBarrierPtr) * srcCount);
-#ifdef RECYCLER_WRITE_BARRIER
-        RecyclerWriteBarrierManager::WriteBarrier(dst, dstCount);
-#endif
+        WriteBarrier<Allocator>(dst, dstCount);
     }
     static void ClearArray(WriteBarrierPtr * dst, size_t count)
     {
@@ -162,7 +290,7 @@ class WriteBarrierPtr
 private:
     T * ptr;
 };
-}
+}  // namespace Memory
 
 
 template<class T> inline

lib/Common/Memory/RecyclerWriteBarrierManager.cpp

@@ -57,7 +57,7 @@ X64WriteBarrierCardTableManager::OnThreadInit()
     ULONG_PTR stackEnd = 0;
     ::GetCurrentThreadStackLimits(&stackEnd, &stackBase);
 #endif
-    
+
     size_t numPages = (stackBase - stackEnd) / AutoSystemInfo::PageSize;
     // stackEnd is the lower boundary
     return OnSegmentAlloc((char*) stackEnd, numPages);
@@ -283,11 +283,11 @@ RecyclerWriteBarrierManager::WriteBarrier(void * address)
 
 
 void
-RecyclerWriteBarrierManager::WriteBarrier(void * address, size_t ptrCount)
+RecyclerWriteBarrierManager::WriteBarrier(void * address, size_t bytes)
 {
 #ifdef RECYCLER_WRITE_BARRIER_BYTE
     uintptr_t startIndex = GetCardTableIndex(address);
-    char * endAddress = (char *)Math::Align<INT_PTR>((INT_PTR)((char *)address + sizeof(void *) * ptrCount), s_WriteBarrierPageSize);
+    char * endAddress = (char *)Math::Align<INT_PTR>((INT_PTR)((char *)address + bytes), s_WriteBarrierPageSize);
     uintptr_t endIndex = GetCardTableIndex(endAddress);
     Assert(startIndex <= endIndex);
     memset(cardTable + startIndex, 1, endIndex - startIndex);
@@ -297,7 +297,7 @@ RecyclerWriteBarrierManager::WriteBarrier(void * address, size_t ptrCount)
     uint bitMask = 0xFFFFFFFF << bitShift;
     uint cardIndex = ((uint)address) / s_BytesPerCard);
 
-    char * endAddress = (char *)Math::Align((INT_PTR)((char *)address + sizeof(void *) * ptrCount), s_BytesPerCardBit);
+    char * endAddress = (char *)Math::Align((INT_PTR)((char *)address + bytes), s_BytesPerCardBit);
     char * alignedAddress = (char *)Math::Align((INT_PTR)address, s_WriteBarrierPageSize);
     if (alignedAddress > endAddress)
     {

lib/Common/Memory/RecyclerWriteBarrierManager.h

@@ -123,7 +123,7 @@ class RecyclerWriteBarrierManager
 {
 public:
     static void WriteBarrier(void * address);
-    static void WriteBarrier(void * address, size_t ptrCount);
+    static void WriteBarrier(void * address, size_t bytes);
 
     // For JIT
     static uintptr_t GetCardTableIndex(void * address);

lib/Common/Memory/WriteBarrierMacros.h

@@ -12,7 +12,7 @@
 // Usage:
 //   In general, don't need to use anything, just use the macros to annotate your fields
 //
-//   If you want to force your fields to always generate the right write-barrier types, 
+//   If you want to force your fields to always generate the right write-barrier types,
 //   at the start of the file, add the following:
 //     #define FORCE_USE_WRITE_BARRIER
 //     #include <Memory/WriteBarrierMacros.h>
@@ -27,34 +27,34 @@
 #define PushMacro(x) __pragma(push_macro( #x ))
 
 #define SAVE_WRITE_BARRIER_MACROS() \
-    PushMacro("PointerNoBarrier") \
     PushMacro("Field") \
+    PushMacro("PointerNoBarrier") \
     PushMacro("Pointer")
 
 #define RESTORE_WRITE_BARRIER_MACROS() \
-    PopMacro("PointerNoBarrier") \
     PopMacro("Field") \
+    PopMacro("PointerNoBarrier") \
     PopMacro("Pointer")
 
 #endif
 
 #ifdef FORCE_USE_WRITE_BARRIER
 SAVE_WRITE_BARRIER_MACROS()
-#undef PointerNoBarrier
 #undef Field
+#undef PointerNoBarrier
 #undef Pointer
 #endif
 
 // TODO: Turn off these annotations on Win32
 #if defined(__clang__) || defined(FORCE_USE_WRITE_BARRIER)
 // Various macros for defining field attributes
-#define PointerNoBarrier(type) NoWriteBarrierPtr<type>
 #define Field(type) NoWriteBarrierField<type>
-#define Pointer(type) WriteBarrierPtr<type>
+#define PointerNoBarrier(type, ...) NoWriteBarrierPtr<type, ##__VA_ARGS__>
+#define Pointer(type, ...) WriteBarrierPtr<type, ##__VA_ARGS__>
 #else
-#define PointerNoBarrier(type) type*
 #define Field(type) type
-#define Pointer(type) type*
+#define PointerNoBarrier(type) type*
+#define Pointer(type, ...) type*
 #endif
 
 #undef FORCE_USE_WRITE_BARRIER

lib/Runtime/Base/ScriptContext.cpp

@@ -4721,8 +4721,9 @@ void ScriptContext::RegisterPrototypeChainEnsuredToHaveOnlyWritableDataPropertie
     }
 
 #if ENABLE_PROFILE_INFO
-    template<template<typename> class BarrierT>
-    void ScriptContext::AddDynamicProfileInfo(FunctionBody * functionBody, BarrierT<DynamicProfileInfo>& dynamicProfileInfo)
+    template<template<typename, class> class BarrierT>
+    void ScriptContext::AddDynamicProfileInfo(
+        FunctionBody * functionBody, BarrierT<DynamicProfileInfo, Recycler>& dynamicProfileInfo)
     {
         Assert(functionBody->GetScriptContext() == this);
         Assert(functionBody->HasValidSourceInfo());
@@ -4777,7 +4778,6 @@ void ScriptContext::RegisterPrototypeChainEnsuredToHaveOnlyWritableDataPropertie
         Assert(dynamicProfileInfo != nullptr);
     }
     template void  ScriptContext::AddDynamicProfileInfo<WriteBarrierPtr>(FunctionBody *, WriteBarrierPtr<DynamicProfileInfo>&);
-    template void  ScriptContext::AddDynamicProfileInfo<NoWriteBarrierPtr>(FunctionBody *, NoWriteBarrierPtr<DynamicProfileInfo>&);
 #endif
 
     CharClassifier const * ScriptContext::GetCharClassifier(void) const