diff --git a/DDCore/include/Parsers/Primitives.h b/DDCore/include/Parsers/Primitives.h
index 20afb2b27b169093466400cb6ad41c91efeb541a..77230c610321d315150bac8f8a575d04e72bd1ad 100644
--- a/DDCore/include/Parsers/Primitives.h
+++ b/DDCore/include/Parsers/Primitives.h
@@ -25,6 +25,7 @@
#include <string_view>
#endif
#include <limits>
+#include <cstdint>
#include <typeinfo>
#include <algorithm>
@@ -105,15 +106,28 @@ namespace dd4hep {
/// DD4hep internal namespace declaration for utilities and implementation details
namespace detail {
- /// We need it so often: one-at-time 64 bit hash function
+ /// 64 bit hash function
+ unsigned long long int hash64(const void* key, std::size_t len);
+ /// 64 bit hash function
unsigned long long int hash64(const char* key);
+ /// 64 bit hash function
unsigned long long int hash64(const std::string& key);
- template <typename T> unsigned long long int typeHash64() {
- static unsigned long long int code = hash64(typeid(T).name());
- return code;
- }
- /// We need it so often: one-at-time 32 bit hash function
+ /// 32 bit hash function
+ inline unsigned int hash32(const void* key, std::size_t len) {
+ unsigned int hash = 0;
+ const unsigned char* k = (const unsigned char*)key;
+ for (; --len; k++) {
+ hash += *k;
+ hash += (hash << 10);
+ hash ^= (hash >> 6);
+ }
+ hash += (hash << 3);
+ hash ^= (hash >> 11);
+ hash += (hash << 15);
+ return hash;
+ }
+ /// 32 bit hash function
inline unsigned int hash32(const char* key) {
unsigned int hash = 0;
const char* k = key;
@@ -123,14 +137,37 @@ namespace dd4hep {
hash ^= (hash >> 6);
}
hash += (hash << 3);
- hash ^= (hash >> 11); hash += (hash << 15);
+ hash ^= (hash >> 11);
+ hash += (hash << 15);
return hash;
}
-
+ /// 32 bit hash function
inline unsigned int hash32(const std::string& key) {
return hash32(key.c_str());
}
+ /// 16 bit hash function
+ unsigned short hash16(const void* key, std::size_t len);
+ /// 16 bit hash function
+ inline unsigned short hash16(const std::string& key) {
+ return hash16(key.c_str(), key.length());
+ }
+
+ /// 8 bit hash function
+ unsigned char hash8(const char* key);
+ /// 8 bit hash function
+ unsigned char hash8(const void* key, std::size_t len);
+ /// 8 bit hash function
+ inline unsigned short hash8(const std::string& key) {
+ return hash8(key.c_str(), key.length());
+ }
+
+ /// 64 bit type hash function
+ template <typename T> unsigned long long int typeHash64() {
+ static unsigned long long int code = hash64(typeid(T).name());
+ return code;
+ }
+
template <typename T> T reverseBits(T num) {
static constexpr size_t NO_OF_BITS = sizeof(num) * 8 - 1;
static constexpr T _zero = 0;
diff --git a/DDCore/src/Primitives.cpp b/DDCore/src/Primitives.cpp
index 29773362dc91cd9932f8d6dfa2eb866444d6c5ba..e0e0f334b846bcfce2dc2f1309900cf598265fb4 100644
--- a/DDCore/src/Primitives.cpp
+++ b/DDCore/src/Primitives.cpp
@@ -142,6 +142,38 @@ namespace {
static constexpr unsigned long long int doByte(unsigned long long int hash,unsigned char val)
{ return (hash ^ val) * 1099511628211ull; }
};
+
+ static unsigned char crc8_table[] =
+ { 0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
+ 157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220,
+ 35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98,
+ 190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
+ 70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7,
+ 219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154,
+ 101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36,
+ 248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185,
+ 140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
+ 17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
+ 175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
+ 50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
+ 202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139,
+ 87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
+ 233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
+ 116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53
+ };
+ /// Original Pearson algorithm
+ static unsigned char pearson_hash(const void *data, size_t len) {
+ const char *s = (const char*)data;
+ unsigned char c = 0;
+ while (--len) c = crc8_table[c ^ *s++];
+ return c;
+ }
+ static unsigned char pearson_hash(const char *data) {
+ const char *s = data;
+ unsigned char c = 0;
+ while (*s) c = crc8_table[c ^ *s++];
+ return c;
+ }
}
/// Convert volumeID to string format (016X)
@@ -151,20 +183,43 @@ std::string dd4hep::volumeID(VolumeID vid) {
return text;
}
-/// We need it so often: one-at-time 64 bit hash function
+/// 64 bit hash function
unsigned long long int dd4hep::detail::hash64(const char* key) {
- //return murmur_hash_64(key, strlen(key));
unsigned char* str = (unsigned char*)key;
unsigned long long int hash = FNV1a_64::hashinit;
for ( ; *str; ++str) hash = FNV1a_64::doByte(hash, *str);
return hash;
}
+/// 64 bit hash function
+unsigned long long int dd4hep::detail::hash64(const void* key, std::size_t len) {
+ const unsigned char* str = (const unsigned char*)key;
+ unsigned long long int hash = FNV1a_64::hashinit;
+ for ( ; --len; ++str) hash = FNV1a_64::doByte(hash, *str);
+ return hash;
+}
+
+/// 64 bit hash function
unsigned long long int dd4hep::detail::hash64(const std::string& key) {
- //return murmur_hash_64(key.data(), key.length());
return std::accumulate(begin(key),end(key),FNV1a_64::hashinit,FNV1a_64::doByte);
}
+/// 16 bit hash function
+unsigned short dd4hep::detail::hash16(const void* key, std::size_t len) {
+ unsigned int value = hash32(key, len);
+ return *(unsigned short*)&value;
+}
+
+/// 8 bit hash function
+unsigned char dd4hep::detail::hash8(const void* key, std::size_t len) {
+ return pearson_hash(key, len);
+}
+
+/// 8 bit hash function
+unsigned char dd4hep::detail::hash8(const char* key) {
+ return pearson_hash(key);
+}
+
/// Replace all occurrencies of a string
std::string dd4hep::detail::str_replace(const std::string& str,
const std::string& pattern,