/
utility.go
136 lines (127 loc) · 2.89 KB
/
utility.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package main
import (
"hash/crc32"
"os"
)
var VALID_TYPES map[uint8]bool = map[uint8]bool{LISTTYPE: true, PMAPTYPE: true,
MAPTYPE: true, CTRTYPE: true}
func getPartition(key string, maxpart uint32) uint32 {
return (crc32.ChecksumIEEE([]byte(key)) & MAX_PARTITIONS_AND) % maxpart
}
func copyslice(inp []byte) []byte {
out := make([]byte, len(inp))
copy(out, inp)
return out
}
func errp(err error) {
if err != nil {
panic(err)
}
}
func validType(typ uint8) bool {
_, ok := VALID_TYPES[typ]
return ok
}
func getFileSizeFile(file *os.File) int64 {
filestat, err := file.Stat()
if err != nil {
return -1
}
return filestat.Size()
}
func murmur3_64(data []byte, seed uint64) uint64 {
var m uint64 = 0xc6a4a7935bd1e995
var r uint64 = 47
length := uint64(len(data))
hashval := (seed & 0xffffffff) ^ (length * m)
numeightbytes := length - (length & 7)
for i := uint64(0); i < numeightbytes; i += 8 {
k := uint64(data[i+7])
k = k<<8 + uint64(data[i+6])
k = k<<8 + uint64(data[i+5])
k = k<<8 + uint64(data[i+4])
k = k<<8 + uint64(data[i+3])
k = k<<8 + uint64(data[i+2])
k = k<<8 + uint64(data[i+1])
k = k<<8 + uint64(data[i])
k *= m
k ^= k >> r
k *= m
hashval ^= k
hashval *= m
}
remaining := length & 7
if remaining > 0 {
remaining_start := data[numeightbytes:]
if remaining == 7 {
hashval ^= uint64(remaining_start[6]) << 48
}
if remaining >= 6 {
hashval ^= uint64(remaining_start[5]) << 40
}
if remaining >= 5 {
hashval ^= uint64(remaining_start[4]) << 32
}
if remaining >= 4 {
hashval ^= uint64(remaining_start[3]) << 24
}
if remaining >= 3 {
hashval ^= uint64(remaining_start[2]) << 16
}
if remaining >= 2 {
hashval ^= uint64(remaining_start[1]) << 8
}
hashval ^= uint64(remaining_start[0])
hashval *= m
}
hashval ^= hashval >> r
hashval *= m
hashval ^= hashval >> r
return hashval
}
func murmur3_32(data []byte, seed uint32) uint32 {
var c1 uint32 = 0xcc9e2d51
var c2 uint32 = 0x1b873593
var r1 uint32 = 15
var r2 uint32 = 13
var m uint32 = 5
var n uint32 = 0xe6546b64
hashval := seed
length := uint32(len(data))
numfourbytes := length - (length & 3)
for i := uint32(0); i < numfourbytes; i += 4 {
k := uint32(data[i+3])
k = k<<4 + uint32(data[i+2])
k = k<<4 + uint32(data[i+1])
k = k<<4 + uint32(data[i])
k *= c1
k <<= r1
k *= c2
hashval ^= k
hashval <<= r2
hashval = hashval*m + n
}
remaining := length & 3
if remaining > 0 {
remaining_start := data[numfourbytes:]
var rem uint32 = 0
if remaining == 3 {
rem = uint32(remaining_start[2])
}
if remaining >= 2 {
rem = rem<<8 + uint32(remaining_start[1])
}
rem = rem<<8 + uint32(remaining_start[0])
rem *= c1
rem <<= r1
rem *= c2
hashval ^= rem
}
hashval ^= length
hashval = hashval ^ (hashval >> 16)
hashval *= 0x85ebca6b
hashval = hashval ^ (hashval >> 13)
hashval *= 0xc2b2ae35
hashval = hashval ^ (hashval >> 16)
return hashval
}