allocAppendable() and getCapacity().

sdlib/d/gc/extent.d

@@ -99,7 +99,15 @@ private:
 	Links _links;
 
 	import d.gc.bitmap;
-	Bitmap!512 _slabData = void;
+	union Meta {
+		// Slab occupancy (constrained by freeSlots, so usable for all classes)
+		Bitmap!512 _slabData;
+
+		// Metadata for non-slab (large) size classes
+		size_t allocSize; // Actual alloc size, 0 if not appendable
+	}
+
+	Meta _meta;
 
 	this(uint arenaIndex, void* ptr, size_t size, ubyte generation,
 	     HugePageDescriptor* hpd, ExtentClass ec) {
@@ -120,10 +128,27 @@ private:
 			bits |= ulong(binInfos[ec.sizeClass].slots) << 48;
 
 			slabData.clear();
+		} else {
+			_meta.allocSize = 0;
 		}
 	}
 
 public:
+	@property
+	bool isAppendable() {
+		return allocSize != 0;
+	}
+
+	@property
+	ulong allocSize() {
+		return isLarge() ? _meta.allocSize : 0;
+	}
+
+	void setAllocSize(size_t size) {
+		assert(isLarge(), "Cannot set alloc size on a slab alloc!");
+		_meta.allocSize = size;
+	}
+
 	Extent* at(void* ptr, size_t size, HugePageDescriptor* hpd,
 	           ExtentClass ec) {
 		this = Extent(arenaIndex, ptr, size, generation, hpd, ec);
@@ -202,6 +227,10 @@ public:
 		return ec.isSlab();
 	}
 
+	bool isLarge() const {
+		return !isSlab();
+	}
+
 	@property
 	ubyte sizeClass() const {
 		auto ec = extentClass;
@@ -240,7 +269,7 @@ public:
 		// FIXME: in contract.
 		assert(isSlab(), "slabData accessed on non slab!");
 
-		return _slabData;
+		return _meta._slabData;
 	}
 }
 

sdlib/d/gc/tcache.d

@@ -1,5 +1,6 @@
 module d.gc.tcache;
 
+import d.gc.extent;
 import d.gc.sizeclass;
 import d.gc.spec;
 import d.gc.util;
@@ -15,17 +16,26 @@ private:
 	const(void*)[][] roots;
 
 public:
-	void* alloc(size_t size, bool containsPointers) {
+	void* alloc(size_t size, bool containsPointers, bool isAppendable = false) {
 		if (!isAllocatableSize(size)) {
 			return null;
 		}
 
 		initializeExtentMap();
 
 		auto arena = chooseArena(containsPointers);
-		return size <= SizeClass.Small
-			? arena.allocSmall(emap, size)
-			: arena.allocLarge(emap, size, false);
+
+		if (isAppendable) {
+			// Currently, large (extent) allocs must be used for appendables:
+			auto ptr = arena.allocLarge(emap, upsizeToLarge(size), false);
+			auto pd = getPageDescriptor(ptr);
+			pd.extent.setAllocSize(size);
+			return ptr;
+		} else {
+			return size <= SizeClass.Small
+				? arena.allocSmall(emap, size)
+				: arena.allocLarge(emap, size, false);
+		}
 	}
 
 	void* calloc(size_t size, bool containsPointers) {
@@ -54,6 +64,39 @@ public:
 		pd.arena.free(emap, pd, ptr);
 	}
 
+	// Determine whether given alloc is appendable
+	bool is_appendable(void* ptr) {
+		return maybeGetAppendableExtent(ptr) !is null;
+	}
+
+	// Get the current fill of an appendable alloc.
+	// If the alloc is not appendable, returns 0.
+	size_t get_appendable_fill(void* ptr) {
+		auto e = maybeGetAppendableExtent(ptr);
+		return (e !is null) ? e.allocSize : 0;
+	}
+
+	// Get the current free space of an appendable alloc.
+	// If the alloc is not appendable, returns 0.
+	size_t get_appendable_free_space(void* ptr) {
+		auto e = maybeGetAppendableExtent(ptr);
+		return (e !is null) ? e.size - e.allocSize : 0;
+	}
+
+	// Change the current fill of an appendable alloc.
+	// If the alloc is not appendable, or the requested
+	// fill exceeds the available space, returns false.
+	bool set_appendable_fill(void* ptr, size_t fill) {
+		auto e = maybeGetAppendableExtent(ptr);
+
+		if ((e !is null) && (fill <= e.size)) {
+			e.setAllocSize(fill);
+			return true;
+		}
+
+		return false;
+	}
+
 	void* realloc(void* ptr, size_t size, bool containsPointers) {
 		if (!isAllocatableSize(size)) {
 			free(ptr);
@@ -64,9 +107,12 @@ public:
 			return alloc(size, containsPointers);
 		}
 
+		size_t oldFill = 0;
 		auto copySize = size;
 		auto pd = getPageDescriptor(ptr);
 
+		// TODO: should realloc work with pointers outside of GC?
+
 		if (pd.isSlab()) {
 			auto newSizeClass = getSizeClass(size);
 			auto oldSizeClass = pd.sizeClass;
@@ -78,23 +124,37 @@ public:
 				copySize = getSizeFromClass(oldSizeClass);
 			}
 		} else {
-			auto esize = pd.extent.size;
-			if (alignUp(size, PageSize) == esize) {
+			oldFill = pd.extent.allocSize;
+
+			// Prohibit resize below appendable fill:
+			if (size < oldFill)
+				return ptr;
+
+			auto oldSize = oldFill ? oldFill : pd.extent.size;
+
+			if (alignUp(size, PageSize) == alignUp(oldSize, PageSize)) {
 				return ptr;
 			}
 
 			// TODO: Try to extend/shrink in place.
-			import d.gc.util;
-			copySize = min(size, esize);
+			copySize = min(size, oldSize);
 		}
 
 		containsPointers = (containsPointers | pd.containsPointers) != 0;
-		auto newPtr = alloc(size, containsPointers);
+		auto useSize = oldFill ? upsizeToLarge(size) : size;
+		auto newPtr = alloc(useSize, containsPointers);
 		if (newPtr is null) {
 			return null;
 		}
 
 		memcpy(newPtr, ptr, copySize);
+
+		if (oldFill) {
+			auto pdNew = getPageDescriptor(newPtr);
+			assert(pdNew.extent.isLarge());
+			pdNew.extent.setAllocSize(oldFill);
+		}
+
 		pd.arena.free(emap, pd, ptr);
 
 		return newPtr;
@@ -171,6 +231,29 @@ public:
 	}
 
 private:
+	// Force large allocation rather than slab
+	size_t upsizeToLarge(size_t size) {
+		auto aSize = size;
+		while (getAllocSize(aSize) <= SizeClass.Small) {
+			aSize = getSizeFromClass(getSizeClass(aSize) + 1);
+		}
+
+		return aSize;
+	}
+
+	// Get appendable extent of ptr, or null if this is impossible
+	Extent* maybeGetAppendableExtent(void* ptr) {
+		if (ptr is null)
+			return null;
+
+		auto pd = maybeGetPageDescriptor(ptr);
+		if ((pd.extent is null) || (ptr !is pd.extent.address)
+			    || (!pd.extent.isAppendable))
+			return null;
+
+		return pd.extent;
+	}
+
 	auto getPageDescriptor(void* ptr) {
 		auto pd = maybeGetPageDescriptor(ptr);
 		assert(pd.extent !is null);
@@ -283,3 +366,57 @@ unittest makeRange {
 	checkRange(ptr[1 .. 7], 0, 0);
 	checkRange(ptr[1 .. 8], 8, 8);
 }
+
+unittest appendableAlloc {
+	// Basics:
+	auto p0 = threadCache.alloc(100, false, true);
+	auto p1 = threadCache.alloc(100, false, false);
+	assert(threadCache.is_appendable(p0));
+	assert(!threadCache.is_appendable(p1));
+	assert(threadCache.get_appendable_fill(p1) == 0);
+	assert(threadCache.get_appendable_free_space(p1) == 0);
+	assert(threadCache.get_appendable_fill(p0) == 100);
+	assert(threadCache.get_appendable_free_space(p0) == 16284);
+	assert(threadCache.set_appendable_fill(p0, 50000) == false);
+	assert(threadCache.set_appendable_fill(p0, 200) == true);
+	assert(threadCache.get_appendable_fill(p0) == 200);
+	assert(threadCache.get_appendable_free_space(p0) == 16184);
+
+	// Realloc non-appendable alloc, should stay non-appendable :
+	p1 = threadCache.realloc(p1, 1000, false);
+	assert(p1 !is null);
+	assert(!threadCache.is_appendable(p1));
+	assert(threadCache.get_appendable_fill(p1) == 0);
+	assert(threadCache.get_appendable_free_space(p1) == 0);
+	threadCache.free(p1);
+
+	// Realloc an appendable alloc up :
+	p0 = threadCache.realloc(p0, 100000, false);
+	assert(p0 !is null);
+	assert(threadCache.get_appendable_fill(p0) == 200);
+	assert(threadCache.set_appendable_fill(p0, 50000) == true);
+	assert(threadCache.get_appendable_fill(p0) == 50000);
+	assert(threadCache.get_appendable_free_space(p0) == 52400);
+
+	// Realloc an appendable alloc down :
+	p0 = threadCache.realloc(p0, 60000, false);
+	assert(p0 !is null);
+	assert(threadCache.get_appendable_free_space(p0) == 11440);
+
+	// Realloc prohibited by appendable fill, so nothing should change
+	auto p3 = threadCache.realloc(p0, 40000, false);
+	assert(p3 == p0);
+
+	// Pointers the GC does not know about:
+	void* interior = p0 + 2000;
+	assert(!threadCache.is_appendable(interior));
+	assert(threadCache.set_appendable_fill(interior, 222) == false);
+	assert(threadCache.get_appendable_fill(interior) == 0);
+	assert(threadCache.get_appendable_free_space(interior) == 0);
+	threadCache.free(p0);
+	auto martian = cast(void*) 0x56789abcd000;
+	assert(!threadCache.is_appendable(martian));
+	assert(threadCache.set_appendable_fill(martian, 333) == false);
+	assert(threadCache.get_appendable_fill(martian) == 0);
+	assert(threadCache.get_appendable_free_space(martian) == 0);
+}