source: trunk/symbol_table/src/hash_strategy.hpp @ 2078

Last change on this file since 2078 was 2078, checked in by ksherdy, 7 years ago

Add.

File size: 10.2 KB
Line 
1#ifndef HASH_STRATEGY_HPP
2#define HASH_STRATEGY_HPP
3
4#define MAX_HASH_BITS 17 // maximum length specific hash_strategy
5
6enum group_strategy { id, div2, logbase2 };
7
8/* Hash Strategy */
9class hash_strategy {
10public:
11    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits);
12    static IDISA_ALWAYS_INLINE uint32_t max_hashsize();
13protected:
14    hash_strategy() {}
15};
16
17/* Hash functions specialized on symbol length. */
18template<uint32_t LGTH, int GROUP_STRATEGY>
19class hash_strategy_t: public hash_strategy {
20public:
21    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits);
22    static IDISA_ALWAYS_INLINE uint32_t max_hashsize();
23};
24
25///////////////////////////////////////////////////////////////////////////////
26// Bit Space Hash
27///////////////////////////////////////////////////////////////////////////////
28template<> class hash_strategy_t<0,id> {
29public:
30    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
31        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits); // expect h0 as hash bit stream
32    }
33    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return MAX_HASH_BITS; }
34};
35
36///////////////////////////////////////////////////////////////////////////////
37// Byte Space Hash - Identity
38///////////////////////////////////////////////////////////////////////////////
39template<> class hash_strategy_t<1,id> {
40public:
41    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
42        return h0[idx];
43    }
44    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(1); }
45};
46
47template<> class hash_strategy_t<2,id> {
48public:
49    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
50        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
51    }
52    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(2); }
53};
54
55template<> class hash_strategy_t<3,id> {
56public:
57    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
58        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
59    }
60    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(3); }
61};
62
63template<> class hash_strategy_t<4,id>: public hash_strategy {
64public:
65    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
66        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
67    };
68    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(4); }
69};
70
71template<> class hash_strategy_t<5,id>: public hash_strategy {
72public:
73    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
74        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
75    };
76    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(5); }
77};
78
79template<> class hash_strategy_t<6,id>: public hash_strategy {
80public:
81    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
82        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
83    };
84    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(6); }
85};
86
87template<> class hash_strategy_t<7,id>: public hash_strategy {
88public:
89    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
90        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
91    };
92    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(7); }
93};
94
95///////////////////////////////////////////////////////////////////////////////
96// Bit Space Hash - Identity
97///////////////////////////////////////////////////////////////////////////////
98template<> class hash_strategy_t<8,id>: public hash_strategy {
99public:
100    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
101        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits);
102    };
103    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 8; }
104};
105
106template<> class hash_strategy_t<9,id>: public hash_strategy {
107public:
108    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
109        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits);
110    };
111    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 9; }
112};
113
114template<> class hash_strategy_t<10,id>: public hash_strategy {
115public:
116    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
117        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits);
118    };
119    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 10; }
120};
121
122template<> class hash_strategy_t<11,id>: public hash_strategy {
123public:
124    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
125        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits);
126    };
127    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 11; }
128};
129
130template<> class hash_strategy_t<12,id>: public hash_strategy {
131public:
132    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
133        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits);
134    };
135    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 12; }
136};
137
138template<> class hash_strategy_t<13,id>: public hash_strategy {
139public:
140    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
141        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits);
142    };
143    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 13; }
144};
145
146template<> class hash_strategy_t<14,id>: public hash_strategy {
147public:
148    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
149        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits);
150    };
151    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 14; }
152};
153
154template<> class hash_strategy_t<15,id>: public hash_strategy {
155public:
156    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
157        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits);
158    };
159    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 15; }
160};
161
162template<> class hash_strategy_t<16,id>: public hash_strategy {
163public:
164    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
165        return bit_compress_hash(h0, h1, idx, slice_bits, hash_bits);
166    };
167    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 16; }
168};
169
170///////////////////////////////////////////////////////////////////////////////
171// Bit Space / Byte Space - Div 2 - Equivalent to identity hash function.
172///////////////////////////////////////////////////////////////////////////////
173template<uint32_t LGTH> class hash_strategy_t<LGTH,div2>: public hash_strategy_t<LGTH,id>{};
174
175///////////////////////////////////////////////////////////////////////////////
176// Byte Space Hash - Log base 2
177///////////////////////////////////////////////////////////////////////////////
178template<> class hash_strategy_t<1,logbase2> {
179public:
180    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
181        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
182    }
183    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(1); }
184};
185
186template<> class hash_strategy_t<2,logbase2> {
187public:
188    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
189        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
190    }
191    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(2); }
192};
193
194template<> class hash_strategy_t<4,logbase2> {
195public:
196    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
197        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
198    }
199    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(3); }
200};
201
202template<> class hash_strategy_t<8,logbase2> {
203public:
204    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
205        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
206    }
207    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return bytes2bits(5); }
208};
209
210///////////////////////////////////////////////////////////////////////////////
211// Bit Space Hash - Log base 2
212///////////////////////////////////////////////////////////////////////////////
213template<> class hash_strategy_t<16,logbase2> {
214public:
215    static IDISA_ALWAYS_INLINE uint64_t hash(const uint8_t * h0, const uint8_t * h1, const int32_t idx, const uint32_t slice_bits, const uint32_t hash_bits) {
216        return bit_compress_hash(h0, h1, bytes2bits(idx), slice_bits, hash_bits);
217    }
218    static IDISA_ALWAYS_INLINE uint32_t max_hashsize() { return 9; }
219};
220
221#endif // HASH_STRATEGY_HPP
Note: See TracBrowser for help on using the repository browser.