Extract hash mixing logic into a common class. (#121)

Author: Ian Sturdy

opencensus/common/internal/BUILD

@@ -20,6 +20,12 @@ licenses(["notice"])  # Apache 2.0
 
 package(default_visibility = ["//opencensus:__subpackages__"])
 
+cc_library(
+    name = "hash_mix",
+    hdrs = ["hash_mix.h"],
+    copts = DEFAULT_COPTS,
+)
+
 cc_library(
     name = "random_lib",
     srcs = ["random.cc"],

opencensus/common/internal/hash_mix.h

@@ -0,0 +1,48 @@
+// Copyright 2018, OpenCensus Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPENCENSUS_COMMON_INTERNAL_HASH_MIX_H_
+#define OPENCENSUS_COMMON_INTERNAL_HASH_MIX_H_
+
+#include <cstddef>
+#include <limits>
+
+namespace opencensus {
+namespace common {
+
+// HashMix provides efficient mixing of hash values.
+class HashMix final {
+ public:
+  HashMix() : hash_(1) {}
+
+  // Mixes in another *hashed* value.
+  void Mix(std::size_t hash) {
+    // A multiplier that has been found to provide good mixing.
+    constexpr std::size_t kMul = 0xdc3eb94af8ab4c93ULL;
+    hash_ *= kMul;
+    hash_ =
+        ((hash << 19) | (hash >> (std::numeric_limits<size_t>::digits - 19))) +
+        hash;
+  }
+
+  size_t get() const { return hash_; }
+
+ private:
+  std::size_t hash_;
+};
+
+}  // namespace common
+}  // namespace opencensus
+
+#endif  // OPENCENSUS_COMMON_INTERNAL_HASH_MIX_H_

opencensus/common/internal/string_vector_hash.h

@@ -16,25 +16,22 @@
 #define OPENCENSUS_COMMON_INTERNAL_STRING_VECTOR_HASH_H_
 
 #include <functional>
-#include <limits>
 #include <string>
 #include <vector>
 
+#include "opencensus/common/internal/hash_mix.h"
+
 namespace opencensus {
 namespace common {
 
 struct StringVectorHash {
   std::size_t operator()(const std::vector<std::string>& container) const {
     std::hash<std::string> hasher;
-    size_t hash = 1;
+    HashMix mixer;
     for (const auto& elem : container) {
-      static const size_t kMul = static_cast<size_t>(0xdc3eb94af8ab4c93ULL);
-      hash *= kMul;
-      hash = ((hash << 19) |
-              (hash >> (std::numeric_limits<size_t>::digits - 19))) +
-             hasher(elem);
+      mixer.Mix(hasher(elem));
     }
-    return hash;
+    return mixer.get();
   }
 };
 

opencensus/stats/BUILD

@@ -96,6 +96,7 @@ cc_library(
     ],
     copts = DEFAULT_COPTS,
     deps = [
+        "//opencensus/common/internal:hash_mix",
         "//opencensus/common/internal:stats_object",
         "//opencensus/common/internal:string_vector_hash",
         "@com_google_absl//absl/base:core_headers",

opencensus/stats/internal/tag_set.cc

@@ -21,6 +21,7 @@
 #include <vector>
 
 #include "absl/strings/string_view.h"
+#include "opencensus/common/internal/hash_mix.h"
 
 namespace opencensus {
 namespace stats {
@@ -44,18 +45,12 @@ void TagSet::Initialize() {
   std::sort(tags_.begin(), tags_.end());
 
   std::hash<std::string> hasher;
-  hash_ = 1;
+  common::HashMix mixer;
   for (const auto& tag : tags_) {
-    static const size_t kMul = static_cast<size_t>(0xdc3eb94af8ab4c93ULL);
-    hash_ *= kMul;
-    hash_ = ((hash_ << 19) |
-             (hash_ >> (std::numeric_limits<size_t>::digits - 19))) +
-            hasher(tag.first);
-    hash_ *= kMul;
-    hash_ = ((hash_ << 19) |
-             (hash_ >> (std::numeric_limits<size_t>::digits - 19))) +
-            hasher(tag.second);
+    mixer.Mix(hasher(tag.first));
+    mixer.Mix(hasher(tag.second));
   }
+  hash_ = mixer.get();
 }
 
 std::size_t TagSet::Hash::operator()(const TagSet& tag_set) const {