wip try to match rust & assembly

Author: coyotte508

packages/gearhash-wasm/assembly/next-match.ts

@@ -12,9 +12,24 @@ export class MatchResult {
 export function nextMatch(buf: Uint8Array, mask: u64, hash: u64 = 0): MatchResult {
 	for (let i = 0; i < buf.length; i++) {
 		const b = buf[i];
-		hash = (hash << 1) + DEFAULT_TABLE[b];
+		// Use proper unsigned operations to match Rust's wrapping_add behavior
+		hash = ((hash << 1) as u64) + (DEFAULT_TABLE[b] as u64);
+
+		// console.log(
+		// 	"hash " +
+		// 		hash.toString(16) +
+		// 		" " +
+		// 		(hash << 1).toString(16) +
+		// 		" " +
+		// 		b.toString(16) +
+		// 		" " +
+		// 		(DEFAULT_TABLE[b] as u64).toString(16)
+		// );
+		// console.log("mask " + mask.toString(16));
+		// console.log("hash & mask " + (hash & mask).toString(16));
 
 		if ((hash & mask) == 0) {
+			// console.log("match found at position " + (i + 1).toString());
 			return { position: i + 1, hash };
 		}
 	}

packages/gearhash-wasm/tests/index.js

@@ -1,19 +1,26 @@
-import { nextMatch } from "../build/debug.js";
+import { nextMatch, nextMatches } from "../build/debug.js";
 
-// Simple deterministic RNG for reproducible results (same as Rust version)
+// Simple deterministic RNG for reproducible results (32-bit version)
 class SimpleRng {
 	constructor(seed) {
-		this.state = BigInt(seed);
+		this.state = seed;
 	}
 
-	nextU64() {
-		// Simple xorshift algorithm (same as Rust version)
-		this.state ^= this.state << 13n;
-		this.state ^= this.state >> 7n;
-		this.state ^= this.state << 17n;
+	nextU32() {
+		// Simple 32-bit xorshift algorithm (same as Rust version)
+		this.state ^= this.state << 13;
+		this.state ^= this.state >> 17;
+		this.state ^= this.state << 5;
 		return this.state;
 	}
 
+	nextU64() {
+		// Generate two 32-bit values and combine them
+		const low = this.nextU32();
+		const high = this.nextU32();
+		return (BigInt(high) << 32n) | BigInt(low);
+	}
+
 	fillBytes(dest) {
 		for (let i = 0; i < dest.length; i += 8) {
 			const value = this.nextU64();
@@ -50,38 +57,20 @@ function testGearhash() {
 	console.log("Chunk | Offset | Size | Hash");
 	console.log("------|--------|------|------------------");
 
-	while (offset < inputBuf.length) {
-		const chunkStart = offset;
-
-		const result = nextMatch(inputBuf.subarray(offset), BENCH_MASK, hash);
-		if (result.matchSize > 0) {
-			offset += result.matchSize;
-			totalProcessed += result.matchSize;
-			chunkCount += 1;
-			hash = result.hash;
+	const result = nextMatches(inputBuf, BENCH_MASK, 0);
+	const matches = [...result.matches, { position: result.remaining, hash: result.hash }];
 
-			console.log(
-				`${chunkCount.toString().padStart(5)} | ${chunkStart.toString().padStart(6)} | ${result.matchSize
-					.toString()
-					.padStart(4)} | 0x${hash.toString(16).padStart(16, "0")}`
-			);
-		} else {
-			// No more matches, process remaining bytes
-			const remaining = inputBuf.length - offset;
-			// Update hash for remaining bytes
-			for (let i = 0; i < remaining; i++) {
-				hash = ((hash << 1n) + BigInt(inputBuf[offset + i])) & 0xffffffffffffffffn;
-			}
-			totalProcessed += remaining;
-			chunkCount += 1;
+	for (const match of matches) {
+		offset += match.position;
+		totalProcessed += match.position;
+		chunkCount += 1;
+		hash = match.hash;
 
-			console.log(
-				`${chunkCount.toString().padStart(5)} | ${offset.toString().padStart(6)} | ${remaining
-					.toString()
-					.padStart(4)} | 0x${hash.toString(16).padStart(16, "0")} (final)`
-			);
-			break;
-		}
+		console.log(
+			`${chunkCount.toString().padStart(5)} | ${offset.toString().padStart(6)} | ${match.position
+				.toString()
+				.padStart(4)} | 0x${match.hash.toString(16).padStart(16, "0")}`
+		);
 	}
 
 	console.log("\nSummary:");

packages/gearhash-wasm/vendor/test_gearhash.rs

@@ -1,23 +1,30 @@
 use gearhash::{Hasher, DEFAULT_TABLE};
 
-// Simple deterministic RNG for reproducible results
+// Simple deterministic RNG for reproducible results (32-bit version)
 struct SimpleRng {
-    state: u64,
+    state: u32,
 }
 
 impl SimpleRng {
-    fn new(seed: u64) -> Self {
+    fn new(seed: u32) -> Self {
         Self { state: seed }
     }
 
-    fn next_u64(&mut self) -> u64 {
-        // Simple xorshift algorithm
+    fn next_u32(&mut self) -> u32 {
+        // Simple 32-bit xorshift algorithm
         self.state ^= self.state << 13;
-        self.state ^= self.state >> 7;
-        self.state ^= self.state << 17;
+        self.state ^= self.state >> 17;
+        self.state ^= self.state << 5;
         self.state
     }
 
+    fn next_u64(&mut self) -> u64 {
+        // Generate two 32-bit values and combine them
+        let low = self.next_u32() as u64;
+        let high = self.next_u32() as u64;
+        (high << 32) | low
+    }
+    
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         for chunk in dest.chunks_mut(8) {
             let value = self.next_u64();
@@ -28,7 +35,7 @@ impl SimpleRng {
     }
 }
 
-const BENCH_INPUT_SEED: u64 = 0xbecd17f;
+const BENCH_INPUT_SEED: u32 = 0xbecd17f;
 const BENCH_MASK: u64 = 0x0000d90003530000;
 const INPUT_SIZE: usize = 100_000;
 
@@ -64,10 +71,11 @@ fn test_gearhash() {
 
             println!("{:5} | {:6} | {:4} | 0x{:016x}", 
                 chunk_count, chunk_start, match_size, hasher.get_hash());
+
+            hasher.set_hash(0);
         } else {
             // No more matches, process remaining bytes
             let remaining = input_buf.len() - offset;
-            hasher.update(&input_buf[offset..]);
             total_processed += remaining;
             chunk_count += 1;