Apache/hbase
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

HBASE-4206 jenkins hash implementation uses longs unnecessarily

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/hbase/trunk@1165127 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Michael Stack 2011-09-04 22:58:11 +00:00
parent f2552ba5fd
commit ab61758985
2 changed files with 47 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CHANGES.txt
View File

@ -441,6 +441,8 @@ Release 0.91.0 - Unreleased
HBASE-4257 Limit the number of regions in transitions displayed on HBASE-4257 Limit the number of regions in transitions displayed on
master webpage. (todd) master webpage. (todd)
HBASE-1730 Online Schema Changes HBASE-1730 Online Schema Changes
HBASE-4206 jenkins hash implementation uses longs unnecessarily
(Ron Yang)
TASKS TASKS
HBASE-3559 Move report of split to master OFF the heartbeat channel HBASE-3559 Move report of split to master OFF the heartbeat channel

94
src/main/java/org/apache/hadoop/hbase/util/JenkinsHash.java
View File

@ -20,6 +20,8 @@
package org.apache.hadoop.hbase.util; package org.apache.hadoop.hbase.util;
import static java.lang.Integer.rotateLeft;
import java.io.FileInputStream; import java.io.FileInputStream;
import java.io.IOException; import java.io.IOException;
@ -39,8 +41,7 @@ import java.io.IOException;
* Dr. Dobbs Article</a> * Dr. Dobbs Article</a>
*/ */
public class JenkinsHash extends Hash { public class JenkinsHash extends Hash {
private static long INT_MASK = 0x00000000ffffffffL; private static final int BYTE_MASK = 0xff;
private static long BYTE_MASK = 0x00000000000000ffL;
private static JenkinsHash _instance = new JenkinsHash(); private static JenkinsHash _instance = new JenkinsHash();
@ -48,11 +49,6 @@ public class JenkinsHash extends Hash {
return _instance; return _instance;
} }
private static long rot(long val, int pos) {
return ((Integer.rotateLeft(
(int)(val & INT_MASK), pos)) & INT_MASK);
}
/** /**
* taken from hashlittle() -- hash a variable-length key into a 32-bit value * taken from hashlittle() -- hash a variable-length key into a 32-bit value
* *
@ -82,23 +78,22 @@ public class JenkinsHash extends Hash {
@SuppressWarnings("fallthrough") @SuppressWarnings("fallthrough")
public int hash(byte[] key, int off, int nbytes, int initval) { public int hash(byte[] key, int off, int nbytes, int initval) {
int length = nbytes; int length = nbytes;
long a, b, c; // We use longs because we don't have unsigned ints int a, b, c;
a = b = c = (0x00000000deadbeefL + length + initval) & INT_MASK; a = b = c = 0xdeadbeef + length + initval;
int offset = off; int offset = off;
for (; length > 12; offset += 12, length -= 12) { for (; length > 12; offset += 12, length -= 12) {
//noinspection PointlessArithmeticExpression a += (key[offset] & BYTE_MASK);
a = (a + (key[offset + 0] & BYTE_MASK)) & INT_MASK; a += ((key[offset + 1] & BYTE_MASK) << 8);
a = (a + (((key[offset + 1] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK; a += ((key[offset + 2] & BYTE_MASK) << 16);
a = (a + (((key[offset + 2] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK; a += ((key[offset + 3] & BYTE_MASK) << 24);
a = (a + (((key[offset + 3] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK; b += (key[offset + 4] & BYTE_MASK);
b = (b + (key[offset + 4] & BYTE_MASK)) & INT_MASK; b += ((key[offset + 5] & BYTE_MASK) << 8);
b = (b + (((key[offset + 5] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK; b += ((key[offset + 6] & BYTE_MASK) << 16);
b = (b + (((key[offset + 6] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK; b += ((key[offset + 7] & BYTE_MASK) << 24);
b = (b + (((key[offset + 7] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK; c += (key[offset + 8] & BYTE_MASK);
c = (c + (key[offset + 8] & BYTE_MASK)) & INT_MASK; c += ((key[offset + 9] & BYTE_MASK) << 8);
c = (c + (((key[offset + 9] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK; c += ((key[offset + 10] & BYTE_MASK) << 16);
c = (c + (((key[offset + 10] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK; c += ((key[offset + 11] & BYTE_MASK) << 24);
c = (c + (((key[offset + 11] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
/* /*
* mix -- mix 3 32-bit values reversibly. * mix -- mix 3 32-bit values reversibly.
@ -154,44 +149,44 @@ public class JenkinsHash extends Hash {
* *
* mix(a,b,c); * mix(a,b,c);
*/ */
a = (a - c) & INT_MASK; a ^= rot(c, 4); c = (c + b) & INT_MASK; a -= c; a ^= rotateLeft(c, 4); c += b;
b = (b - a) & INT_MASK; b ^= rot(a, 6); a = (a + c) & INT_MASK; b -= a; b ^= rotateLeft(a, 6); a += c;
c = (c - b) & INT_MASK; c ^= rot(b, 8); b = (b + a) & INT_MASK; c -= b; c ^= rotateLeft(b, 8); b += a;
a = (a - c) & INT_MASK; a ^= rot(c,16); c = (c + b) & INT_MASK; a -= c; a ^= rotateLeft(c, 16); c += b;
b = (b - a) & INT_MASK; b ^= rot(a,19); a = (a + c) & INT_MASK; b -= a; b ^= rotateLeft(a, 19); a += c;
c = (c - b) & INT_MASK; c ^= rot(b, 4); b = (b + a) & INT_MASK; c -= b; c ^= rotateLeft(b, 4); b += a;
} }
//-------------------------------- last block: affect all 32 bits of (c) //-------------------------------- last block: affect all 32 bits of (c)
switch (length) { // all the case statements fall through switch (length) { // all the case statements fall through
case 12: case 12:
c = (c + (((key[offset + 11] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK; c += ((key[offset + 11] & BYTE_MASK) << 24);
case 11: case 11:
c = (c + (((key[offset + 10] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK; c += ((key[offset + 10] & BYTE_MASK) << 16);
case 10: case 10:
c = (c + (((key[offset + 9] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK; c += ((key[offset + 9] & BYTE_MASK) << 8);
case 9: case 9:
c = (c + (key[offset + 8] & BYTE_MASK)) & INT_MASK; c += (key[offset + 8] & BYTE_MASK);
case 8: case 8:
b = (b + (((key[offset + 7] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK; b += ((key[offset + 7] & BYTE_MASK) << 24);
case 7: case 7:
b = (b + (((key[offset + 6] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK; b += ((key[offset + 6] & BYTE_MASK) << 16);
case 6: case 6:
b = (b + (((key[offset + 5] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK; b += ((key[offset + 5] & BYTE_MASK) << 8);
case 5: case 5:
b = (b + (key[offset + 4] & BYTE_MASK)) & INT_MASK; b += (key[offset + 4] & BYTE_MASK);
case 4: case 4:
a = (a + (((key[offset + 3] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK; a += ((key[offset + 3] & BYTE_MASK) << 24);
case 3: case 3:
a = (a + (((key[offset + 2] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK; a += ((key[offset + 2] & BYTE_MASK) << 16);
case 2: case 2:
a = (a + (((key[offset + 1] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK; a += ((key[offset + 1] & BYTE_MASK) << 8);
case 1: case 1:
//noinspection PointlessArithmeticExpression //noinspection PointlessArithmeticExpression
a = (a + (key[offset + 0] & BYTE_MASK)) & INT_MASK; a += (key[offset + 0] & BYTE_MASK);
break; break;
case 0: case 0:
return (int)(c & INT_MASK); return c;
} }
/* /*
* final -- final mixing of 3 32-bit values (a,b,c) into c * final -- final mixing of 3 32-bit values (a,b,c) into c
@ -230,15 +225,14 @@ public class JenkinsHash extends Hash {
* } * }
* *
*/ */
c ^= b; c = (c - rot(b,14)) & INT_MASK; c ^= b; c -= rotateLeft(b, 14);
a ^= c; a = (a - rot(c,11)) & INT_MASK; a ^= c; a -= rotateLeft(c, 11);
b ^= a; b = (b - rot(a,25)) & INT_MASK; b ^= a; b -= rotateLeft(a, 25);
c ^= b; c = (c - rot(b,16)) & INT_MASK; c ^= b; c -= rotateLeft(b, 16);
a ^= c; a = (a - rot(c,4)) & INT_MASK; a ^= c; a -= rotateLeft(c, 4);
b ^= a; b = (b - rot(a,14)) & INT_MASK; b ^= a; b -= rotateLeft(a, 14);
c ^= b; c = (c - rot(b,24)) & INT_MASK; c ^= b; c -= rotateLeft(b, 24);
return c;
return (int)(c & INT_MASK);
} }
/** /**