Merge branch 'master' of github.com:dsm9000/sdc into slab_alloc_threadcache

Author: dsm9000

sdlib/d/gc/arena.d

@@ -112,12 +112,13 @@ public:
 	/**
 	 * Small allocation facilities.
 	 */
-	void* allocSmall(shared(ExtentMap)* emap, size_t size) shared {
+	uint allocSmall(shared(ExtentMap)* emap, size_t size,
+	                void*[] allocs) shared {
 		// TODO: in contracts
 		assert(isSmallSize(size));
 
 		auto sizeClass = getSizeClass(size);
-		return bins[sizeClass].alloc(&this, emap, sizeClass);
+		return bins[sizeClass].alloc(&this, emap, sizeClass, allocs);
 	}
 
 	/**

sdlib/d/gc/bin.d

@@ -20,8 +20,8 @@ struct Bin {
 	import d.gc.heap;
 	Heap!(Extent, addrExtentCmp) slabs;
 
-	void* alloc(shared(Arena)* arena, shared(ExtentMap)* emap,
-	            ubyte sizeClass) shared {
+	uint alloc(shared(Arena)* arena, shared(ExtentMap)* emap, ubyte sizeClass,
+	           void*[] allocs) shared {
 		import d.gc.sizeclass;
 		assert(sizeClass < ClassCount.Small);
 		assert(&arena.bins[sizeClass] == &this, "Invalid arena or sizeClass!");
@@ -31,21 +31,27 @@ struct Bin {
 		auto size = binInfos[sizeClass].itemSize;
 
 		Extent* slab;
-		uint index;
+		uint gotAllocs;
 
 		{
 			mutex.lock();
 			scope(exit) mutex.unlock();
 
 			slab = (cast(Bin*) &this).getSlab(arena, emap, sizeClass);
 			if (slab is null) {
-				return null;
+				return 0;
 			}
 
-			index = slab.allocate();
+			// Get as many of the requested slots as we can from the current slab:
+			import d.gc.util;
+			gotAllocs = min(cast(uint) allocs.length, slab.freeSlots);
+			foreach (i; 0 .. gotAllocs) {
+				auto index = slab.allocate();
+				allocs[i] = slab.address + index * size;
+			}
 		}
 
-		return slab.address + index * size;
+		return gotAllocs;
 	}
 
 	bool free(shared(Arena)* arena, void* ptr, PageDescriptor pd) shared {

sdlib/d/gc/dequeue.d

@@ -0,0 +1,147 @@
+module d.gc.dequeue;
+
+template DEQueue(T, uint Entries) {
+	struct DEQueue {
+	private:
+		uint _front = 0;
+		uint _back = 0;
+		uint _count = 0;
+		T[Entries] _buffer;
+
+	public:
+		enum Size = Entries;
+
+		@property
+		auto buffer() {
+			assert(empty, "Buffer is not empty!");
+
+			return _buffer.ptr;
+		}
+
+		void clear() {
+			_front = 0;
+			_back = 0;
+			_count = 0;
+		}
+
+		void pushBackAdvance(uint delta) {
+			assert(empty, "Cannot pushBackAdvance: not empty!");
+			assert(delta <= Entries,
+			       "Cannot pushBackAdvance: delta exceeds Entries!");
+
+			_front = 0;
+			_back = delta % Entries;
+			_count = delta;
+		}
+
+		void pushBack(T item) {
+			assert(!full, "Cannot pushBack: full!");
+
+			_buffer[_back] = item;
+			_back = (_back + 1) % Entries;
+			_count++;
+		}
+
+		T popFront() {
+			assert(!empty, "Cannot popFront: empty!");
+
+			auto item = _buffer[_front];
+			_front = (_front + 1) % Entries;
+			_count--;
+
+			return item;
+		}
+
+		void pushFront(T item) {
+			assert(!full, "Cannot pushFront: full!");
+
+			_front = (_front > 0 ? _front : Entries) - 1;
+			_buffer[_front] = item;
+			_count++;
+		}
+
+		T popBack() {
+			assert(!empty, "Cannot popBack: empty!");
+
+			_back = (_back > 0 ? _back : Entries) - 1;
+			auto item = _buffer[_back];
+			_count--;
+
+			return item;
+		}
+
+		@property
+		auto length() {
+			return _count;
+		}
+
+		@property
+		bool empty() {
+			return _count == 0;
+		}
+
+		@property
+		bool full() {
+			return _count == Entries;
+		}
+	}
+}
+
+unittest DEQueue {
+	static DEQueue!(uint, 3) q;
+	assert(q.empty);
+
+	q.pushBack(1);
+	q.pushBack(2);
+	q.pushBack(3);
+	assert(q.full);
+	assert(q.popFront() == 1);
+	assert(q.popFront() == 2);
+	assert(q.popFront() == 3);
+	assert(q.empty);
+
+	q.pushBack(1);
+	q.pushBack(2);
+	q.pushBack(3);
+	assert(q.full);
+	assert(q.popBack() == 3);
+	assert(q.popBack() == 2);
+	assert(q.popBack() == 1);
+	assert(q.empty);
+
+	q.pushFront(1);
+	q.pushFront(2);
+	q.pushFront(3);
+	assert(q.full);
+	assert(q.popFront() == 3);
+	assert(q.popFront() == 2);
+	assert(q.popFront() == 1);
+	assert(q.empty);
+
+	q.pushFront(1);
+	q.pushFront(2);
+	q.pushFront(3);
+	assert(q.full);
+	assert(q.popBack() == 1);
+	assert(q.popBack() == 2);
+	assert(q.popBack() == 3);
+	assert(q.empty);
+
+	q.pushBack(1);
+	q.pushFront(2);
+	q.pushBack(3);
+	assert(q.full);
+	assert(q.popFront() == 2);
+	assert(q.popBack() == 3);
+	assert(q.popFront() == 1);
+	assert(q.empty);
+
+	q.pushBack(1);
+	q.pushFront(2);
+	q.pushBack(3);
+	assert(q.full);
+	assert(q.popBack() == 3);
+	assert(q.popFront() == 2);
+	assert(q.popBack() == 1);
+	assert(q.empty);
+}

sdlib/d/gc/slab.d

@@ -76,6 +76,10 @@ public:
 		return true;
 	}
 
+	void clearMetadata() {
+		setFreeSpace(0);
+	}
+
 	@property
 	Finalizer finalizer() {
 		if (!finalizerEnabled) {