Run unit tests in 64 and 32 bit mode. Fix #41 and should prevent 32-bit bugs in the future

Hackerpilot · Hackerpilot · commit 84692a5387a2 · 2016-03-28T11:39:43.000-07:00
diff --git a/.gitignore b/.gitignore
@@ -3,10 +3,14 @@
 *.lst
 *.s
 test/tests
+test/tests_32
 test/looptest
 perf.data
 doc/
 .dub/
 dub.selections.json
 test/compile_test
+test/compile_test_32
 test/external_allocator_test
+test/external_allocator_test_32
+.gdb_history
diff --git a/src/containers/internal/backwards.d b/src/containers/internal/backwards.d
@@ -0,0 +1,29 @@
+module containers.internal.backwards;
+
+static if (__VERSION__ < 2071)
+{
+	/// 64-bit popcnt
+	int popcnt(ulong v) pure nothrow @nogc @safe
+	{
+		import core.bitop : popcnt;
+
+		return popcnt(cast(uint) v) + popcnt(cast(uint)(v >>> 32));
+	}
+
+	version (X86_64)
+		public import core.bitop : bsf;
+	else
+	{
+		/// Allow 64-bit bsf on old compilers
+		int bsf(ulong v) pure nothrow @nogc @safe
+		{
+			import core.bitop : bsf;
+
+			immutable uint lower = cast(uint) v;
+			immutable uint upper = cast(uint)(v >>> 32);
+			return lower == 0 ? bsf(upper) + 32 : bsf(lower);
+		}
+	}
+}
+else
+	public import core.bitop : bsf, popcnt;
diff --git a/src/containers/ttree.d b/src/containers/ttree.d
@@ -389,7 +389,8 @@ private:
 	alias N = FatNodeInfo!(T.sizeof, 3, cacheLineSize, ulong.sizeof);
 	enum size_t nodeCapacity = N[0];
 	alias BookkeepingType = N[1];
-	static assert (nodeCapacity <= (uint.sizeof * 8), "cannot fit height info and registry in ulong");
+	enum HEIGHT_BIT_OFFSET = 48UL;
+	static assert (nodeCapacity <= HEIGHT_BIT_OFFSET, "cannot fit height info and registry in ulong");
 	enum fullBitPattern = fullBits!(ulong, nodeCapacity);
 
 	enum RangeType : ubyte { all, lower, equal, upper }
@@ -454,7 +455,8 @@ private:
 	{
 		private size_t nextAvailableIndex() const nothrow pure @nogc @safe
 		{
-			import core.bitop : bsf;
+			import containers.internal.backwards : bsf;
+
 			return bsf(~(registry & fullBitPattern));
 		}
 
@@ -501,14 +503,15 @@ private:
 			immutable ulong l = left !is null ? left.height() : 0;
 			immutable ulong r = right !is null ? right.height() : 0;
 			immutable ulong h = 1 + (l > r ? l : r);
+			assert (h < ushort.max);
 			registry &= fullBitPattern;
-			registry |= (h << 32UL);
+			registry |= (h << HEIGHT_BIT_OFFSET);
 			return h;
 		}
 
 		ulong height() const nothrow pure @nogc @safe
 		{
-			return registry >>> 32UL;
+			return registry >>> HEIGHT_BIT_OFFSET;
 		}
 
 		int imbalanced() const nothrow pure @nogc @safe
@@ -720,7 +723,7 @@ private:
 		{
 			if (left is null && right is null)
 			{
-				size_t i = nextAvailableIndex() - 1;
+				immutable size_t i = nextAvailableIndex() - 1;
 				Value r = values[i];
 				markUnused(i);
 				return r;
@@ -871,7 +874,7 @@ private:
 		Node* parent;
 
 		Value[nodeCapacity] values;
-		ulong registry = 1UL << 32UL;
+		ulong registry = 1UL << HEIGHT_BIT_OFFSET;
 	}
 
 	AllocatorType allocator;
diff --git a/src/containers/unrolledlist.d b/src/containers/unrolledlist.d
@@ -176,7 +176,7 @@ struct UnrolledList(T, Allocator = Mallocator,
 	 */
 	bool remove(T item)
 	{
-		import core.bitop : popcnt;
+		import containers.internal.backwards : popcnt;
 		if (_front is null)
 			return false;
 		bool retVal = false;
@@ -218,7 +218,7 @@ struct UnrolledList(T, Allocator = Mallocator,
 	}
 	body
 	{
-		import core.bitop : bsf, popcnt;
+		import containers.internal.backwards : bsf;
 		size_t index = bsf(_front.registry);
 		T r = _front.items[index];
 		_front.markUnused(index);
@@ -268,7 +268,7 @@ struct UnrolledList(T, Allocator = Mallocator,
 	}
 	body
 	{
-		import core.bitop: bsf;
+		import containers.internal.backwards : bsf;
 		import std.string: format;
 		size_t index = bsf(_front.registry);
 		assert (index < nodeCapacity, format("%d", index));
@@ -308,7 +308,7 @@ struct UnrolledList(T, Allocator = Mallocator,
 	}
 	body
 	{
-		import core.bitop : popcnt;
+		import containers.internal.backwards : popcnt;
 		size_t i = nodeCapacity - 1;
 		while (_back.isFree(i))
 		{
@@ -346,13 +346,15 @@ struct UnrolledList(T, Allocator = Mallocator,
 
 		this(inout(Node)* current, size_t l)
 		{
-			import core.bitop: bsf;
+			import containers.internal.backwards : bsf;
+			version(assert) import std.format:format;
+
 			this.current = current;
 			this.length = l;
 			if (current !is null)
 			{
 				index = bsf(current.registry);
-				assert (index < nodeCapacity);
+				assert (index < nodeCapacity, "index = %d, nodeCapacity = %d".format(index, nodeCapacity));
 			}
 		}
 
@@ -456,22 +458,12 @@ private:
 
 	static bool shouldMerge(const Node* first, const Node* second)
 	{
-		import core.bitop : popcnt;
+		import containers.internal.backwards : popcnt;
 
 		if (first is null || second is null)
 			return false;
-		static if (first.registry.sizeof > uint.sizeof)
-		{
-			immutable f = popcnt(cast(uint) first.registry)
-				+ popcnt(cast(uint) (first.registry >>> 32));
-			immutable s = popcnt(cast(uint) second.registry)
-				+ popcnt(cast(uint) (second.registry >>> 32));
-		}
-		else
-		{
-			immutable f = popcnt(first.registry);
-			immutable s = popcnt(second.registry);
-		}
+		immutable f = popcnt(first.registry);
+		immutable s = popcnt(second.registry);
 		return f + s <= nodeCapacity;
 	}
 
@@ -484,7 +476,7 @@ private:
 	}
 	body
 	{
-		import core.bitop: bsf;
+		import containers.internal.backwards : bsf;
 		size_t i;
 		ContainerStorageType!T[nodeCapacity] temp;
 		foreach (j; 0 .. nodeCapacity)
@@ -505,7 +497,7 @@ private:
 	{
 		size_t nextAvailableIndex() const nothrow pure @safe @nogc
 		{
-			import core.bitop: bsf;
+			import containers.internal.backwards : bsf;
 			return bsf(~registry);
 		}
 
diff --git a/test/makefile b/test/makefile
@@ -1,19 +1,31 @@
 .PHONY: test graphs clean
 
-SRC=$(shell find ../src/ -name "*.d") $(shell find ../experimental_allocator -name "*.d")
-FLAGS=-unittest -main -g -cov -I../src/ -debug -wi
+SRC:=$(shell find ../src/ -name "*.d") $(shell find ../experimental_allocator -name "*.d")
+FLAGS:=-unittest -main -g -cov -I../src/ -debug -wi
+FLAGS32:=$(FLAGS) -m32
 
-test: compile_test external_allocator_test
-	dmd $(FLAGS) $(SRC) -oftests
+all: test test_32 compile_test compile_test_32 external_allocator_test external_allocator_test_32
 	./tests
+	./tests_32
 	./compile_test
+	./compile_test_32
 	./external_allocator_test
+	./external_allocator_test_32
+
+test: $(SRC)
+	dmd $(FLAGS) $(SRC) -oftests
+test_32: $(SRC)
+	dmd $(FLAGS32) $(SRC) -oftests_32
 
-compile_test: compile_test.d
+compile_test: compile_test.d $(SRC)
 	dmd $(FLAGS) compile_test.d $(SRC) -ofcompile_test
+compile_test_32: compile_test.d $(SRC)
+	dmd $(FLAGS32) compile_test.d $(SRC) -ofcompile_test_32
 
-external_allocator_test: external_allocator_test.d
+external_allocator_test: external_allocator_test.d $(SRC)
 	dmd $(FLAGS) external_allocator_test.d $(SRC) -ofexternal_allocator_test
+external_allocator_test_32: external_allocator_test.d $(SRC)
+	dmd $(FLAGS32) external_allocator_test.d $(SRC) -ofexternal_allocator_test_32
 
 looptest: looptest.d
 	dmd looptest.d -inline -O -release \

Original file line number	Diff line number	Diff line change
`@@ -389,7 +389,8 @@ private:`
`389`	`389`	`alias N = FatNodeInfo!(T.sizeof, 3, cacheLineSize, ulong.sizeof);`
`390`	`390`	`enum size_t nodeCapacity = N[0];`
`391`	`391`	`alias BookkeepingType = N[1];`
`392`		`- static assert (nodeCapacity <= (uint.sizeof * 8), "cannot fit height info and registry in ulong");`
	`392`	`+ enum HEIGHT_BIT_OFFSET = 48UL;`
	`393`	`+ static assert (nodeCapacity <= HEIGHT_BIT_OFFSET, "cannot fit height info and registry in ulong");`
`393`	`394`	`enum fullBitPattern = fullBits!(ulong, nodeCapacity);`
`394`	`395`
`395`	`396`	`enum RangeType : ubyte { all, lower, equal, upper }`
`@@ -454,7 +455,8 @@ private:`
`454`	`455`	`{`
`455`	`456`	`private size_t nextAvailableIndex() const nothrow pure @nogc @safe`
`456`	`457`	`{`
`457`		`- import core.bitop : bsf;`
	`458`	`+ import containers.internal.backwards : bsf;`
	`459`	`+`
`458`	`460`	`return bsf(~(registry & fullBitPattern));`
`459`	`461`	`}`
`460`	`462`
`@@ -501,14 +503,15 @@ private:`
`501`	`503`	`immutable ulong l = left !is null ? left.height() : 0;`
`502`	`504`	`immutable ulong r = right !is null ? right.height() : 0;`
`503`	`505`	`immutable ulong h = 1 + (l > r ? l : r);`
	`506`	`+ assert (h < ushort.max);`
`504`	`507`	`registry &= fullBitPattern;`
`505`		`- registry \|= (h << 32UL);`
	`508`	`+ registry \|= (h << HEIGHT_BIT_OFFSET);`
`506`	`509`	`return h;`
`507`	`510`	`}`
`508`	`511`
`509`	`512`	`ulong height() const nothrow pure @nogc @safe`
`510`	`513`	`{`
`511`		`- return registry >>> 32UL;`
	`514`	`+ return registry >>> HEIGHT_BIT_OFFSET;`
`512`	`515`	`}`
`513`	`516`
`514`	`517`	`int imbalanced() const nothrow pure @nogc @safe`
`@@ -720,7 +723,7 @@ private:`
`720`	`723`	`{`
`721`	`724`	`if (left is null && right is null)`
`722`	`725`	`{`
`723`		`- size_t i = nextAvailableIndex() - 1;`
	`726`	`+ immutable size_t i = nextAvailableIndex() - 1;`
`724`	`727`	`Value r = values[i];`
`725`	`728`	`markUnused(i);`
`726`	`729`	`return r;`
`@@ -871,7 +874,7 @@ private:`
`871`	`874`	`Node* parent;`
`872`	`875`
`873`	`876`	`Value[nodeCapacity] values;`
`874`		`- ulong registry = 1UL << 32UL;`
	`877`	`+ ulong registry = 1UL << HEIGHT_BIT_OFFSET;`
`875`	`878`	`}`
`876`	`879`
`877`	`880`	`AllocatorType allocator;`
Original file line number	Diff line number	Diff line change
`@@ -176,7 +176,7 @@ struct UnrolledList(T, Allocator = Mallocator,`
`176`	`176`	`*/`
`177`	`177`	`bool remove(T item)`
`178`	`178`	`{`
`179`		`- import core.bitop : popcnt;`
	`179`	`+ import containers.internal.backwards : popcnt;`
`180`	`180`	`if (_front is null)`
`181`	`181`	`return false;`
`182`	`182`	`bool retVal = false;`
`@@ -218,7 +218,7 @@ struct UnrolledList(T, Allocator = Mallocator,`
`218`	`218`	`}`
`219`	`219`	`body`
`220`	`220`	`{`
`221`		`- import core.bitop : bsf, popcnt;`
	`221`	`+ import containers.internal.backwards : bsf;`
`222`	`222`	`size_t index = bsf(_front.registry);`
`223`	`223`	`T r = _front.items[index];`
`224`	`224`	`_front.markUnused(index);`
`@@ -268,7 +268,7 @@ struct UnrolledList(T, Allocator = Mallocator,`
`268`	`268`	`}`
`269`	`269`	`body`
`270`	`270`	`{`
`271`		`- import core.bitop: bsf;`
	`271`	`+ import containers.internal.backwards : bsf;`
`272`	`272`	`import std.string: format;`
`273`	`273`	`size_t index = bsf(_front.registry);`
`274`	`274`	`assert (index < nodeCapacity, format("%d", index));`
`@@ -308,7 +308,7 @@ struct UnrolledList(T, Allocator = Mallocator,`
`308`	`308`	`}`
`309`	`309`	`body`
`310`	`310`	`{`
`311`		`- import core.bitop : popcnt;`
	`311`	`+ import containers.internal.backwards : popcnt;`
`312`	`312`	`size_t i = nodeCapacity - 1;`
`313`	`313`	`while (_back.isFree(i))`
`314`	`314`	`{`
`@@ -346,13 +346,15 @@ struct UnrolledList(T, Allocator = Mallocator,`
`346`	`346`
`347`	`347`	`this(inout(Node)* current, size_t l)`
`348`	`348`	`{`
`349`		`- import core.bitop: bsf;`
	`349`	`+ import containers.internal.backwards : bsf;`
	`350`	`+ version(assert) import std.format:format;`
	`351`	`+`
`350`	`352`	`this.current = current;`
`351`	`353`	`this.length = l;`
`352`	`354`	`if (current !is null)`
`353`	`355`	`{`
`354`	`356`	`index = bsf(current.registry);`
`355`		`- assert (index < nodeCapacity);`
	`357`	`+ assert (index < nodeCapacity, "index = %d, nodeCapacity = %d".format(index, nodeCapacity));`
`356`	`358`	`}`
`357`	`359`	`}`
`358`	`360`
`@@ -456,22 +458,12 @@ private:`
`456`	`458`
`457`	`459`	`static bool shouldMerge(const Node* first, const Node* second)`
`458`	`460`	`{`
`459`		`- import core.bitop : popcnt;`
	`461`	`+ import containers.internal.backwards : popcnt;`
`460`	`462`
`461`	`463`	`if (first is null \|\| second is null)`
`462`	`464`	`return false;`
`463`		`- static if (first.registry.sizeof > uint.sizeof)`
`464`		`- {`
`465`		`- immutable f = popcnt(cast(uint) first.registry)`
`466`		`- + popcnt(cast(uint) (first.registry >>> 32));`
`467`		`- immutable s = popcnt(cast(uint) second.registry)`
`468`		`- + popcnt(cast(uint) (second.registry >>> 32));`
`469`		`- }`
`470`		`- else`
`471`		`- {`
`472`		`- immutable f = popcnt(first.registry);`
`473`		`- immutable s = popcnt(second.registry);`
`474`		`- }`
	`465`	`+ immutable f = popcnt(first.registry);`
	`466`	`+ immutable s = popcnt(second.registry);`
`475`	`467`	`return f + s <= nodeCapacity;`
`476`	`468`	`}`
`477`	`469`
`@@ -484,7 +476,7 @@ private:`
`484`	`476`	`}`
`485`	`477`	`body`
`486`	`478`	`{`
`487`		`- import core.bitop: bsf;`
	`479`	`+ import containers.internal.backwards : bsf;`
`488`	`480`	`size_t i;`
`489`	`481`	`ContainerStorageType!T[nodeCapacity] temp;`
`490`	`482`	`foreach (j; 0 .. nodeCapacity)`
`@@ -505,7 +497,7 @@ private:`
`505`	`497`	`{`
`506`	`498`	`size_t nextAvailableIndex() const nothrow pure @safe @nogc`
`507`	`499`	`{`
`508`		`- import core.bitop: bsf;`
	`500`	`+ import containers.internal.backwards : bsf;`
`509`	`501`	`return bsf(~registry);`
`510`	`502`	`}`
`511`	`503`