Make AffixAllocator take into account RCISharedAllocator

Author: edi33416

std/experimental/allocator/building_blocks/affix_allocator.d

@@ -18,13 +18,15 @@ Suffixes are slower to get at because of alignment rounding, so prefixes should
 be preferred. However, small prefixes blunt the alignment so if a large
 alignment with a small affix is needed, suffixes should be chosen.
 
-The following methods are defined if $(D Allocator) defines them, and forward to it: $(D deallocateAll), $(D empty), $(D owns).
+The following methods are defined if $(D Allocator) defines them,
+and forwards to it: $(D deallocateAll), $(D empty), $(D owns).
  */
 struct AffixAllocator(Allocator, Prefix, Suffix = void)
 {
     import std.algorithm.comparison : min;
     import std.conv : emplace;
-    import std.experimental.allocator : RCIAllocator, theAllocator;
+    import std.experimental.allocator : RCIAllocator, RCISharedAllocator,
+           theAllocator, processAllocator;
     import std.experimental.allocator.common : stateSize, forwardToMember,
         roundUpToMultipleOf, alignedAt, alignDownTo, roundUpToMultipleOf,
         hasStaticallyKnownAlignment;
@@ -43,7 +45,8 @@ struct AffixAllocator(Allocator, Prefix, Suffix = void)
         "This restriction could be relaxed in the future.");
 
     /**
-    If $(D Prefix) is $(D void), the alignment is that of the parent. Otherwise, the alignment is the same as the $(D Prefix)'s alignment.
+    If $(D Prefix) is $(D void), the alignment is that of the parent.
+    Otherwise, the alignment is the same as the $(D Prefix)'s alignment.
     */
     static if (hasStaticallyKnownAlignment!Allocator)
     {
@@ -60,36 +63,39 @@ struct AffixAllocator(Allocator, Prefix, Suffix = void)
         enum uint alignment = Prefix.alignof;
     }
 
-    /**
-    If the parent allocator $(D Allocator) is stateful, an instance of it is
-    stored as a member. Otherwise, $(D AffixAllocator) uses
-    `Allocator.instance`. In either case, the name $(D _parent) is uniformly
-    used for accessing the parent allocator.
-    */
-    static if (stateSize!Allocator)
+    private template Impl()
     {
-        Allocator _parent;
-        static if (is(Allocator == RCIAllocator))
+        static if (stateSize!Allocator)
         {
-            Allocator parent()
+            Allocator _parent;
+            static if (is(Allocator == RCIAllocator) || is(Allocator == RCISharedAllocator))
             {
-                if (_parent.isNull) _parent = theAllocator;
-                assert(alignment <= _parent.alignment);
-                return _parent;
+                Allocator parent()
+                {
+                    if (_parent.isNull)
+                    {
+                        static if (is(Allocator == RCIAllocator))
+                        {
+                            _parent = theAllocator;
+                        }
+                        else
+                        {
+                            _parent = processAllocator;
+                        }
+                    }
+                    assert(alignment <= _parent.alignment);
+                    return _parent;
+                }
+            }
+            else
+            {
+                alias parent = _parent;
             }
         }
         else
         {
-            alias parent = _parent;
+            alias parent = Allocator.instance;
         }
-    }
-    else
-    {
-        alias parent = Allocator.instance;
-    }
-
-    private template Impl()
-    {
 
         size_t goodAllocSize(size_t s)
         {
@@ -298,6 +304,20 @@ struct AffixAllocator(Allocator, Prefix, Suffix = void)
         */
         static AffixAllocator instance;
 
+        /**
+        If the parent allocator `Allocator` is stateful, an instance of it is
+        stored as a member. If the parent allocator is null instance of
+        $(REF RCIAllocator, std,experimental,allocator) or
+        $(REF RCISharedAllocator, std,experimental,allocator) then `AffixAllocator`
+        will use $(REF theAllocator, std,experimental,allocator) or
+        $(REF processAllocator, std,experimental,allocator) respectively.
+        If the parent allocator `Allocator` is stateless, `AffixAllocator` uses
+        `Allocator.instance`.
+        In either case, the name `_parent` is uniformly used for accessing the
+        parent allocator.
+        */
+        Allocator parent();
+
         /**
         Affix access functions offering references to the affixes of a
         block `b` previously allocated with this allocator. `b` may not be null.
@@ -520,3 +540,30 @@ struct AffixAllocator(Allocator, Prefix, Suffix = void)
     static assert(is(typeof(a.allocate) == shared));
     assert(buf.length == 10);
 }
+
+@system unittest
+{
+    import std.experimental.allocator : RCISharedAllocator;
+
+    shared AffixAllocator!(RCISharedAllocator, uint) a;
+    auto buf = a.allocate(42);
+    assert(buf.length == 42);
+}
+
+@system unittest
+{
+    import std.experimental.allocator.mallocator : Mallocator;
+    import std.experimental.allocator.building_blocks.stats_collector;
+
+    alias SCAlloc = StatsCollector!(Mallocator, Options.bytesUsed);
+    alias AffixAl = AffixAllocator!(SCAlloc, uint);
+
+    AffixAl a;
+    auto b = a.allocate(42);
+    assert(b.length == 42);
+    assert(a.parent.bytesUsed == 42 + uint.sizeof);
+    assert((() nothrow @nogc => a.reallocate(b, 100))());
+    assert(b.length == 100);
+    assert(a.parent.bytesUsed == 100 + uint.sizeof);
+    assert((() nothrow @nogc => a.deallocate(b))());
+}