echelon/i2p.i2p
1
0
Fork 0
forked from I2P_Developers/i2p.i2p
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

SipHash inline implementation and junit test, unmodified.

Browse Source 
As pulled from https://github.com/nahi/siphash-java-inline
Last commit was 5be5c84851
2012-11-06

Copyright 2012  Hiroshi Nakamura <nahi@ruby-lang.org>
Apache 2 license

25%-35% faster than reference implementation in my tests.
This commit is contained in:
zzz
2013-01-02 13:54:49 +00:00
parent f2331b0603
commit 20cc48cd87
2 changed files with 253 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
core/java/src/net/i2p/util/SipHashInline.java Normal file
View File

@ -0,0 +1,170 @@
/**
* SipHash implementation with hand inlining the SIPROUND.
*
* To know details about SipHash, see;
* "a fast short-input PRF" https://www.131002.net/siphash/
*
* SIPROUND is defined in siphash24.c that can be downloaded from the above
* site. Following license notice is subject to change based on the licensing
* policy of siphash24.c.
*/
public class SipHashInline {
public static long hash24(long k0, long k1, byte[] data) {
long v0 = 0x736f6d6570736575L ^ k0;
long v1 = 0x646f72616e646f6dL ^ k1;
long v2 = 0x6c7967656e657261L ^ k0;
long v3 = 0x7465646279746573L ^ k1;
long m;
int last = data.length / 8 * 8;
int i = 0;
// processing 8 bytes blocks in data
while (i < last) {
// pack a block to long, as LE 8 bytes
m = (long) data[i++] |
(long) data[i++] << 8 |
(long) data[i++] << 16 |
(long) data[i++] << 24 |
(long) data[i++] << 32 |
(long) data[i++] << 40 |
(long) data[i++] << 48 |
(long) data[i++] << 56 ;
// MSGROUND {
v3 ^= m;
/* SIPROUND wih hand reordering
*
* SIPROUND in siphash24.c:
* A: v0 += v1;
* B: v1=ROTL(v1,13);
* C: v1 ^= v0;
* D: v0=ROTL(v0,32);
* E: v2 += v3;
* F: v3=ROTL(v3,16);
* G: v3 ^= v2;
* H: v0 += v3;
* I: v3=ROTL(v3,21);
* J: v3 ^= v0;
* K: v2 += v1;
* L: v1=ROTL(v1,17);
* M: v1 ^= v2;
* N: v2=ROTL(v2,32);
*
* Each dependency:
* B -> A
* C -> A, B
* D -> C
* F -> E
* G -> E, F
* H -> D, G
* I -> H
* J -> H, I
* K -> C, G
* L -> K
* M -> K, L
* N -> M
*
* Dependency graph:
* D -> C -> B -> A
* G -> F -> E
* J -> I -> H -> D, G
* N -> M -> L -> K -> C, G
*
* Resulting parallel friendly execution order:
* -> ABCDHIJ
* -> EFGKLMN
*/
// SIPROUND {
v0 += v1; v2 += v3;
v1 = (v1 << 13) | v1 >>> 51; v3 = (v3 << 16) | v3 >>> 48;
v1 ^= v0; v3 ^= v2;
v0 = (v0 << 32) | v0 >>> 32; v2 += v1;
v0 += v3; v1 = (v1 << 17) | v1 >>> 47;
v3 = (v3 << 21) | v3 >>> 43; v1 ^= v2;
v3 ^= v0; v2 = (v2 << 32) | v2 >>> 32;
// }
// SIPROUND {
v0 += v1; v2 += v3;
v1 = (v1 << 13) | v1 >>> 51; v3 = (v3 << 16) | v3 >>> 48;
v1 ^= v0; v3 ^= v2;
v0 = (v0 << 32) | v0 >>> 32; v2 += v1;
v0 += v3; v1 = (v1 << 17) | v1 >>> 47;
v3 = (v3 << 21) | v3 >>> 43; v1 ^= v2;
v3 ^= v0; v2 = (v2 << 32) | v2 >>> 32;
// }
v0 ^= m;
// }
}
// packing the last block to long, as LE 0-7 bytes + the length in the top byte
m = 0;
for (i = data.length - 1; i >= last; --i) {
m <<= 8; m |= (long) data[i];
}
m |= (long) data.length << 56;
// MSGROUND {
v3 ^= m;
// SIPROUND {
v0 += v1; v2 += v3;
v1 = (v1 << 13) | v1 >>> 51; v3 = (v3 << 16) | v3 >>> 48;
v1 ^= v0; v3 ^= v2;
v0 = (v0 << 32) | v0 >>> 32; v2 += v1;
v0 += v3; v1 = (v1 << 17) | v1 >>> 47;
v3 = (v3 << 21) | v3 >>> 43; v1 ^= v2;
v3 ^= v0; v2 = (v2 << 32) | v2 >>> 32;
// }
// SIPROUND {
v0 += v1; v2 += v3;
v1 = (v1 << 13) | v1 >>> 51; v3 = (v3 << 16) | v3 >>> 48;
v1 ^= v0; v3 ^= v2;
v0 = (v0 << 32) | v0 >>> 32; v2 += v1;
v0 += v3; v1 = (v1 << 17) | v1 >>> 47;
v3 = (v3 << 21) | v3 >>> 43; v1 ^= v2;
v3 ^= v0; v2 = (v2 << 32) | v2 >>> 32;
// }
v0 ^= m;
// }
// finishing...
v2 ^= 0xff;
// SIPROUND {
v0 += v1; v2 += v3;
v1 = (v1 << 13) | v1 >>> 51; v3 = (v3 << 16) | v3 >>> 48;
v1 ^= v0; v3 ^= v2;
v0 = (v0 << 32) | v0 >>> 32; v2 += v1;
v0 += v3; v1 = (v1 << 17) | v1 >>> 47;
v3 = (v3 << 21) | v3 >>> 43; v1 ^= v2;
v3 ^= v0; v2 = (v2 << 32) | v2 >>> 32;
// }
// SIPROUND {
v0 += v1; v2 += v3;
v1 = (v1 << 13) | v1 >>> 51; v3 = (v3 << 16) | v3 >>> 48;
v1 ^= v0; v3 ^= v2;
v0 = (v0 << 32) | v0 >>> 32; v2 += v1;
v0 += v3; v1 = (v1 << 17) | v1 >>> 47;
v3 = (v3 << 21) | v3 >>> 43; v1 ^= v2;
v3 ^= v0; v2 = (v2 << 32) | v2 >>> 32;
// }
// SIPROUND {
v0 += v1; v2 += v3;
v1 = (v1 << 13) | v1 >>> 51; v3 = (v3 << 16) | v3 >>> 48;
v1 ^= v0; v3 ^= v2;
v0 = (v0 << 32) | v0 >>> 32; v2 += v1;
v0 += v3; v1 = (v1 << 17) | v1 >>> 47;
v3 = (v3 << 21) | v3 >>> 43; v1 ^= v2;
v3 ^= v0; v2 = (v2 << 32) | v2 >>> 32;
// }
// SIPROUND {
v0 += v1; v2 += v3;
v1 = (v1 << 13) | v1 >>> 51; v3 = (v3 << 16) | v3 >>> 48;
v1 ^= v0; v3 ^= v2;
v0 = (v0 << 32) | v0 >>> 32; v2 += v1;
v0 += v3; v1 = (v1 << 17) | v1 >>> 47;
v3 = (v3 << 21) | v3 >>> 43; v1 ^= v2;
v3 ^= v0; v2 = (v2 << 32) | v2 >>> 32;
// }
return v0 ^ v1 ^ v2 ^ v3;
}
}

83
core/java/test/junit/net/i2p/util/SipHashInlineTest.java Normal file
View File

@ -0,0 +1,83 @@
import junit.framework.TestCase;
public class SipHashInlineTest extends TestCase {
private long[] EXPECTED = new long[] {
0x726fdb47dd0e0e31L,
0x74f839c593dc67fdL,
0x0d6c8009d9a94f5aL,
0x85676696d7fb7e2dL,
0xcf2794e0277187b7L,
0x18765564cd99a68dL,
0xcbc9466e58fee3ceL,
0xab0200f58b01d137L,
0x93f5f5799a932462L,
0x9e0082df0ba9e4b0L,
0x7a5dbbc594ddb9f3L,
0xf4b32f46226bada7L,
0x751e8fbc860ee5fbL,
0x14ea5627c0843d90L,
0xf723ca908e7af2eeL,
0xa129ca6149be45e5L,
0x3f2acc7f57c29bdbL,
0x699ae9f52cbe4794L,
0x4bc1b3f0968dd39cL,
0xbb6dc91da77961bdL,
0xbed65cf21aa2ee98L,
0xd0f2cbb02e3b67c7L,
0x93536795e3a33e88L,
0xa80c038ccd5ccec8L,
0xb8ad50c6f649af94L,
0xbce192de8a85b8eaL,
0x17d835b85bbb15f3L,
0x2f2e6163076bcfadL,
0xde4daaaca71dc9a5L,
0xa6a2506687956571L,
0xad87a3535c49ef28L,
0x32d892fad841c342L,
0x7127512f72f27cceL,
0xa7f32346f95978e3L,
0x12e0b01abb051238L,
0x15e034d40fa197aeL,
0x314dffbe0815a3b4L,
0x027990f029623981L,
0xcadcd4e59ef40c4dL,
0x9abfd8766a33735cL,
0x0e3ea96b5304a7d0L,
0xad0c42d6fc585992L,
0x187306c89bc215a9L,
0xd4a60abcf3792b95L,
0xf935451de4f21df2L,
0xa9538f0419755787L,
0xdb9acddff56ca510L,
0xd06c98cd5c0975ebL,
0xe612a3cb9ecba951L,
0xc766e62cfcadaf96L,
0xee64435a9752fe72L,
0xa192d576b245165aL,
0x0a8787bf8ecb74b2L,
0x81b3e73d20b49b6fL,
0x7fa8220ba3b2eceaL,
0x245731c13ca42499L,
0xb78dbfaf3a8d83bdL,
0xea1ad565322a1a0bL,
0x60e61c23a3795013L,
0x6606d7e446282b93L,
0x6ca4ecb15c5f91e1L,
0x9f626da15c9625f3L,
0xe51b38608ef25f57L,
0x958a324ceb064572L
};
// Ported from test vectors in siphash24.c at https://www.131002.net/siphash/siphash24.c
public void testVectors() {
long k0 = 0x0706050403020100L;
long k1 = 0x0f0e0d0c0b0a0908L;
for (int i = 0; i < EXPECTED.length; ++i) {
byte[] msg = new byte[i];
for (int j = 0; j < i; ++j) {
msg[j] = (byte) j;
}
assertEquals(EXPECTED[i], SipHashInline.hash24(k0, k1, msg));
}
}
}