Fix AMD64 inner loop with compiler-optimized unrolled pipeline

Author: janos

README.md

@@ -27,7 +27,7 @@ Alternatively, `VoteRanked` accepts a pre-ordered slice of ranks (`[][]C`), avoi
 - **Generic Ballot Ingestion**: `VoteFrom` enables voting directly from arbitrary external structures using a custom ranking function.
 - **Type transformations (`Map`)**: `Record`, `Result`, `Duel`, and `Voting` support Go method type parameters via `.Map(...)` to translate between choice identifiers (e.g. `UUID` $\leftrightarrow$ `string` $\leftrightarrow$ `int`).
 - **Standard Go iterators**: `Duels` provides a standard `iter.Seq[*Duel[C]]` iterator for range-over-func loops.
-- **Hardware SIMD Acceleration**: Uses ARM64 NEON and AMD64 AVX/SSE vector assembly kernels to accelerate inner matrix relaxation.
+- **Hardware SIMD Acceleration**: Uses ARM64 NEON vector assembly kernels and unrolled multi-core pipelines to accelerate inner matrix relaxation.
 - **Fast Winner Calculation**: `Winner` returns the election winner using an $O(N^2)$ Condorcet fast-path with fallback to full beatpath computation for cycles.
 - **Configurable numeric precision**: Pairwise preferences support generic `Number` types (`int`, `uint32`, `uint16`, etc.) for memory optimization.
 

schulze_test.go

@@ -1627,8 +1627,7 @@ func BenchmarkVoteRanked(b *testing.B) {
 	preferences := schulze.NewPreferences[int](choicesCount)
 	ranked := [][]string{{"0"}, {"1", "2"}, {"3"}}
 
-	b.ResetTimer()
-	for n := 0; n < b.N; n++ {
+	for b.Loop() {
 		if _, err := schulze.VoteRanked(preferences, choices, ranked); err != nil {
 			b.Fatal(err)
 		}

simd_amd64.go

@@ -3,19 +3,50 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !arm64 && !amd64
+//go:build !arm64
 
 package schulze
 
 import "unsafe"
 
 func relaxRowInt(rowI, rowJ unsafe.Pointer, jip int, n int) {
-	for k := 0; k < n; k++ {
-		ikp := (*int)(unsafe.Add(rowI, uintptr(k)*8))
-		jkp := (*int)(unsafe.Add(rowJ, uintptr(k)*8))
-		m := min(jip, *ikp)
-		if m > *jkp {
-			*jkp = m
+	rowISlice := unsafe.Slice((*int)(rowI), n)
+	rowJSlice := unsafe.Slice((*int)(rowJ), n)
+
+	const step = 8
+	mod := n % step
+	end := n - mod
+
+	for k := 0; k < end; k += step {
+		if m := min(jip, rowISlice[k]); m > rowJSlice[k] {
+			rowJSlice[k] = m
+		}
+		if m := min(jip, rowISlice[k+1]); m > rowJSlice[k+1] {
+			rowJSlice[k+1] = m
+		}
+		if m := min(jip, rowISlice[k+2]); m > rowJSlice[k+2] {
+			rowJSlice[k+2] = m
+		}
+		if m := min(jip, rowISlice[k+3]); m > rowJSlice[k+3] {
+			rowJSlice[k+3] = m
+		}
+		if m := min(jip, rowISlice[k+4]); m > rowJSlice[k+4] {
+			rowJSlice[k+4] = m
+		}
+		if m := min(jip, rowISlice[k+5]); m > rowJSlice[k+5] {
+			rowJSlice[k+5] = m
+		}
+		if m := min(jip, rowISlice[k+6]); m > rowJSlice[k+6] {
+			rowJSlice[k+6] = m
+		}
+		if m := min(jip, rowISlice[k+7]); m > rowJSlice[k+7] {
+			rowJSlice[k+7] = m
+		}
+	}
+
+	for k := end; k < n; k++ {
+		if m := min(jip, rowISlice[k]); m > rowJSlice[k] {
+			rowJSlice[k] = m
 		}
 	}
 }