From f46b678bca862b17a246b80f1d07aa06e1317bc0 Mon Sep 17 00:00:00 2001 From: "nasko@chromium.org" Date: Thu, 20 Jun 2013 17:26:47 +0000 Subject: Move hash_pair.h from cc/base into base/. BUG= Review URL: https://chromiumcodereview.appspot.com/17094004 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@207475 0039d316-1c4b-4281-b951-d872f2087c98 --- base/base.gyp | 1 + base/containers/hash_tables.h | 145 ++++++++++++++++++++++++++++++++ base/containers/hash_tables_unittest.cc | 53 ++++++++++++ 3 files changed, 199 insertions(+) create mode 100644 base/containers/hash_tables_unittest.cc (limited to 'base') diff --git a/base/base.gyp b/base/base.gyp index 731bbf9..a1c1156b 100644 --- a/base/base.gyp +++ b/base/base.gyp @@ -463,6 +463,7 @@ 'callback_unittest.nc', 'cancelable_callback_unittest.cc', 'command_line_unittest.cc', + 'containers/hash_tables_unittest.cc', 'containers/linked_list_unittest.cc', 'containers/mru_cache_unittest.cc', 'containers/small_map_unittest.cc', diff --git a/base/containers/hash_tables.h b/base/containers/hash_tables.h index 13d413b..0615e0d 100644 --- a/base/containers/hash_tables.h +++ b/base/containers/hash_tables.h @@ -21,6 +21,9 @@ #ifndef BASE_CONTAINERS_HASH_TABLES_H_ #define BASE_CONTAINERS_HASH_TABLES_H_ +#include + +#include "base/basictypes.h" #include "base/strings/string16.h" #include "build/build_config.h" @@ -117,4 +120,146 @@ using BASE_HASH_NAMESPACE::hash_multiset; using BASE_HASH_NAMESPACE::hash_set; } + +// Implement methods for hashing a pair of integers, so they can be used as +// keys in STL containers. + +#if defined(COMPILER_MSVC) + +#define DEFINE_PAIR_HASH_FUNCTION_START(type1, type2) \ + template<> \ + inline std::size_t hash_value >( \ + const std::pair& value) + +#define DEFINE_PAIR_HASH_FUNCTION_END() + +#elif defined(COMPILER_GCC) + +#define DEFINE_PAIR_HASH_FUNCTION_START(type1, type2) \ + template<> \ + struct hash > { \ + std::size_t operator()(std::pair value) const + +#define DEFINE_PAIR_HASH_FUNCTION_END() \ + }; + +#else +#error define DEFINE_PAIR_HASH_FUNCTION_START for your compiler +#endif // COMPILER + +namespace BASE_HASH_NAMESPACE { + +// Implement hashing for pairs of at-most 32 bit integer values. +// When size_t is 32 bits, we turn the 64-bit hash code into 32 bits by using +// multiply-add hashing. This algorithm, as described in +// Theorem 4.3.3 of the thesis "Über die Komplexität der Multiplikation in +// eingeschränkten Branchingprogrammmodellen" by Woelfel, is: +// +// h32(x32, y32) = (h64(x32, y32) * rand_odd64 + rand16 * 2^16) % 2^64 / 2^32 +// +// Contact danakj@chromium.org for any questions. +#define DEFINE_32BIT_PAIR_HASH(type1, type2) \ + DEFINE_PAIR_HASH_FUNCTION_START(type1, type2) { \ + uint64 first = value.first; \ + uint32 second = value.second; \ + uint64 hash64 = (first << 32) | second; \ + \ + if (sizeof(std::size_t) >= sizeof(uint64)) \ + return static_cast(hash64); \ + \ + uint64 odd_random = 481046412LL << 32 | 1025306954LL; \ + uint32 shift_random = 10121U << 16; \ + \ + hash64 = hash64 * odd_random + shift_random; \ + std::size_t high_bits = static_cast( \ + hash64 >> (sizeof(uint64) - sizeof(std::size_t))); \ + return high_bits; \ + } \ + DEFINE_PAIR_HASH_FUNCTION_END(); + +DEFINE_32BIT_PAIR_HASH(int16, int16); +DEFINE_32BIT_PAIR_HASH(int16, uint16); +DEFINE_32BIT_PAIR_HASH(int16, int32); +DEFINE_32BIT_PAIR_HASH(int16, uint32); +DEFINE_32BIT_PAIR_HASH(uint16, int16); +DEFINE_32BIT_PAIR_HASH(uint16, uint16); +DEFINE_32BIT_PAIR_HASH(uint16, int32); +DEFINE_32BIT_PAIR_HASH(uint16, uint32); +DEFINE_32BIT_PAIR_HASH(int32, int16); +DEFINE_32BIT_PAIR_HASH(int32, uint16); +DEFINE_32BIT_PAIR_HASH(int32, int32); +DEFINE_32BIT_PAIR_HASH(int32, uint32); +DEFINE_32BIT_PAIR_HASH(uint32, int16); +DEFINE_32BIT_PAIR_HASH(uint32, uint16); +DEFINE_32BIT_PAIR_HASH(uint32, int32); +DEFINE_32BIT_PAIR_HASH(uint32, uint32); + +#undef DEFINE_32BIT_PAIR_HASH + +// Implement hashing for pairs of up-to 64-bit integer values. +// We use the compound integer hash method to produce a 64-bit hash code, by +// breaking the two 64-bit inputs into 4 32-bit values: +// http://opendatastructures.org/versions/edition-0.1d/ods-java/node33.html#SECTION00832000000000000000 +// Then we reduce our result to 32 bits if required, similar to above. +#define DEFINE_64BIT_PAIR_HASH(type1, type2) \ + DEFINE_PAIR_HASH_FUNCTION_START(type1, type2) { \ + uint32 short_random1 = 842304669U; \ + uint32 short_random2 = 619063811U; \ + uint32 short_random3 = 937041849U; \ + uint32 short_random4 = 3309708029U; \ + \ + uint64 value1 = value.first; \ + uint64 value2 = value.second; \ + uint32 value1a = static_cast(value1 & 0xffffffff); \ + uint32 value1b = static_cast((value1 >> 32) & 0xffffffff); \ + uint32 value2a = static_cast(value2 & 0xffffffff); \ + uint32 value2b = static_cast((value2 >> 32) & 0xffffffff); \ + \ + uint64 product1 = static_cast(value1a) * short_random1; \ + uint64 product2 = static_cast(value1b) * short_random2; \ + uint64 product3 = static_cast(value2a) * short_random3; \ + uint64 product4 = static_cast(value2b) * short_random4; \ + \ + uint64 hash64 = product1 + product2 + product3 + product4; \ + \ + if (sizeof(std::size_t) >= sizeof(uint64)) \ + return static_cast(hash64); \ + \ + uint64 odd_random = 1578233944LL << 32 | 194370989LL; \ + uint32 shift_random = 20591U << 16; \ + \ + hash64 = hash64 * odd_random + shift_random; \ + std::size_t high_bits = static_cast( \ + hash64 >> (sizeof(uint64) - sizeof(std::size_t))); \ + return high_bits; \ + } \ + DEFINE_PAIR_HASH_FUNCTION_END(); + +DEFINE_64BIT_PAIR_HASH(int16, int64); +DEFINE_64BIT_PAIR_HASH(int16, uint64); +DEFINE_64BIT_PAIR_HASH(uint16, int64); +DEFINE_64BIT_PAIR_HASH(uint16, uint64); +DEFINE_64BIT_PAIR_HASH(int32, int64); +DEFINE_64BIT_PAIR_HASH(int32, uint64); +DEFINE_64BIT_PAIR_HASH(uint32, int64); +DEFINE_64BIT_PAIR_HASH(uint32, uint64); +DEFINE_64BIT_PAIR_HASH(int64, int16); +DEFINE_64BIT_PAIR_HASH(int64, uint16); +DEFINE_64BIT_PAIR_HASH(int64, int32); +DEFINE_64BIT_PAIR_HASH(int64, uint32); +DEFINE_64BIT_PAIR_HASH(int64, int64); +DEFINE_64BIT_PAIR_HASH(int64, uint64); +DEFINE_64BIT_PAIR_HASH(uint64, int16); +DEFINE_64BIT_PAIR_HASH(uint64, uint16); +DEFINE_64BIT_PAIR_HASH(uint64, int32); +DEFINE_64BIT_PAIR_HASH(uint64, uint32); +DEFINE_64BIT_PAIR_HASH(uint64, int64); +DEFINE_64BIT_PAIR_HASH(uint64, uint64); + +#undef DEFINE_64BIT_PAIR_HASH +} + +#undef DEFINE_PAIR_HASH_FUNCTION_START +#undef DEFINE_PAIR_HASH_FUNCTION_END + #endif // BASE_CONTAINERS_HASH_TABLES_H_ diff --git a/base/containers/hash_tables_unittest.cc b/base/containers/hash_tables_unittest.cc new file mode 100644 index 0000000..65724ec --- /dev/null +++ b/base/containers/hash_tables_unittest.cc @@ -0,0 +1,53 @@ +// Copyright 2013 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "base/containers/hash_tables.h" + +#include "base/basictypes.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace { + +class HashPairTest : public testing::Test { +}; + +#define INSERT_PAIR_TEST(Type, value1, value2) \ + { \ + Type pair(value1, value2); \ + base::hash_map map; \ + map[pair] = 1; \ + } + +// Verify that a hash_map can be constructed for pairs of integers of various +// sizes. +TEST_F(HashPairTest, IntegerPairs) { + typedef std::pair Int16Int16Pair; + typedef std::pair Int16Int32Pair; + typedef std::pair Int16Int64Pair; + + INSERT_PAIR_TEST(Int16Int16Pair, 4, 6); + INSERT_PAIR_TEST(Int16Int32Pair, 9, (1 << 29) + 378128932); + INSERT_PAIR_TEST(Int16Int64Pair, 10, + (GG_INT64_C(1) << 60) + GG_INT64_C(78931732321)); + + typedef std::pair Int32Int16Pair; + typedef std::pair Int32Int32Pair; + typedef std::pair Int32Int64Pair; + + INSERT_PAIR_TEST(Int32Int16Pair, 4, 6); + INSERT_PAIR_TEST(Int32Int32Pair, 9, (1 << 29) + 378128932); + INSERT_PAIR_TEST(Int32Int64Pair, 10, + (GG_INT64_C(1) << 60) + GG_INT64_C(78931732321)); + + typedef std::pair Int64Int16Pair; + typedef std::pair Int64Int32Pair; + typedef std::pair Int64Int64Pair; + + INSERT_PAIR_TEST(Int64Int16Pair, 4, 6); + INSERT_PAIR_TEST(Int64Int32Pair, 9, (1 << 29) + 378128932); + INSERT_PAIR_TEST(Int64Int64Pair, 10, + (GG_INT64_C(1) << 60) + GG_INT64_C(78931732321)); +} + +} // namespace -- cgit v1.1