Make short string hashing 30% faster by splitting Hash::hash_end from Hash::hash

src/liballoc/arc.rs

@@ -892,6 +892,10 @@ impl<T: ?Sized + Hash> Hash for Arc<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         (**self).hash(state)
     }
+
+    fn hash_end<H: Hasher>(&self, state: &mut H) {
+        (**self).hash_end(state)
+    }
 }
 
 #[cfg(test)]

src/liballoc/boxed.rs

@@ -373,6 +373,10 @@ impl<T: ?Sized + Hash> Hash for Box<T> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         (**self).hash(state);
     }
+
+    fn hash_end<H: hash::Hasher>(&self, state: &mut H) {
+        (**self).hash_end(state);
+    }
 }
 
 impl Box<Any> {

src/liballoc/lib.rs

@@ -82,6 +82,7 @@
 #![feature(core_slice_ext)]
 #![feature(custom_attribute)]
 #![feature(fundamental)]
+// #![feature(hash_end)]
 #![feature(lang_items)]
 #![feature(no_std)]
 #![feature(nonzero)]

src/liballoc/rc.rs

@@ -678,6 +678,10 @@ impl<T: ?Sized+Hash> Hash for Rc<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         (**self).hash(state);
     }
+
+    fn hash_end<H: Hasher>(&self, state: &mut H) {
+        (**self).hash_end(state);
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

src/libcollections/borrow.rs

@@ -232,6 +232,11 @@ impl<'a, B: ?Sized> Hash for Cow<'a, B> where B: Hash + ToOwned
     fn hash<H: Hasher>(&self, state: &mut H) {
         Hash::hash(&**self, state)
     }
+
+    #[inline]
+    fn hash_end<H: Hasher>(&self, state: &mut H) {
+        Hash::hash_end(&**self, state)
+    }
 }
 
 /// Trait for moving into a `Cow`.

src/libcollections/btree/map.rs

@@ -889,6 +889,11 @@ impl<'a, K: Ord + Copy, V: Copy> Extend<(&'a K, &'a V)> for BTreeMap<K, V> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<K: Hash, V: Hash> Hash for BTreeMap<K, V> {
     fn hash<H: Hasher>(&self, state: &mut H) {
+        self.len().hash(state);
+        self.hash_end(state);
+    }
+
+    fn hash_end<H: Hasher>(&self, state: &mut H) {
         for elt in self {
             elt.hash(state);
         }

src/libcollections/lib.rs

@@ -45,6 +45,7 @@
 #![feature(core_str_ext)]
 #![feature(fmt_internals)]
 #![feature(fmt_radix)]
+// #![feature(hash_end)]
 #![feature(heap_api)]
 #![feature(iter_order)]
 #![feature(iter_arith)]

src/libcollections/linked_list.rs

@@ -963,6 +963,10 @@ impl<A: fmt::Debug> fmt::Debug for LinkedList<A> {
 impl<A: Hash> Hash for LinkedList<A> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.len().hash(state);
+        self.hash_end(state);
+    }
+
+    fn hash_end<H: Hasher>(&self, state: &mut H) {
         for elt in self {
             elt.hash(state);
         }

src/libcollections/string.rs

@@ -1033,6 +1033,11 @@ impl hash::Hash for String {
     fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
         (**self).hash(hasher)
     }
+
+    #[inline]
+    fn hash_end<H: hash::Hasher>(&self, hasher: &mut H) {
+        (**self).hash_end(hasher)
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

src/libcollections/vec.rs

@@ -1098,6 +1098,11 @@ impl<T: Hash> Hash for Vec<T> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         Hash::hash(&**self, state)
     }
+
+    #[inline]
+    fn hash_end<H: hash::Hasher>(&self, state: &mut H) {
+        Hash::hash_end(&**self, state)
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

src/libcollections/vec_deque.rs

@@ -1696,6 +1696,10 @@ impl<A: Ord> Ord for VecDeque<A> {
 impl<A: Hash> Hash for VecDeque<A> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.len().hash(state);
+        self.hash_end(state);
+    }
+
+    fn hash_end<H: Hasher>(&self, state: &mut H) {
         for elt in self {
             elt.hash(state);
         }

src/libcore/array.rs

@@ -106,6 +106,10 @@ macro_rules! array_impls {
                 fn hash<H: hash::Hasher>(&self, state: &mut H) {
                     Hash::hash(&self[..], state)
                 }
+
+                fn hash_end<H: hash::Hasher>(&self, state: &mut H) {
+                    Hash::hash_end(&self[..], state)
+                }
             }
 
             #[stable(feature = "rust1", since = "1.0.0")]

src/libcore/hash/mod.rs

@@ -107,6 +107,17 @@ pub trait Hash {
             piece.hash(state);
         }
     }
+
+    // FIXME: This should be unstable, but doing so breaks deriving
+    // #[unstable(feature = "hash_end", reason = "recently added", issue = "0")]
+
+    /// Feeds this value into the state given, assuming it will be the last
+    /// value fed before finishing the hash.  This means that there is no need
+    /// to write a size or sentinel to separate this value from what follows.
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn hash_end<H: Hasher>(&self, state: &mut H) {
+        self.hash(state);
+    }
 }
 
 /// A trait which represents the ability to hash an arbitrary stream of bytes.
@@ -246,6 +257,10 @@ mod impls {
             state.write(self.as_bytes());
             state.write_u8(0xff)
         }
+
+        fn hash_end<H: Hasher>(&self, state: &mut H) {
+            state.write(self.as_bytes());
+        }
     }
 
     macro_rules! impl_hash_tuple {
@@ -256,13 +271,21 @@ mod impls {
             }
         );
 
-        ( $($name:ident)+) => (
+        ( $last:ident $($name:ident)*) => (
             #[stable(feature = "rust1", since = "1.0.0")]
-            impl<$($name: Hash),*> Hash for ($($name,)*) {
+            impl<$($name: Hash,)* $last: Hash> Hash for ($($name,)*$last,) {
                 #[allow(non_snake_case)]
                 fn hash<S: Hasher>(&self, state: &mut S) {
-                    let ($(ref $name,)*) = *self;
+                    let ($(ref $name,)* ref $last,) = *self;
+                    $($name.hash(state);)*
+                    $last.hash(state);
+                }
+
+                #[allow(non_snake_case)]
+                fn hash_end<S: Hasher>(&self, state: &mut S) {
+                    let ($(ref $name,)* ref $last,) = *self;
                     $($name.hash(state);)*
+                    $last.hash_end(state);
                 }
             }
         );
@@ -288,6 +311,10 @@ mod impls {
             self.len().hash(state);
             Hash::hash_slice(self, state)
         }
+
+        fn hash_end<H: Hasher>(&self, state: &mut H) {
+            Hash::hash_slice(self, state)
+        }
     }
 
 
@@ -296,13 +323,21 @@ mod impls {
         fn hash<H: Hasher>(&self, state: &mut H) {
             (**self).hash(state);
         }
+
+        fn hash_end<H: Hasher>(&self, state: &mut H) {
+            (**self).hash_end(state);
+        }
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]
     impl<'a, T: ?Sized + Hash> Hash for &'a mut T {
         fn hash<H: Hasher>(&self, state: &mut H) {
             (**self).hash(state);
         }
+
+        fn hash_end<H: Hasher>(&self, state: &mut H) {
+            (**self).hash_end(state);
+        }
     }
 
     #[stable(feature = "rust1", since = "1.0.0")]

src/libcoretest/hash/mod.rs

@@ -41,6 +41,12 @@ fn test_writer_hasher() {
         s.finish()
     }
 
+    fn hash_end<T: Hash>(t: &T) -> u64 {
+        let mut s = MyHasher { hash: 0 };
+        t.hash_end(&mut s);
+        s.finish()
+    }
+
     assert_eq!(hash(&()), 0);
 
     assert_eq!(hash(&5_u8), 5);
@@ -78,6 +84,13 @@ fn test_writer_hasher() {
 
     let ptr = 5_usize as *mut i32;
     assert_eq!(hash(&ptr), 5);
+
+    assert_eq!(hash_end(&5_u32), 5);
+    assert_eq!(hash_end(&s), 97);
+    assert_eq!(hash_end(&("a", "b")), 97 + 98 + 0xFF);
+    assert_eq!(hash_end(&(42u8, "a")), 42 + 97);
+    assert_eq!(hash_end(&("a", 42u8)), 97 + 0xFF + 42);
+    assert_eq!(hash_end(&&s), 97);
 }
 
 struct Custom { hash: u64 }

src/librustc/lib.rs

@@ -36,6 +36,7 @@
 #![feature(dynamic_lib)]
 #![feature(enumset)]
 #![feature(fs_canonicalize)]
+// #![feature(hash_end)]
 #![feature(hashmap_hasher)]
 #![feature(into_cow)]
 #![feature(iter_cmp)]

src/librustc/middle/ty/context.rs

@@ -692,6 +692,10 @@ impl<'tcx> Hash for InternedTy<'tcx> {
     fn hash<H: Hasher>(&self, s: &mut H) {
         self.ty.sty.hash(s)
     }
+
+    fn hash_end<H: Hasher>(&self, s: &mut H) {
+        self.ty.sty.hash_end(s)
+    }
 }
 
 impl<'tcx> Borrow<TypeVariants<'tcx>> for InternedTy<'tcx> {

src/libstd/collections/hash/table.rs

@@ -148,7 +148,7 @@ pub fn make_hash<T: ?Sized, S>(hash_state: &S, t: &T) -> SafeHash
     where T: Hash, S: HashState
 {
     let mut state = hash_state.hasher();
-    t.hash(&mut state);
+    t.hash_end(&mut state);
     // We need to avoid 0 in order to prevent collisions with
     // EMPTY_HASH. We can maintain our precious uniform distribution
     // of initial indexes by unconditionally setting the MSB,

src/libstd/ffi/os_str.rs

@@ -211,6 +211,11 @@ impl Hash for OsString {
     fn hash<H: Hasher>(&self, state: &mut H) {
         (&**self).hash(state)
     }
+
+    #[inline]
+    fn hash_end<H: Hasher>(&self, state: &mut H) {
+        (&**self).hash_end(state)
+    }
 }
 
 impl OsStr {
@@ -348,6 +353,11 @@ impl Hash for OsStr {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.bytes().hash(state)
     }
+
+    #[inline]
+    fn hash_end<H: Hasher>(&self, state: &mut H) {
+        self.bytes().hash(state)
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

src/libstd/lib.rs

@@ -222,6 +222,7 @@
 #![feature(core_simd)]
 #![feature(drain)]
 #![feature(fnbox)]
+// #![feature(hash_end)]
 #![feature(heap_api)]
 #![feature(int_error_internals)]
 #![feature(into_cow)]

src/libsyntax/ext/deriving/hash.rs

@@ -42,29 +42,48 @@ pub fn expand_deriving_hash(cx: &mut ExtCtxt,
                                   vec![path_std!(cx, core::hash::Hasher)])],
                 },
                 explicit_self: borrowed_explicit_self(),
-                args: vec!(Ptr(Box::new(Literal(arg)), Borrowed(None, MutMutable))),
+                args: vec!(Ptr(Box::new(Literal(arg.clone())), Borrowed(None, MutMutable))),
                 ret_ty: nil_ty(),
                 attributes: vec![],
                 is_unsafe: false,
                 combine_substructure: combine_substructure(Box::new(|a, b, c| {
-                    hash_substructure(a, b, c)
+                    hash_substructure(a, b, c, false)
                 }))
-            }
+            },
+            MethodDef {
+                name: "hash_end",
+                generics: LifetimeBounds {
+                    lifetimes: Vec::new(),
+                    bounds: vec![("__H",
+                                  vec![path_std!(cx, core::hash::Hasher)])],
+                },
+                explicit_self: borrowed_explicit_self(),
+                args: vec!(Ptr(Box::new(Literal(arg.clone())), Borrowed(None, MutMutable))),
+                ret_ty: nil_ty(),
+                attributes: vec![],
+                is_unsafe: false,
+                combine_substructure: combine_substructure(Box::new(|a, b, c| {
+                    hash_substructure(a, b, c, true)
+                }))
+            },
         ),
         associated_types: Vec::new(),
     };
 
     hash_trait_def.expand(cx, mitem, item, push);
 }
 
-fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
+fn hash_substructure(cx: &mut ExtCtxt,
+                     trait_span: Span,
+                     substr: &Substructure,
+                     is_end: bool) -> P<Expr> {
     let state_expr = match (substr.nonself_args.len(), substr.nonself_args.get(0)) {
         (1, Some(o_f)) => o_f,
         _ => cx.span_bug(trait_span, "incorrect number of arguments in `derive(Hash)`")
     };
-    let call_hash = |span, thing_expr| {
+    let call_hash = |span, thing_expr, use_end| {
         let hash_path = {
-            let strs = cx.std_path(&["hash", "Hash", "hash"]);
+            let strs = cx.std_path(&["hash", "Hash", if use_end { "hash_end" } else { "hash" }]);
 
             cx.expr_path(cx.path_global(span, strs))
         };
@@ -84,15 +103,15 @@ fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
                 None => cx.expr_usize(trait_span, index)
             };
 
-            stmts.push(call_hash(trait_span, discriminant));
+            stmts.push(call_hash(trait_span, discriminant, false));
 
             fs
         }
         _ => cx.span_bug(trait_span, "impossible substructure in `derive(Hash)`")
     };
 
-    for &FieldInfo { ref self_, span, .. } in fields {
-        stmts.push(call_hash(span, self_.clone()));
+    for (index, &FieldInfo { ref self_, span, .. }) in fields.iter().enumerate() {
+        stmts.push(call_hash(span, self_.clone(), is_end && index == fields.len() - 1));
     }
 
     cx.expr_block(cx.block(trait_span, stmts, None))

src/libsyntax/lib.rs

@@ -28,6 +28,7 @@
 #![feature(associated_consts)]
 #![feature(drain)]
 #![feature(filling_drop)]
+// #![feature(hash_end)]
 #![feature(libc)]
 #![feature(ref_slice)]
 #![feature(rustc_private)]