Hash String and ByteArray in chunks

Instead of hashing these values byte by byte, we can hash them in chunks
of 8/4/2 bytes, only hashing the remainder on a per byte basis.
Depending on the size of the input this can improve performance by up to
4-5 times.

Changelog: performance

Author: yorickpeterse

std/src/std/byte_array.inko

@@ -8,7 +8,7 @@ import std.hash (Hash, Hasher)
 import std.iter (Stream)
 import std.option (Option)
 import std.ptr
-import std.string (Bytes, IntoString, ToString)
+import std.string (Bytes, IntoString, ToString, hash_bytes)
 
 fn extern inko_byte_array_new(state: Pointer[UInt8]) -> ByteArray
 
@@ -728,7 +728,7 @@ impl Clone for ByteArray {
 
 impl Hash for ByteArray {
   fn pub hash[H: mut + Hasher](hasher: mut H) {
-    iter.each(fn (v) { hasher.write(v) })
+    hash_bytes(self, hasher)
   }
 }
 

std/src/std/string.inko

@@ -105,6 +105,43 @@ fn padding(string: String, chars: Int, pad_to: Int) -> String {
   }
 }
 
+fn hash_bytes[T: Bytes, H: mut + Hasher](bytes: ref T, hasher: mut H) {
+  let mut len = bytes.size
+  let mut cur = bytes.to_pointer
+
+  len.hash(hasher)
+
+  while len > 8 {
+    let val = (cur as Pointer[UInt64]).0 as Int
+
+    val.hash(hasher)
+    cur = ptr.add(cur, 8)
+    len -= 8
+  }
+
+  while len > 4 {
+    let val = (cur as Pointer[UInt32]).0 as Int
+
+    val.hash(hasher)
+    cur = ptr.add(cur, 4)
+    len -= 4
+  }
+
+  while len > 2 {
+    let val = (cur as Pointer[UInt16]).0 as Int
+
+    val.hash(hasher)
+    cur = ptr.add(cur, 2)
+    len -= 2
+  }
+
+  while len > 0 {
+    (cur.0 as Int).hash(hasher)
+    cur = ptr.add(cur, 1)
+    len -= 1
+  }
+}
+
 # A type that can be moved into a `String`.
 trait pub IntoString {
   # Moves `self` into a `String`.
@@ -855,12 +892,7 @@ impl Equal for String {
 
 impl Hash for String {
   fn pub hash[H: mut + Hasher](hasher: mut H) {
-    let mut index = 0
-
-    while index < size {
-      hasher.write(byte_unchecked(index))
-      index += 1
-    }
+    hash_bytes(self, hasher)
   }
 }
 

std/test/std/test_byte_array.inko

@@ -312,8 +312,24 @@ fn pub tests(t: mut Tests) {
   })
 
   t.test('ByteArray.hash', fn (t) {
-    t.equal(hash(ByteArray.from_array([10])), hash(ByteArray.from_array([10])))
-    t.not_equal(hash(ByteArray.from_array([10, 20])), hash(ByteArray.new))
+    [
+      'a'.to_byte_array,
+      'aa'.to_byte_array,
+      'aaa'.to_byte_array,
+      'aaaa'.to_byte_array,
+      'aaaa'.to_byte_array,
+      'aaaaa'.to_byte_array,
+      'aaaaaa'.to_byte_array,
+      'aaaaaaa'.to_byte_array,
+      'aaaaaaaa'.to_byte_array,
+      'aaaaaaaaa'.to_byte_array,
+      'aaaaaaaaaa'.to_byte_array,
+      'aaaaaaaaaaa'.to_byte_array,
+    ]
+      .into_iter
+      .each(fn (v) { t.equal(hash(v), hash(v)) })
+
+    t.not_equal(hash('hello'.to_byte_array), hash('world'.to_byte_array))
   })
 
   t.test('ByteArray.contains?', fn (t) {

std/test/std/test_string.inko

@@ -269,7 +269,26 @@ fn pub tests(t: mut Tests) {
     t.not_equal('aaaaaaaaa', 'aaaaaaaab')
   })
 
-  t.test('String.hash', fn (t) { t.equal(hash('foo'), hash('foo')) })
+  t.test('String.hash', fn (t) {
+    [
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'aaaa',
+      'aaaaa',
+      'aaaaaa',
+      'aaaaaaa',
+      'aaaaaaaa',
+      'aaaaaaaaa',
+      'aaaaaaaaaa',
+      'aaaaaaaaaaa',
+    ]
+      .into_iter
+      .each(fn (v) { t.equal(hash(v), hash(v)) })
+
+    t.not_equal(hash('hello'), hash('world'))
+  })
 
   t.test('String.+', fn (t) {
     t.equal('foo' + 'bar', 'foobar')