buffered parsing of the hash, and modify the hash function slightly

Author: shwestrick

hash-table/PACKED_WEIGHTED_HASH_TABLE.sml

@@ -14,13 +14,7 @@ sig
   val size: table -> int
   val capacity: table -> int
 
-  val insertCombineWeights: table -> K.t * W.t -> unit
-  val insertCombineWeightsLimitProbes: {probes: int}
-                                       -> table
-                                       -> K.t * W.t
-                                       -> unit
-
-  val forceInsertUnique: table -> K.t * W.t -> unit
+  val insertCombineWeightsKnownHash: table -> K.t * W.t -> {hash: int} -> unit
 
   (* not safe for concurrency with insertions *)
   val lookup: table -> K.t -> W.t option

hash-table/PackedWeightedHashTable.sml

@@ -70,12 +70,11 @@ struct
     MLton.eq (old, Concurrency.casArray (arr, i) (old, new))
 
 
-  fun insertCombineWeightsLimitProbes {probes = tolerance}
-    (input as T {keys, packedWeights}) (x, v) =
+  fun insertCombineWeightsKnownHash (input as T {keys, packedWeights}) (x, v)
+    {hash = hashval} =
     let
       val n = Array.length keys
-      (* val _ = print
-        ("insertCombineWeightsLimitProbes capacity=" ^ Int.toString n ^ "\n") *)
+      val tolerance = n
 
       val j = shard ()
 
@@ -91,8 +90,6 @@ struct
           loop 0 probes
         else
           let
-            (* val _ = print
-              ("insertCombineWeightsLimitProbes.loop " ^ Int.toString i ^ "\n") *)
             val k = Array.sub (keys, i)
           in
             if K.equal (k, K.empty) then
@@ -103,50 +100,12 @@ struct
               loop (i + 1) (probes + 1)
           end
 
-      val start = (K.hash x) mod (Array.length keys)
+      val start = hashval mod (Array.length keys)
     in
       loop start 0
     end
 
 
-  fun insertCombineWeights table (x, v) =
-    insertCombineWeightsLimitProbes {probes = capacity table} table (x, v)
-
-
-  fun forceInsertUnique (T {keys, packedWeights}) (x, v) =
-    let
-      val n = Array.length keys
-      val start = (K.hash x) mod n
-
-      val j = shard ()
-
-      fun claimSlotAt i = bcas (keys, i, K.empty, x)
-
-      fun putValueAt i =
-        W.unpack_into (v, locationOfPack n packedWeights i j)
-
-      fun loop i =
-        if i >= n then
-          loop 0
-        else
-          let
-            val k = Array.sub (keys, i)
-          in
-            if K.equal (k, K.empty) then
-              if claimSlotAt i then putValueAt i else loop i
-            else if K.equal (k, x) then
-              raise DuplicateKey
-            else
-              loopNext (i + 1)
-          end
-
-      and loopNext i =
-        if i = start then raise Full else loop i
-    in
-      loop start
-    end
-
-
   fun lookup (T {keys, packedWeights, ...}) x =
     let
       val n = Array.length keys

main.sml

@@ -182,7 +182,11 @@ struct
    * Define the hash table type. We identify entries by their starting index.
    *)
 
-  structure Key: KEY =
+  structure Key:
+  sig
+    include KEY
+    val parseAndHashBuffered: buffer -> int -> buffer * int * int
+  end =
   struct
     type t = index (* int *)
 
@@ -220,7 +224,7 @@ struct
             if cursor >= definitely_stop orelse x = semicolon_id then
               acc
             else
-              loop (LargeWord.orb (LargeWord.<< (acc, 0w8), Word8.toLarge x))
+              loop (LargeWord.xorb (LargeWord.<< (acc, 0w3), Word8.toLarge x))
                 (cursor + 1)
           end
 
@@ -229,6 +233,21 @@ struct
       in
         Word64.toIntX result
       end
+
+
+    fun parseAndHashBuffered buffer start =
+      let
+        val (b, p, h) = bufferLoop buffer
+          { start = start
+          , continue = fn byte => byte <> semicolon_id
+          , z = 0w0
+          , func = fn (acc, byte) =>
+              LargeWord.xorb (LargeWord.<< (acc, 0w3), Word8.toLarge byte)
+          }
+      in
+        (b, p, Word64.toIntX h)
+      end
+
   end
 
 
@@ -332,14 +351,13 @@ struct
         else
           let
             val start = cursor
-            val (buffer, cursor) = findNextBuffered buffer semicolon_id cursor
-            val cursor = valOf cursor
+            val (buffer, cursor, h) = Key.parseAndHashBuffered buffer cursor
             val cursor = cursor + 1 (* get past the ";" *)
             val (buffer, cursor, m) = parseMeasurement buffer cursor
             val cursor = cursor + 1 (* get past the newline character *)
             val weight = {min = m, max = m, tot = m, count = 1}
           in
-            T.insertCombineWeights table (start, weight);
+            T.insertCombineWeightsKnownHash table (start, weight) {hash = h};
             loop buffer cursor stop
           end
 

timings/aware-240106-182600-after-remove-intermediate-copy.txt

@@ -1,10 +1,10 @@
 $ hyperfine --warmup 1 './main @mpl procs 144 set-affinity -- /usr3/data/1brc/measurements.txt --unsafe-no-bounds-checks'
 Benchmark 1: ./main @mpl procs 144 set-affinity -- /usr3/data/1brc/measurements.txt --unsafe-no-bounds-checks
-  Time (mean ± σ):      2.408 s ±  0.011 s    [User: 334.217 s, System: 2.892 s]
-  Range (min … max):    2.390 s …  2.422 s    10 runs
+  Time (mean ± σ):      2.342 s ±  0.020 s    [User: 324.751 s, System: 2.546 s]
+  Range (min … max):    2.317 s …  2.380 s    10 runs
 
 
 $ hyperfine --warmup 1 './main @mpl procs 144 set-affinity -- /usr3/data/1brc/measurements.txt'
 Benchmark 1: ./main @mpl procs 144 set-affinity -- /usr3/data/1brc/measurements.txt
-  Time (mean ± σ):      2.655 s ±  0.057 s    [User: 370.180 s, System: 2.765 s]
-  Range (min … max):    2.599 s …  2.772 s    10 runs
+  Time (mean ± σ):      2.443 s ±  0.018 s    [User: 339.081 s, System: 2.687 s]
+  Range (min … max):    2.417 s …  2.475 s    10 runs