support for finalization in slab allocs and tests for same. (#320)

Author: dsm9000

sdlib/d/gc/tcache.d

@@ -36,7 +36,8 @@ public:
 			return null;
 		}
 
-		auto asize = getAllocSize(alignUp(size, 2 * Quantum));
+		auto reservedBytes = finalizer is null ? 0 : PointerSize;
+		auto asize = getAllocSize(alignUp(size + reservedBytes, 2 * Quantum));
 		assert(sizeClassSupportsMetadata(getSizeClass(asize)),
 		       "allocAppendable got size class without metadata support!");
 
@@ -47,12 +48,11 @@ public:
 			auto ptr = arena.allocSmall(emap, asize);
 			auto pd = getPageDescriptor(ptr);
 			auto si = SlabAllocInfo(pd, ptr);
-			si.setUsedCapacity(size);
-			assert(finalizer is null, "finalizer not yet supported for slab!");
+			si.initializeMetadata(finalizer, size);
 			return ptr;
 		}
 
-		auto ptr = arena.allocLarge(emap, asize, false);
+		auto ptr = arena.allocLarge(emap, size, false);
 		auto pd = getPageDescriptor(ptr);
 		auto e = pd.extent;
 		e.setUsedCapacity(size);
@@ -92,11 +92,21 @@ public:
 		}
 
 		auto pd = getPageDescriptor(ptr);
-
 		auto e = pd.extent;
-		// Slab is not yet supported
-		if (e !is null && !pd.isSlab() && e.finalizer !is null) {
-			e.finalizer(ptr, e.usedCapacity);
+
+		if (pd.isSlab()) {
+			auto si = SlabAllocInfo(pd, ptr);
+			auto finalizer = si.finalizer;
+			if (finalizer !is null) {
+				assert(cast(void*) si.address == ptr,
+				       "destroy() was invoked on an interior pointer!");
+
+				finalizer(ptr, si.usedCapacity);
+			}
+		} else {
+			if (e.finalizer !is null) {
+				e.finalizer(ptr, e.usedCapacity);
+			}
 		}
 
 		pd.arena.free(emap, pd, ptr);
@@ -125,8 +135,9 @@ public:
 			auto oldSizeClass = pd.sizeClass;
 			if (samePointerness && newSizeClass == oldSizeClass) {
 				auto si = SlabAllocInfo(pd, ptr);
-				si.setUsedCapacity(size);
-				return ptr;
+				if (!si.allowsMetadata || si.setUsedCapacity(size)) {
+					return ptr;
+				}
 			}
 
 			if (newSizeClass > oldSizeClass) {
@@ -834,4 +845,33 @@ unittest finalization {
 	auto oldDestroyCount = destroyCount;
 	threadCache.destroy(s1);
 	assert(destroyCount == oldDestroyCount);
+
+	// Finalizers for small allocs:
+	auto s2 = threadCache.allocAppendable(45, false, &destruct);
+	assert(threadCache.getCapacity(s2[0 .. 45]) == 56);
+	assert(!threadCache.extend(s2[0 .. 45], 12));
+	assert(threadCache.extend(s2[0 .. 45], 11));
+	assert(threadCache.getCapacity(s2[0 .. 56]) == 56);
+	threadCache.destroy(s2);
+	assert(lastKilledAddress == s2);
+	assert(lastKilledUsedCapacity == 56);
+
+	// Behaviour of realloc() on small allocs with finalizers:
+	auto s3 = threadCache.allocAppendable(70, false, &destruct);
+	assert(threadCache.getCapacity(s3[0 .. 70]) == 72);
+	auto s4 = threadCache.realloc(s3, 70, false);
+	assert(s3 == s4);
+
+	// This is in the same size class, but will not work in-place
+	// given as finalizer occupies final 8 of the 80 bytes in the slot:
+	auto s5 = threadCache.realloc(s4, 75, false);
+	assert(s5 != s4);
+
+	// So we end up with a new alloc, without metadata:
+	assert(threadCache.getCapacity(s5[0 .. 80]) == 80);
+
+	// And the finalizer has been discarded:
+	oldDestroyCount = destroyCount;
+	threadCache.destroy(s5);
+	assert(destroyCount == oldDestroyCount);
 }