/*
* 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.store;
import java.io.File;
import java.io.FileOutputStream;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import org.h2.security.AES;
/**
* Calculate the constant for the secondary hash function, so that the hash
* function mixes the input bits as much as possible.
*/
public class CalculateHashConstantLong implements Runnable {
private static BitSet primeNumbers = new BitSet();
private static long[] randomValues;
private static AtomicInteger high = new AtomicInteger(0x20);
private static Set<Long> candidates =
Collections.synchronizedSet(new HashSet<Long>());
private long constant;
private int[] fromTo = new int[64 * 64];
private final AES aes = new AES();
{
aes.setKey("Hello World Hallo Welt".getBytes());
}
private final byte[] data = new byte[16];
/**
* Run just this test.
*
* @param args ignored
*/
public static void main(String... args) throws Exception {
for (int i = 0x0; i < 0x10000; i++) {
if (BigInteger.valueOf(i).isProbablePrime(20)) {
primeNumbers.set(i);
}
}
randomValues = getRandomValues(1000, 1);
Random r = new Random(1);
for (int i = 0; i < randomValues.length; i++) {
randomValues[i] = r.nextInt();
}
printQuality(new CalculateHashConstantLong() {
@Override
public long hash(long x) {
return secureHash(x);
}
@Override
public String toString() {
return "AES";
}
}, randomValues);
// Quality of AES
// Dependencies: 15715..16364
// Avalanche: 31998
// AvalancheSum: 3199841
// Effect: 49456..50584
printQuality(new CalculateHashConstantLong() {
@Override
public long hash(long x) {
x = (x ^ (x >>> 30)) * 0xbf58476d1ce4e5b9L;
x = (x ^ (x >>> 27)) * 0x94d049bb133111ebL;
return x ^ (x >>> 31);
}
@Override
public String toString() {
return "Test";
}
}, randomValues);
// Quality of Test
// Dependencies: 14693..16502
// Avalanche: 31996
// AvalancheSum: 3199679
// Effect: 49437..50537
Thread[] threads = new Thread[8];
for (int i = 0; i < 8; i++) {
threads[i] = new Thread(new CalculateHashConstantLong());
threads[i].start();
}
for (int i = 0; i < 8; i++) {
threads[i].join();
}
int finalCount = 10000;
long[] randomValues = getRandomValues(finalCount, 10);
CalculateHashConstantLong test;
int[] minMax;
test = new CalculateHashConstantLong();
long best = 0;
int dist = Integer.MAX_VALUE;
for (long i : candidates) {
test.constant = i;
System.out.println();
System.out.println("Constant: 0x" + Long.toHexString(i));
minMax = test.getDependencies(test, randomValues);
System.out.println("Dependencies: " + minMax[0] + ".." + minMax[1]);
int d = minMax[1] - minMax[0];
int av = 0;
for (int j = 0; j < 100; j++) {
av += test.getAvalanche(test, randomValues[j]);
}
System.out.println("AvalancheSum: " + av);
minMax = test.getEffect(test, finalCount * 10, 11);
System.out.println("Effect: " + minMax[0] + ".." + minMax[1]);
d += minMax[1] - minMax[0];
if (d < dist) {
dist = d;
best = i;
}
}
System.out.println();
System.out.println("Best constant: 0x" + Long.toHexString(best));
test.constant = best;
long collisions = test.getCollisionCount();
System.out.println("Collisions: " + collisions);
}
private static void printQuality(CalculateHashConstantLong test, long[] randomValues) {
int finalCount = randomValues.length * 10;
System.out.println("Quality of " + test);
int[] minMax;
int av = 0;
minMax = test.getDependencies(test, randomValues);
System.out.println("Dependencies: " + minMax[0] + ".." + minMax[1]);
av = 0;
for (int j = 0; j < 100; j++) {
av += test.getAvalanche(test, randomValues[j]);
}
System.out.println("Avalanche: " + (av / 100));
System.out.println("AvalancheSum: " + av);
minMax = test.getEffect(test, finalCount * 10, 11);
System.out.println("Effect: " + minMax[0] + ".." + minMax[1]);
System.out.println("ok=" + test.testCandidate());
}
/**
* Store a random file to be analyzed by the Diehard test.
*/
void storeRandomFile() throws Exception {
File f = new File(System.getProperty("user.home") + "/temp/rand.txt");
FileOutputStream out = new FileOutputStream(f);
CalculateHashConstantLong test = new CalculateHashConstantLong();
// Random r = new Random(1);
byte[] buff = new byte[8];
// tt.constant = 0x29a907;
for (int i = 0; i < 10000000 / 8; i++) {
long y = test.hash(i);
// int y = r.nextInt();
writeLong(buff, 0, y);
out.write(buff);
}
out.close();
}
private static long[] getRandomValues(int count, int seed) {
long[] values = new long[count];
Random r = new Random(seed);
for (int i = 0; i < count; i++) {
values[i] = r.nextLong();
}
return values;
}
@Override
public void run() {
while (true) {
int currentHigh = high.getAndIncrement();
// if (currentHigh > 0x2d) {
if (currentHigh > 0xffff) {
break;
}
System.out.println("testing " + Integer.toHexString(currentHigh) + "....");
addCandidates(currentHigh);
}
}
private void addCandidates(long currentHigh) {
for (int low = 0; low <= 0xffff; low++) {
// the lower 16 bits don't have to be a prime number
// but it seems that's a good restriction
if (!primeNumbers.get(low)) {
continue;
}
long i = (currentHigh << 48) | ((long) low << 32) | (currentHigh << 16) | low;
constant = i;
if (!testCandidate()) {
continue;
}
System.out.println(Long.toHexString(i) +
" hit " + i);
candidates.add(i);
}
}
private boolean testCandidate() {
// after one bit changes in the input,
// on average 32 bits of the output change
int av = getAvalanche(this, 0);
if (Math.abs(av - 32000) > 1000) {
return false;
}
av = getAvalanche(this, 0xffffffffffffffffL);
if (Math.abs(av - 32000) > 1000) {
return false;
}
long es = getEffectSquare(this, randomValues);
if (es > 1100000) {
System.out.println("fail at a " + es);
return false;
}
int[] minMax = getEffect(this, 10000, 1);
if (!isWithin(4700, 5300, minMax)) {
System.out.println("fail at b " + minMax[0] + " " + minMax[1]);
return false;
}
minMax = getDependencies(this, randomValues);
if (!isWithin(14500, 17000, minMax)) {
System.out.println("fail at c " + minMax[0] + " " + minMax[1]);
return false;
}
return true;
}
long getCollisionCount() {
// TODO need a way to check this
return 0;
}
private static boolean isWithin(int min, int max, int[] range) {
return range[0] >= min && range[1] <= max;
}
/**
* Calculate how much the bit changes (output bits that change if an input
* bit is changed) are independent of each other.
*
* @param h the hash object
* @param values the values to test with
* @return the minimum and maximum number of output bits that are changed in
* combination with another output bit
*/
int[] getDependencies(CalculateHashConstantLong h, long[] values) {
Arrays.fill(fromTo, 0);
for (long x : values) {
for (int shift = 0; shift < 64; shift++) {
long x1 = h.hash(x);
long x2 = h.hash(x ^ (1L << shift));
long x3 = x1 ^ x2;
for (int s = 0; s < 64; s++) {
if ((x3 & (1L << s)) != 0) {
for (int s2 = 0; s2 < 64; s2++) {
if (s == s2) {
continue;
}
if ((x3 & (1L << s2)) != 0) {
fromTo[s * 64 + s2]++;
}
}
}
}
}
}
int a = Integer.MAX_VALUE, b = Integer.MIN_VALUE;
for (int x : fromTo) {
if (x == 0) {
continue;
}
if (x < a) {
a = x;
}
if (x > b) {
b = x;
}
}
return new int[] {a, b};
}
/**
* Calculate the number of bits that change if a single bit is changed
* multiplied by 1000 (expected: 16000 +/- 5%).
*
* @param h the hash object
* @param value the base value
* @return the number of bit changes multiplied by 1000
*/
int getAvalanche(CalculateHashConstantLong h, long value) {
int changedBitsSum = 0;
for (int i = 0; i < 64; i++) {
long x = value ^ (1L << i);
for (int shift = 0; shift < 64; shift++) {
long x1 = h.hash(x);
long x2 = h.hash(x ^ (1L << shift));
long x3 = x1 ^ x2;
changedBitsSum += Long.bitCount(x3);
}
}
return changedBitsSum * 1000 / 64 / 64;
}
/**
* Calculate the sum of the square of the distance to the expected
* probability that an output bit changes if an input bit is changed. The
* lower the value, the better.
*
* @param h the hash object
* @param values the values to test with
* @return sum(distance^2)
*/
long getEffectSquare(CalculateHashConstantLong h, long[] values) {
Arrays.fill(fromTo, 0);
int total = 0;
for (long x : values) {
for (int shift = 0; shift < 64; shift++) {
long x1 = h.hash(x);
long x2 = h.hash(x ^ (1L << shift));
long x3 = x1 ^ x2;
for (int s = 0; s < 64; s++) {
if ((x3 & (1L << s)) != 0) {
fromTo[shift * 64 + s]++;
total++;
}
}
}
}
long sqDist = 0;
int expected = total / 64 / 64;
for (int x : fromTo) {
int dist = Math.abs(x - expected);
sqDist += dist * dist;
}
return sqDist;
}
/**
* Calculate if the bit changes (that an output bit changes if an input
* bit is changed) are within a certain range.
*
* @param h the hash object
* @param count the number of values to test
* @param seed the random seed
* @return the minimum and maximum value of all input-to-output bit changes
*/
int[] getEffect(CalculateHashConstantLong h, int count, int seed) {
Random r = new Random();
r.setSeed(seed);
Arrays.fill(fromTo, 0);
for (int i = 0; i < count; i++) {
long x = r.nextLong();
for (int shift = 0; shift < 64; shift++) {
long x1 = h.hash(x);
long x2 = h.hash(x ^ (1L << shift));
long x3 = x1 ^ x2;
for (int s = 0; s < 64; s++) {
if ((x3 & (1L << s)) != 0) {
fromTo[shift * 64 + s]++;
}
}
}
}
int a = Integer.MAX_VALUE, b = Integer.MIN_VALUE;
for (int x : fromTo) {
if (x < a) {
a = x;
}
if (x > b) {
b = x;
}
}
return new int[] {a, b};
}
/**
* The hash method.
*
* @param x the input
* @return the output
*/
long hash(long x) {
x = ((x >>> 32) ^ x) * constant;
x = ((x >>> 32) ^ x) * constant;
x = (x >>> 32) ^ x;
return x;
}
/**
* Calculate a hash using AES.
*
* @param x the input
* @return the output
*/
long secureHash(long x) {
writeLong(data, 0, x);
aes.encrypt(data, 0, 16);
return readLong(data, 0);
}
private static void writeLong(byte[] buff, int pos, long x) {
writeInt(buff, pos, (int) (x >>> 32));
writeInt(buff, pos + 4, (int) x);
}
private static void writeInt(byte[] buff, int pos, int x) {
buff[pos++] = (byte) (x >> 24);
buff[pos++] = (byte) (x >> 16);
buff[pos++] = (byte) (x >> 8);
buff[pos++] = (byte) x;
}
private static long readLong(byte[] buff, int pos) {
return (((long) readInt(buff, pos)) << 32) | (readInt(buff, pos + 4) & 0xffffffffL);
}
private static int readInt(byte[] buff, int pos) {
return (buff[pos++] << 24) + ((buff[pos++] & 0xff) << 16) +
((buff[pos++] & 0xff) << 8) + (buff[pos] & 0xff);
}
}