[GC] When using free, make sure we leave space int he thread bin to accomodate it.

Author: deadalnix

sdlib/d/gc/tbin.d

@@ -75,7 +75,7 @@ public:
 
 	void refill(ref CachedExtentMap emap, shared(Arena)* arena,
 	            ref ThreadBinState state, ubyte sizeClass, size_t slotSize) {
-		auto nfill = nmax >> state.fillShift;
+		auto nfill = state.getFill(nmax);
 		assert(nfill > 0);
 
 		/**
@@ -99,7 +99,14 @@ public:
 		return true;
 	}
 
-	void flushToFree(ref CachedExtentMap emap) {
+	void flushToFree(ref CachedExtentMap emap, ref ThreadBinState state) {
+		/**
+		 * When we use free explicitely, we want to make sure we have room
+		 * left in the bin to accomodate further freed elements, even in case
+		 * where we refill.
+		 */
+		state.onFlush();
+
 		/**
 		 * We do not have enough space in the bin, so start flushing.
 		 * However, we do not want to flush all of it, as it would leave
@@ -298,7 +305,25 @@ private:
 
 struct ThreadBinState {
 	bool refilled;
+	bool flushed;
 	ubyte fillShift;
+
+	uint getFill(ushort nmax) const {
+		return nmax >> fillShift;
+	}
+
+	bool onFlush() {
+		if (flushed) {
+			return false;
+		}
+
+		flushed = true;
+		if (fillShift == 0) {
+			fillShift++;
+		}
+
+		return true;
+	}
 }
 
 bool isValidThreadBinCapacity(uint capacity) {
@@ -521,3 +546,44 @@ unittest refill {
 		       "Invalid cached element count!");
 	}
 }
+
+unittest flushed {
+	import d.gc.base;
+	shared Base base;
+	scope(exit) base.clear();
+
+	import d.gc.emap;
+	static shared ExtentMap emapStorage;
+	auto emap = CachedExtentMap(&emapStorage, &base);
+
+	enum BinSize = 200;
+
+	// Setup the bin.
+	void*[BinSize] buffer;
+	auto tbin = ThreadBin(buffer[0 .. BinSize]);
+	assert(tbin.empty);
+
+	// Setup the state.
+	ThreadBinState state;
+
+	// When we need to flush for free, we reduce refill.
+	tbin.flushToFree(emap, state);
+
+	assert(state.flushed, "Thread bin was not flushed!");
+	assert(state.getFill(tbin.nmax) == BinSize / 2, "Unexpected fill!");
+
+	// On repeat, nothing happens.
+	tbin.flushToFree(emap, state);
+
+	assert(state.flushed, "Thread bin was not flushed!");
+	assert(state.getFill(tbin.nmax) == BinSize / 2, "Unexpected fill!");
+
+	// When flushed is cleared, we redo, but never
+	// reduce fill to less than half the bin.
+	state.flushed = false;
+	tbin.flushToFree(emap, state);
+
+	assert(!state.refilled, "Thread bin refilled!");
+	assert(state.flushed, "Thread bin was not flushed!");
+	assert(state.getFill(tbin.nmax) == BinSize / 2, "Unexpected fill!");
+}

sdlib/d/gc/tcache.d

@@ -320,7 +320,7 @@ private:
 			return;
 		}
 
-		bin.flushToFree(emap);
+		bin.flushToFree(emap, binStates[index]);
 
 		auto success = bin.free(ptr);
 		assert(success, "Unable to free!");