Skip to content
项目
群组
代码片段
帮助
正在加载...
帮助
为 GitLab 提交贡献
登录/注册
切换导航
H
h2database
项目
项目
详情
活动
周期分析
仓库
仓库
文件
提交
分支
标签
贡献者
分枝图
比较
统计图
议题
0
议题
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
CI / CD
CI / CD
流水线
作业
计划
统计图
Wiki
Wiki
代码片段
代码片段
成员
成员
折叠边栏
关闭边栏
活动
分枝图
统计图
创建新议题
作业
提交
议题看板
打开侧边栏
Administrator
h2database
Commits
f986f6ae
提交
f986f6ae
authored
11月 25, 2014
作者:
Thomas Mueller
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Minimal perfect hash tool
上级
2d649ea2
隐藏空白字符变更
内嵌
并排
正在显示
3 个修改的文件
包含
528 行增加
和
0 行删除
+528
-0
TestIntPerfectHash.java
h2/src/test/org/h2/test/unit/TestIntPerfectHash.java
+109
-0
IntPerfectHash.java
h2/src/tools/org/h2/dev/hash/IntPerfectHash.java
+413
-0
MinimalPerfectHash.java
h2/src/tools/org/h2/dev/hash/MinimalPerfectHash.java
+6
-0
没有找到文件。
h2/src/test/org/h2/test/unit/TestIntPerfectHash.java
0 → 100644
浏览文件 @
f986f6ae
/*
* Copyright 2004-2014 H2 Group. Multiple-Licensed under the MPL 2.0,
* and the EPL 1.0 (http://h2database.com/html/license.html).
* Initial Developer: H2 Group
*/
package
org
.
h2
.
test
.
unit
;
import
java.util.ArrayList
;
import
java.util.BitSet
;
import
java.util.HashSet
;
import
java.util.Random
;
import
java.util.Set
;
import
org.h2.dev.hash.IntPerfectHash
;
import
org.h2.dev.hash.IntPerfectHash.BitArray
;
import
org.h2.test.TestBase
;
/**
* Tests the perfect hash tool.
*/
public
class
TestIntPerfectHash
extends
TestBase
{
/**
* Run just this test.
*
* @param a ignored
*/
public
static
void
main
(
String
...
a
)
throws
Exception
{
TestIntPerfectHash
test
=
(
TestIntPerfectHash
)
TestBase
.
createCaller
().
init
();
test
.
measure
();
test
.
test
();
test
.
measure
();
}
/**
* Measure the hash functions.
*/
public
void
measure
()
{
int
size
=
10000
;
test
(
size
/
10
);
int
s
;
long
time
=
System
.
currentTimeMillis
();
s
=
test
(
size
);
time
=
System
.
currentTimeMillis
()
-
time
;
System
.
out
.
println
((
double
)
s
/
size
+
" bits/key in "
+
time
+
" ms"
);
}
@Override
public
void
test
()
{
testBitArray
();
for
(
int
i
=
0
;
i
<
100
;
i
++)
{
test
(
i
);
}
for
(
int
i
=
100
;
i
<=
10000
;
i
*=
10
)
{
test
(
i
);
}
}
private
void
testBitArray
()
{
byte
[]
data
=
new
byte
[
0
];
BitSet
set
=
new
BitSet
();
for
(
int
i
=
100
;
i
>=
0
;
i
--)
{
data
=
BitArray
.
setBit
(
data
,
i
,
true
);
set
.
set
(
i
);
}
Random
r
=
new
Random
(
1
);
for
(
int
i
=
0
;
i
<
10000
;
i
++)
{
int
pos
=
r
.
nextInt
(
100
);
boolean
s
=
r
.
nextBoolean
();
data
=
BitArray
.
setBit
(
data
,
pos
,
s
);
set
.
set
(
pos
,
s
);
pos
=
r
.
nextInt
(
100
);
assertTrue
(
BitArray
.
getBit
(
data
,
pos
)
==
set
.
get
(
pos
));
}
assertTrue
(
BitArray
.
countBits
(
data
)
==
set
.
cardinality
());
}
private
int
test
(
int
size
)
{
Random
r
=
new
Random
(
size
);
HashSet
<
Integer
>
set
=
new
HashSet
<
Integer
>();
while
(
set
.
size
()
<
size
)
{
set
.
add
(
r
.
nextInt
());
}
ArrayList
<
Integer
>
list
=
new
ArrayList
<
Integer
>();
list
.
addAll
(
set
);
byte
[]
desc
=
IntPerfectHash
.
generate
(
list
);
int
max
=
test
(
desc
,
set
);
assertEquals
(
size
-
1
,
max
);
return
desc
.
length
*
8
;
}
private
int
test
(
byte
[]
desc
,
Set
<
Integer
>
set
)
{
int
max
=
-
1
;
HashSet
<
Integer
>
test
=
new
HashSet
<
Integer
>();
IntPerfectHash
hash
=
new
IntPerfectHash
(
desc
);
for
(
int
x
:
set
)
{
int
h
=
hash
.
get
(
x
);
assertTrue
(
h
>=
0
);
assertTrue
(
h
<=
set
.
size
()
*
3
);
max
=
Math
.
max
(
max
,
h
);
assertFalse
(
test
.
contains
(
h
));
test
.
add
(
h
);
}
return
max
;
}
}
h2/src/tools/org/h2/dev/hash/IntPerfectHash.java
0 → 100644
浏览文件 @
f986f6ae
/*
* Copyright 2004-2014 H2 Group. Multiple-Licensed under the MPL 2.0,
* and the EPL 1.0 (http://h2database.com/html/license.html).
* Initial Developer: H2 Group
*/
package
org
.
h2
.
dev
.
hash
;
import
java.util.ArrayList
;
import
java.util.Arrays
;
/**
* A minimum perfect hash function tool. It needs about 2.2 bits per key.
*/
public
class
IntPerfectHash
{
/**
* Large buckets are typically divided into buckets of this size.
*/
private
static
final
int
DIVIDE
=
6
;
/**
* The maximum size of a small bucket (one that is not further split if
* possible).
*/
private
static
final
int
MAX_SIZE
=
12
;
/**
* The maximum offset for hash functions of small buckets. At most that many
* hash functions are tried for the given size.
*/
private
static
final
int
[]
MAX_OFFSETS
=
{
0
,
0
,
8
,
18
,
47
,
123
,
319
,
831
,
2162
,
5622
,
14617
,
38006
,
98815
};
/**
* The output value to split the bucket into many (more than 2) smaller
* buckets.
*/
private
static
final
int
SPLIT_MANY
=
3
;
/**
* The minimum output value for a small bucket of a given size.
*/
private
static
final
int
[]
SIZE_OFFSETS
=
new
int
[
MAX_OFFSETS
.
length
+
1
];
static
{
int
last
=
SPLIT_MANY
+
1
;
for
(
int
i
=
0
;
i
<
MAX_OFFSETS
.
length
;
i
++)
{
SIZE_OFFSETS
[
i
]
=
last
;
last
+=
MAX_OFFSETS
[
i
];
}
SIZE_OFFSETS
[
SIZE_OFFSETS
.
length
-
1
]
=
last
;
}
/**
* The description of the hash function. Used for calculating the hash of a
* key.
*/
private
final
byte
[]
data
;
/**
* Create a hash object to convert keys to hashes.
*
* @param data the data returned by the generate method
*/
public
IntPerfectHash
(
byte
[]
data
)
{
this
.
data
=
data
;
}
/**
* Get the hash function description.
*
* @return the data
*/
public
byte
[]
getData
()
{
return
data
;
}
/**
* Calculate the hash value for the given key.
*
* @param x the key
* @return the hash value
*/
public
int
get
(
int
x
)
{
return
get
(
0
,
x
,
0
);
}
/**
* Get the hash value for the given key, starting at a certain position and
* level.
*
* @param pos the start position
* @param x the key
* @param isRoot whether this is the root of the tree
* @param level the level
* @return the hash value
*/
private
int
get
(
int
pos
,
int
x
,
int
level
)
{
int
n
=
readVarInt
(
data
,
pos
);
if
(
n
<
2
)
{
return
0
;
}
else
if
(
n
>
SPLIT_MANY
)
{
int
size
=
getSize
(
n
);
int
offset
=
getOffset
(
n
,
size
);
return
hash
(
x
,
level
,
offset
,
size
);
}
pos
++;
int
split
;
if
(
n
==
SPLIT_MANY
)
{
split
=
readVarInt
(
data
,
pos
);
pos
+=
getVarIntLength
(
data
,
pos
);
}
else
{
split
=
n
;
}
int
h
=
hash
(
x
,
level
,
0
,
split
);
int
s
;
int
start
=
pos
;
for
(
int
i
=
0
;
i
<
h
;
i
++)
{
pos
=
getNextPos
(
pos
);
}
s
=
getSizeSum
(
start
,
pos
);
return
s
+
get
(
pos
,
x
,
level
+
1
);
}
/**
* Get the position of the next sibling.
*
* @param pos the position of this branch
* @return the position of the next sibling
*/
private
int
getNextPos
(
int
pos
)
{
int
n
=
readVarInt
(
data
,
pos
);
pos
+=
getVarIntLength
(
data
,
pos
);
if
(
n
<
2
||
n
>
SPLIT_MANY
)
{
return
pos
;
}
int
split
;
if
(
n
==
SPLIT_MANY
)
{
split
=
readVarInt
(
data
,
pos
);
pos
+=
getVarIntLength
(
data
,
pos
);
}
else
{
split
=
n
;
}
for
(
int
i
=
0
;
i
<
split
;
i
++)
{
pos
=
getNextPos
(
pos
);
}
return
pos
;
}
/**
* The sum of the sizes between the start and end position.
*
* @param start the start position
* @param end the end position (excluding)
* @return the sizes
*/
private
int
getSizeSum
(
int
start
,
int
end
)
{
int
s
=
0
;
for
(
int
pos
=
start
;
pos
<
end
;)
{
int
n
=
readVarInt
(
data
,
pos
);
pos
+=
getVarIntLength
(
data
,
pos
);
if
(
n
<
2
)
{
s
+=
n
;
}
else
if
(
n
>
SPLIT_MANY
)
{
s
+=
getSize
(
n
);
}
else
if
(
n
==
SPLIT_MANY
)
{
pos
+=
getVarIntLength
(
data
,
pos
);
}
}
return
s
;
}
private
static
void
writeSizeOffset
(
ByteStream
out
,
int
size
,
int
offset
)
{
writeVarInt
(
out
,
SIZE_OFFSETS
[
size
]
+
offset
);
}
private
static
int
getOffset
(
int
n
,
int
size
)
{
return
n
-
SIZE_OFFSETS
[
size
];
}
private
static
int
getSize
(
int
n
)
{
for
(
int
i
=
0
;
i
<
SIZE_OFFSETS
.
length
;
i
++)
{
if
(
n
<
SIZE_OFFSETS
[
i
])
{
return
i
-
1
;
}
}
return
0
;
}
/**
* Generate the minimal perfect hash function data from the given list.
*
* @param list the data
* @return the hash function description
*/
public
static
<
K
>
byte
[]
generate
(
ArrayList
<
Integer
>
list
)
{
ByteStream
out
=
new
ByteStream
();
generate
(
list
,
0
,
out
);
return
out
.
toByteArray
();
}
private
static
<
K
>
void
generate
(
ArrayList
<
Integer
>
list
,
int
level
,
ByteStream
out
)
{
int
size
=
list
.
size
();
if
(
size
<=
1
)
{
out
.
write
((
byte
)
size
);
return
;
}
if
(
level
>
32
)
{
throw
new
IllegalStateException
(
"Too many recursions; "
+
" incorrect universal hash function?"
);
}
if
(
size
<=
MAX_SIZE
)
{
int
maxOffset
=
MAX_OFFSETS
[
size
];
int
testSize
=
size
;
nextOffset:
for
(
int
offset
=
0
;
offset
<
maxOffset
;
offset
++)
{
int
bits
=
0
;
for
(
int
i
=
0
;
i
<
size
;
i
++)
{
int
x
=
list
.
get
(
i
);
int
h
=
hash
(
x
,
level
,
offset
,
testSize
);
if
((
bits
&
(
1
<<
h
))
!=
0
)
{
continue
nextOffset
;
}
bits
|=
1
<<
h
;
}
writeSizeOffset
(
out
,
size
,
offset
);
return
;
}
}
int
split
;
if
(
size
>
57
*
DIVIDE
)
{
split
=
size
/
(
36
*
DIVIDE
);
}
else
{
split
=
(
size
-
47
)
/
DIVIDE
;
}
split
=
Math
.
max
(
2
,
split
);
ArrayList
<
ArrayList
<
Integer
>>
lists
;
do
{
lists
=
new
ArrayList
<
ArrayList
<
Integer
>>(
split
);
for
(
int
i
=
0
;
i
<
split
;
i
++)
{
lists
.
add
(
new
ArrayList
<
Integer
>(
size
/
split
));
}
for
(
int
x
:
list
)
{
ArrayList
<
Integer
>
l
=
lists
.
get
(
hash
(
x
,
level
,
0
,
split
));
l
.
add
(
x
);
}
}
while
(
lists
==
null
);
if
(
split
>=
SPLIT_MANY
)
{
out
.
write
((
byte
)
SPLIT_MANY
);
}
writeVarInt
(
out
,
split
);
list
.
clear
();
list
.
trimToSize
();
for
(
ArrayList
<
Integer
>
s2
:
lists
)
{
generate
(
s2
,
level
+
1
,
out
);
}
}
private
static
int
hash
(
int
x
,
int
level
,
int
offset
,
int
size
)
{
x
+=
level
+
offset
*
32
;
x
=
((
x
>>>
16
)
^
x
)
*
0x45d9f3b
;
x
=
((
x
>>>
16
)
^
x
)
*
0x45d9f3b
;
x
=
(
x
>>>
16
)
^
x
;
return
Math
.
abs
(
x
%
size
);
}
private
static
int
writeVarInt
(
ByteStream
out
,
int
x
)
{
int
len
=
0
;
while
((
x
&
~
0x7f
)
!=
0
)
{
out
.
write
((
byte
)
(
0x80
|
(
x
&
0x7f
)));
x
>>>=
7
;
len
++;
}
out
.
write
((
byte
)
x
);
return
++
len
;
}
private
static
int
readVarInt
(
byte
[]
d
,
int
pos
)
{
int
x
=
d
[
pos
++];
if
(
x
>=
0
)
{
return
x
;
}
x
&=
0x7f
;
for
(
int
s
=
7
;
s
<
64
;
s
+=
7
)
{
int
b
=
d
[
pos
++];
x
|=
(
b
&
0x7f
)
<<
s
;
if
(
b
>=
0
)
{
break
;
}
}
return
x
;
}
private
static
int
getVarIntLength
(
byte
[]
d
,
int
pos
)
{
int
x
=
d
[
pos
++];
if
(
x
>=
0
)
{
return
1
;
}
int
len
=
2
;
for
(
int
s
=
7
;
s
<
64
;
s
+=
7
)
{
int
b
=
d
[
pos
++];
if
(
b
>=
0
)
{
break
;
}
len
++;
}
return
len
;
}
/**
* A stream of bytes.
*/
static
class
ByteStream
{
private
byte
[]
data
;
private
int
pos
;
ByteStream
()
{
this
.
data
=
new
byte
[
16
];
}
ByteStream
(
byte
[]
data
)
{
this
.
data
=
data
;
}
/**
* Read a byte.
*
* @return the byte, or -1.
*/
int
read
()
{
return
pos
<
data
.
length
?
(
data
[
pos
++]
&
255
)
:
-
1
;
}
/**
* Write a byte.
*
* @param value the byte
*/
void
write
(
byte
value
)
{
if
(
pos
>=
data
.
length
)
{
data
=
Arrays
.
copyOf
(
data
,
data
.
length
*
2
);
}
data
[
pos
++]
=
value
;
}
/**
* Get the byte array.
*
* @return the byte array
*/
byte
[]
toByteArray
()
{
return
Arrays
.
copyOf
(
data
,
pos
);
}
}
/**
* A helper class for bit arrays.
*/
public
static
class
BitArray
{
/**
* Set a bit in the array.
*
* @param data the array
* @param x the bit index
* @param value the new value
* @return the bit array (if the passed one was too small)
*/
public
static
byte
[]
setBit
(
byte
[]
data
,
int
x
,
boolean
value
)
{
int
pos
=
x
/
8
;
if
(
pos
>=
data
.
length
)
{
data
=
Arrays
.
copyOf
(
data
,
pos
+
1
);
}
if
(
value
)
{
data
[
pos
]
|=
1
<<
(
x
&
7
);
}
else
{
data
[
pos
]
&=
255
-
(
1
<<
(
x
&
7
));
}
return
data
;
}
/**
* Get a bit in a bit array.
*
* @param data the array
* @param x the bit index
* @return the value
*/
public
static
boolean
getBit
(
byte
[]
data
,
int
x
)
{
return
(
data
[
x
/
8
]
&
(
1
<<
(
x
&
7
)))
!=
0
;
}
/**
* Count the number of set bits.
*
* @param data the array
* @return the number of set bits
*/
public
static
int
countBits
(
byte
[]
data
)
{
int
count
=
0
;
for
(
byte
x
:
data
)
{
count
+=
Integer
.
bitCount
(
x
&
255
);
}
return
count
;
}
}
}
h2/src/tools/org/h2/dev/hash/MinimalPerfectHash.java
浏览文件 @
f986f6ae
...
...
@@ -76,6 +76,12 @@ public class MinimalPerfectHash<K> {
*/
private
static
final
int
DIVIDE
=
6
;
/**
* For sets larger than this, instead of trying to map then uniquely to a
* set of the same size, the size of the set is incremented by one. This
* reduces the time to find a mapping, but the index of the hole also needs
* to be stored, which increases the space usage.
*/
private
static
final
int
SPEEDUP
=
11
;
/**
...
...
编写
预览
Markdown
格式
0%
重试
或
添加新文件
添加附件
取消
您添加了
0
人
到此讨论。请谨慎行事。
请先完成此评论的编辑!
取消
请
注册
或者
登录
后发表评论