Use LDC intrinsics to speed up hashmap and unrolledlist

Author: Hackerpilot

src/containers/hashset.d

@@ -207,7 +207,6 @@ private:
 	import containers.internal.node : shouldAddGCRange, FatNodeInfo;
 	import containers.internal.storage_type : ContainerStorageType;
 	import std.traits : isPointer;
-	import core.bitop : bsf;
 
 	alias LengthType = ubyte;
 	alias N = FatNodeInfo!(ItemNode.sizeof, 1, 64, LengthType.sizeof);

src/containers/internal/hash.d

@@ -44,40 +44,27 @@ else
  */
 size_t hashToIndex(const size_t hash, const size_t len) pure nothrow @nogc @safe
 {
-	import core.bitop : bsr;
-
 	// This magic number taken from
 	// https://probablydance.com/2018/06/16/fibonacci-hashing-the-optimization-that-the-world-forgot-or-a-better-alternative-to-integer-modulo/
 	//
 	// It's amazing how much faster this makes the hash data structures
 	// when faced with low quality hash functions.
-	version (D_InlineAsm_X86_64)
+	static if (size_t.sizeof == 8)
+		enum ulong magic = 11_400_714_819_323_198_485UL;
+	else
+		enum uint magic = 2_654_435_769U;
+
+	if (len <= 1)
+		return 0;
+	version(LDC)
 	{
-		asm @nogc
-		{
-			naked;
-			cmp RDI, 1;
-			je one;
-			mov RAX, 11_400_714_819_323_198_485UL;
-			mul RSI;
-			tzcnt R9, RDI; // We assume here that the length is a power of two
-			mov RCX, 64;
-			sub RCX, R9;
-			shr RAX, CL;
-			ret;
-		one:
-			xor RAX, RAX;
-			ret;
-		}
+		import ldc.intrinsics : llvm_cttz;
+		return (hash * magic) >>> ((size_t.sizeof * 8) - llvm_cttz(len, true));
 	}
 	else
 	{
-		if (len <= 1)
-			return 0;
-		static if (size_t.sizeof == 8)
-			return (hash * 11_400_714_819_323_198_485UL) >>> (64 - bsr(len));
-		else
-			return (hash * 2_654_435_769U) >>> (32 - bsr(len));
+		import core.bitop : bsr;
+		return (hash * magic) >>> ((size_t.sizeof * 8) - bsr(len));
 	}
 }
 

src/containers/unrolledlist.d

@@ -252,8 +252,16 @@ struct UnrolledList(T, Allocator = Mallocator,
 	}
 	body
 	{
-		import containers.internal.backwards : bsf;
-		size_t index = bsf(_front.registry);
+		version (LDC)
+		{
+			import ldc.intrinsics : llvm_cttz;
+			size_t index = llvm_cttz(_front.registry, true);
+		}
+		else
+		{
+			import containers.internal.backwards : bsf;
+			size_t index = bsf(_front.registry);
+		}
 		T r = _front.items[index];
 		_front.markUnused(index);
 		_length--;
@@ -302,9 +310,16 @@ struct UnrolledList(T, Allocator = Mallocator,
 	}
 	body
 	{
-		import containers.internal.backwards : bsf;
-
-		immutable size_t index = bsf(_front.registry);
+		version (LDC)
+		{
+			import ldc.intrinsics : llvm_cttz;
+			immutable index = llvm_cttz(_front.registry, true);
+		}
+		else
+		{
+			import containers.internal.backwards : bsf;
+			immutable index = bsf(_front.registry);
+		}
 		return *(cast(typeof(return)*) &_front.items[index]);
 	}
 
@@ -377,13 +392,22 @@ struct UnrolledList(T, Allocator = Mallocator,
 
 		this(inout(Node)* current)
 		{
-			import containers.internal.backwards : bsf;
 			import std.format:format;
 
 			this.current = current;
 			if (current !is null)
 			{
-				index = bsf(current.registry);
+				version (LDC)
+				{
+					import ldc.intrinsics : llvm_cttz;
+					index = llvm_cttz(current.registry, true);
+				}
+				else
+				{
+					import containers.internal.backwards : bsf;
+					index = bsf(current.registry);
+				}
+
 				assert (index < nodeCapacity);
 			}
 			else
@@ -490,12 +514,22 @@ private:
 
 	static bool shouldMerge(const Node* first, const Node* second)
 	{
-		import containers.internal.backwards : popcnt;
-
 		if (first is null || second is null)
 			return false;
-		immutable f = popcnt(first.registry);
-		immutable s = popcnt(second.registry);
+		version (LDC)
+		{
+			import ldc.intrinsics : llvm_ctpop;
+
+			immutable f = llvm_ctpop(first.registry);
+			immutable s = llvm_ctpop(second.registry);
+		}
+		else
+		{
+			import containers.internal.backwards : popcnt;
+
+			immutable f = popcnt(first.registry);
+			immutable s = popcnt(second.registry);
+		}
 		return f + s <= nodeCapacity;
 	}
 
@@ -508,7 +542,6 @@ private:
 	}
 	body
 	{
-		import containers.internal.backwards : bsf;
 		size_t i;
 		ContainerStorageType!T[nodeCapacity] temp;
 		foreach (j; 0 .. nodeCapacity)
@@ -529,11 +562,20 @@ private:
 	{
 		size_t nextAvailableIndex() const nothrow pure @safe @nogc
 		{
-			import containers.internal.backwards : bsf;
 			static if (BookkeepingType.sizeof < uint.sizeof)
-				return bsf(~(cast(uint) registry));
+				immutable uint notReg = ~(cast(uint) registry);
+			else
+				immutable uint notReg = ~registry;
+			version (LDC)
+			{
+				import ldc.intrinsics : llvm_cttz;
+				return llvm_cttz(notReg, true);
+			}
 			else
-				return bsf(~registry);
+			{
+				import containers.internal.backwards : bsf;
+				return bsf(notReg);
+			}
 		}
 
 		void markUsed(size_t index) nothrow pure @safe @nogc