Remove almost all blockmeta/cache functionality from rt, using the GC

API instead.

Author: schveiguy

druntime/src/core/internal/array/construction.d

@@ -349,7 +349,7 @@ T[] _d_newarrayU(T)(size_t length, bool isShared=false) @trusted
 {
     import core.exception : onOutOfMemoryError;
     import core.internal.traits : Unqual;
-    import core.internal.array.utils : __arrayStart, __setArrayAllocLength, __arrayAlloc;
+    import core.internal.array.utils : __arrayAlloc;
 
     alias UnqT = Unqual!T;
 
@@ -395,16 +395,11 @@ Loverflow:
     assert(0);
 
 Lcontinue:
-    auto info = __arrayAlloc!UnqT(arraySize);
-    if (!info.base)
+    auto arr = __arrayAlloc!UnqT(arraySize);
+    if (!arr.ptr)
         goto Loverflow;
-    debug(PRINTF) printf("p = %p\n", info.base);
-
-    auto arrstart = __arrayStart(info);
-
-    __setArrayAllocLength!UnqT(info, arraySize, isShared);
-
-    return (cast(T*) arrstart)[0 .. length];
+    debug(PRINTF) printf("p = %p\n", arr.ptr);
+    return (cast(T*) arr.ptr)[0 .. length];
 }
 
 /// ditto
@@ -522,7 +517,7 @@ Tarr _d_newarraymTX(Tarr : U[], T, U)(size_t[] dims, bool isShared=false) @trust
 
     void[] __allocateInnerArray(size_t[] dims)
     {
-        import core.internal.array.utils : __arrayStart, __setArrayAllocLength, __arrayAlloc;
+        import core.internal.array.utils : __arrayAlloc;
 
         auto dim = dims[0];
 
@@ -535,15 +530,13 @@ Tarr _d_newarraymTX(Tarr : U[], T, U)(size_t[] dims, bool isShared=false) @trust
 
         auto allocSize = (void[]).sizeof * dim;
         // the array-of-arrays holds pointers! Don't use UnqT here!
-        auto info = __arrayAlloc!(void[])(allocSize);
-        __setArrayAllocLength!(void[])(info, allocSize, isShared);
-        auto p = __arrayStart(info)[0 .. dim];
+        auto arr = __arrayAlloc!(void[])(allocSize);
 
         foreach (i; 0..dim)
         {
-            (cast(void[]*)p.ptr)[i] = __allocateInnerArray(dims[1..$]);
+            (cast(void[]*)arr.ptr)[i] = __allocateInnerArray(dims[1..$]);
         }
-        return p;
+        return arr;
     }
 
     auto result = __allocateInnerArray(dims);

druntime/src/core/internal/array/utils.d

@@ -12,24 +12,8 @@ module core.internal.array.utils;
 import core.internal.traits : Parameters;
 import core.memory : GC;
 
-alias BlkInfo = GC.BlkInfo;
 alias BlkAttr = GC.BlkAttr;
 
-private
-{
-    enum : size_t
-    {
-        PAGESIZE = 4096,
-        BIGLENGTHMASK = ~(PAGESIZE - 1),
-        SMALLPAD = 1,
-        MEDPAD = ushort.sizeof,
-        LARGEPREFIX = 16, // 16 bytes padding at the front of the array
-        LARGEPAD = LARGEPREFIX + 1,
-        MAXSMALLSIZE = 256-SMALLPAD,
-        MAXMEDSIZE = (PAGESIZE / 2) - MEDPAD
-    }
-}
-
 auto gcStatsPure() nothrow pure
 {
     import core.memory : GC;
@@ -156,55 +140,21 @@ template isPostblitNoThrow(T) {
 }
 
 /**
- * Clear padding that might not be zeroed by the GC (it assumes it is within the
- * requested size from the start, but it is actually at the end of the allocated
- * block).
- *
- * Params:
- *  info = array allocation data
- *  arrSize = size of the array in bytes
- *  padSize = size of the padding in bytes
- */
-void __arrayClearPad()(ref BlkInfo info, size_t arrSize, size_t padSize) nothrow pure
-{
-    import core.stdc.string;
-    if (padSize > MEDPAD && !(info.attr & BlkAttr.NO_SCAN) && info.base)
-    {
-        if (info.size < PAGESIZE)
-            memset(info.base + arrSize, 0, padSize);
-        else
-            memset(info.base, 0, LARGEPREFIX);
-    }
-}
-
-/**
- * Allocate an array memory block by applying the proper padding and assigning
- * block attributes if not inherited from the existing block.
+ * Allocate a memory block with appendable capabilities for array usage.
  *
  * Params:
  *  arrSize = size of the allocated array in bytes
  * Returns:
- *  `BlkInfo` with allocation metadata
+ *  `void[]` matching requested size on success, `null` on failure.
  */
-BlkInfo __arrayAlloc(T)(size_t arrSize) @trusted
+void[] __arrayAlloc(T)(size_t arrSize) @trusted
 {
-    import core.checkedint;
     import core.lifetime : TypeInfoSize;
     import core.internal.traits : hasIndirections;
 
     enum typeInfoSize = TypeInfoSize!T;
     BlkAttr attr = BlkAttr.APPENDABLE;
 
-    size_t padSize = arrSize > MAXMEDSIZE ?
-        LARGEPAD :
-        ((arrSize > MAXSMALLSIZE ? MEDPAD : SMALLPAD) + typeInfoSize);
-
-    bool overflow;
-    auto paddedSize = addu(arrSize, padSize, overflow);
-
-    if (overflow)
-        return BlkInfo();
-
     /* `extern(C++)` classes don't have a classinfo pointer in their vtable,
      * so the GC can't finalize them.
      */
@@ -213,59 +163,8 @@ BlkInfo __arrayAlloc(T)(size_t arrSize) @trusted
     static if (!hasIndirections!T)
         attr |= BlkAttr.NO_SCAN;
 
-    auto bi = GC.qalloc(paddedSize, attr, typeid(T));
-    __arrayClearPad(bi, arrSize, padSize);
-    return bi;
-}
-
-/**
- * Get the start of the array for the given block.
- *
- * Params:
- *  info = array metadata
- * Returns:
- *  pointer to the start of the array
- */
-void *__arrayStart()(return scope BlkInfo info) nothrow pure
-{
-    return info.base + ((info.size & BIGLENGTHMASK) ? LARGEPREFIX : 0);
-}
-
-/**
- * Set the allocated length of the array block.  This is called when an array
- * is appended to or its length is set.
- *
- * The allocated block looks like this for blocks < PAGESIZE:
- * `|elem0|elem1|elem2|...|elemN-1|emptyspace|N*elemsize|`
- *
- * The size of the allocated length at the end depends on the block size:
- *      a block of 16 to 256 bytes has an 8-bit length.
- *      a block with 512 to pagesize/2 bytes has a 16-bit length.
- *
- * For blocks >= pagesize, the length is a size_t and is at the beginning of the
- * block.  The reason we have to do this is because the block can extend into
- * more pages, so we cannot trust the block length if it sits at the end of the
- * block, because it might have just been extended.  If we can prove in the
- * future that the block is unshared, we may be able to change this, but I'm not
- * sure it's important.
- *
- * In order to do put the length at the front, we have to provide 16 bytes
- * buffer space in case the block has to be aligned properly.  In x86, certain
- * SSE instructions will only work if the data is 16-byte aligned.  In addition,
- * we need the sentinel byte to prevent accidental pointers to the next block.
- * Because of the extra overhead, we only do this for page size and above, where
- * the overhead is minimal compared to the block size.
- *
- * So for those blocks, it looks like:
- * `|N*elemsize|padding|elem0|elem1|...|elemN-1|emptyspace|sentinelbyte|``
- *
- * where `elem0` starts 16 bytes after the first byte.
- */
-bool __setArrayAllocLength(T)(ref BlkInfo info, size_t newLength, bool isShared, size_t oldLength = ~0)
-{
-    import core.lifetime : TypeInfoSize;
-    import core.internal.gc.blockmeta : __setArrayAllocLengthImpl, __setBlockFinalizerInfo;
-    static if (TypeInfoSize!T)
-        __setBlockFinalizerInfo(info, typeid(T));
-    return __setArrayAllocLengthImpl(info, newLength, isShared, oldLength, TypeInfoSize!T);
+    auto ptr = GC.malloc(arrSize, attr, typeid(T));
+    if (ptr)
+        return ptr[0 .. arrSize];
+    return null;
 }

druntime/src/core/internal/gc/blockmeta.d

@@ -69,12 +69,11 @@ size_t structTypeInfoSize(const TypeInfo ti) pure nothrow @nogc
 
   where elem0 starts 16 bytes after the first byte.
   */
-bool __setArrayAllocLength(ref BlkInfo info, size_t newlength, bool isshared, const TypeInfo tinext, size_t oldlength = ~0) pure nothrow
+bool __setArrayAllocLength(ref BlkInfo info, size_t newlength, bool isshared, const TypeInfo tinext, size_t oldlength = size_t.max) pure nothrow
 {
-    size_t typeInfoSize = (info.attr & BlkAttr.STRUCTFINAL) ? size_t.sizeof : 0;
-    if (typeInfoSize)
-        __setBlockFinalizerInfo(info, tinext);
+    __setBlockFinalizerInfo(info, tinext);
 
+    size_t typeInfoSize = (info.attr & BlkAttr.STRUCTFINAL) ? size_t.sizeof : 0;
     return __setArrayAllocLengthImpl(info, newlength, isshared, oldlength, typeInfoSize);
 }
 
@@ -97,7 +96,7 @@ bool __setArrayAllocLengthImpl(ref BlkInfo info, size_t newlength, bool isshared
             return false;
 
         auto length = cast(ubyte *)(info.base + info.size - typeInfoSize - SMALLPAD);
-        if (oldlength != ~0)
+        if (oldlength != size_t.max)
         {
             if (isshared)
             {
@@ -123,7 +122,7 @@ bool __setArrayAllocLengthImpl(ref BlkInfo info, size_t newlength, bool isshared
             // new size does not fit inside block
             return false;
         auto length = cast(ushort *)(info.base + info.size - typeInfoSize - MEDPAD);
-        if (oldlength != ~0)
+        if (oldlength != size_t.max)
         {
             if (isshared)
             {
@@ -149,7 +148,7 @@ bool __setArrayAllocLengthImpl(ref BlkInfo info, size_t newlength, bool isshared
             // new size does not fit inside block
             return false;
         auto length = cast(size_t *)(info.base);
-        if (oldlength != ~0)
+        if (oldlength != size_t.max)
         {
             if (isshared)
             {
@@ -176,24 +175,44 @@ bool __setArrayAllocLengthImpl(ref BlkInfo info, size_t newlength, bool isshared
   The block finalizer info is set separately from the array length, as that is
   only needed on the initial setup of the block. No shared is needed, since
   this should only happen when the block is new.
+  If the STRUCTFINAL bit is not set, no finalizer is stored (but if needed the
+  slot is zeroed)
   */
 void __setBlockFinalizerInfo(ref BlkInfo info, const TypeInfo ti) pure nothrow
 {
     if ((info.attr & BlkAttr.APPENDABLE) && info.size >= PAGESIZE)
     {
+        // if the structfinal bit is not set, we don't have a finalizer. But we
+        // should still zero out the finalizer slot.
+        auto context = (info.attr & BlkAttr.STRUCTFINAL) ? cast(void*)ti : null;
+
         // array used size goes at the beginning. We can stuff the typeinfo
         // right after it, as we need to use 16 bytes anyway.
-        auto typeInfo = cast(TypeInfo*)(info.base + size_t.sizeof);
-        *typeInfo = cast() ti;
+        //
+        auto typeInfo = cast(void**)info.base + 1;
+        *typeInfo = context;
     }
-    else
+    else if(info.attr & BlkAttr.STRUCTFINAL)
     {
         // all other cases the typeinfo gets put at the end of the block
-        auto typeInfo = cast(TypeInfo*)(info.base + info.size - size_t.sizeof);
-        *typeInfo = cast() ti;
+        auto typeInfo = cast(void**)(info.base + info.size) - 1;
+        *typeInfo = cast(void*) ti;
     }
 }
 
+/**
+  Get the finalizer info from the block (typeinfo).
+  Must be called on a block with STRUCTFINAL set.
+  */
+const(TypeInfo) __getBlockFinalizerInfo(ref BlkInfo info) pure nothrow
+{
+    bool isLargeArray = (info.attr & BlkAttr.APPENDABLE) && info.size >= PAGESIZE;
+    auto typeInfo = isLargeArray ?
+        info.base + size_t.sizeof :
+        info.base + info.size - size_t.sizeof;
+    return *cast(TypeInfo*)typeInfo;
+}
+
 /**
   get the used size of the array for the given block
   */
@@ -263,8 +282,22 @@ size_t __allocPad(size_t size, uint bits) nothrow pure @trusted
     {
         if (size > MAXMEDSIZE - finalizerSize)
             return LARGEPAD;
-        return size > MAXSMALLSIZE - finalizerSize ? MEDPAD : SMALLPAD;
+        auto pad = (size > MAXSMALLSIZE - finalizerSize) ? MEDPAD : SMALLPAD;
+        return pad + finalizerSize;
     }
 
     return finalizerSize;
 }
+
+/**
+ * Get the start of the array for the given block.
+ *
+ * Params:
+ *  info = array metadata
+ * Returns:
+ *  pointer to the start of the array
+ */
+void *__arrayStart()(return scope BlkInfo info) nothrow pure
+{
+    return info.base + ((info.size & BIGLENGTHMASK) ? LARGEPREFIX : 0);
+}

druntime/src/core/internal/gc/impl/conservative/gc.d

@@ -485,7 +485,14 @@ class ConservativeGC : GC
         adjustAttrs(bits, ti);
 
         immutable padding = __allocPad(size, bits);
-        immutable needed = size + padding;
+
+        bool overflow;
+        import core.checkedint : addu;
+        immutable needed = addu(size, padding, overflow);
+        if (overflow)
+        {
+            return null;
+        }
 
         size_t localAllocSize = void;
 
@@ -585,7 +592,14 @@ class ConservativeGC : GC
         adjustAttrs(bits, ti);
 
         immutable padding = __allocPad(size, bits);
-        immutable needed = size + __allocPad(size, bits);
+        bool overflow;
+        import core.checkedint : addu;
+        immutable needed = addu(size, padding, overflow);
+        if (overflow)
+        {
+            return null;
+        }
+
 
         size_t localAllocSize = void;
 
@@ -5405,13 +5419,13 @@ private void[] setupMetadata(void[] block, uint bits, size_t padding, size_t use
             size: block.length
     );
 
-    auto typeInfoSize = (bits & BlkAttr.STRUCTFINAL) ? (void*).sizeof : 0;
 
-    if (typeInfoSize)
-        __setBlockFinalizerInfo(info, ti);
+    __setBlockFinalizerInfo(info, ti);
 
     if (bits & BlkAttr.APPENDABLE) {
-        __setArrayAllocLengthImpl(info, used, false, ~0, typeInfoSize);
+        auto typeInfoSize = (bits & BlkAttr.STRUCTFINAL) ? (void*).sizeof : 0;
+        auto success = __setArrayAllocLengthImpl(info, used, false, size_t.max, typeInfoSize);
+        assert(success);
         return __arrayStart(info)[0 .. block.length - padding];
     }