Repository: hbase Updated Branches: refs/heads/master 6c427175b -> a4202879a
HBASE-13496 Make Bytes::compareTo inlineable. Project: http://git-wip-us.apache.org/repos/asf/hbase/repo Commit: http://git-wip-us.apache.org/repos/asf/hbase/commit/a4202879 Tree: http://git-wip-us.apache.org/repos/asf/hbase/tree/a4202879 Diff: http://git-wip-us.apache.org/repos/asf/hbase/diff/a4202879 Branch: refs/heads/master Commit: a4202879ad12d797d8c05f3174b824e06cd74279 Parents: 6c42717 Author: anoopsjohn <anoopsamj...@gmail.com> Authored: Thu Apr 23 10:36:08 2015 +0530 Committer: anoopsjohn <anoopsamj...@gmail.com> Committed: Thu Apr 23 10:36:08 2015 +0530 ---------------------------------------------------------------------- .../org/apache/hadoop/hbase/util/Bytes.java | 45 ++++++++++++-------- 1 file changed, 28 insertions(+), 17 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/hbase/blob/a4202879/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Bytes.java ---------------------------------------------------------------------- diff --git a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Bytes.java b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Bytes.java index 21b0a99..f294ec9 100644 --- a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Bytes.java +++ b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Bytes.java @@ -1542,24 +1542,45 @@ public class Bytes implements Comparable<Bytes> { /** * Returns true if x1 is less than x2, when both values are treated as * unsigned long. + * Both values are passed as is read by Unsafe. When platform is Little Endian, have to + * convert to corresponding Big Endian value and then do compare. We do all writes in + * Big Endian format. */ static boolean lessThanUnsignedLong(long x1, long x2) { + if (littleEndian) { + x1 = Long.reverseBytes(x1); + x2 = Long.reverseBytes(x2); + } return (x1 + Long.MIN_VALUE) < (x2 + Long.MIN_VALUE); } /** * Returns true if x1 is less than x2, when both values are treated as * unsigned int. + * Both values are passed as is read by Unsafe. When platform is Little Endian, have to + * convert to corresponding Big Endian value and then do compare. We do all writes in + * Big Endian format. */ static boolean lessThanUnsignedInt(int x1, int x2) { + if (littleEndian) { + x1 = Integer.reverseBytes(x1); + x2 = Integer.reverseBytes(x2); + } return (x1 & 0xffffffffL) < (x2 & 0xffffffffL); } /** * Returns true if x1 is less than x2, when both values are treated as * unsigned short. + * Both values are passed as is read by Unsafe. When platform is Little Endian, have to + * convert to corresponding Big Endian value and then do compare. We do all writes in + * Big Endian format. */ static boolean lessThanUnsignedShort(short x1, short x2) { + if (littleEndian) { + x1 = Short.reverseBytes(x1); + x2 = Short.reverseBytes(x2); + } return (x1 & 0xffff) < (x2 & 0xffff); } @@ -1603,40 +1624,30 @@ public class Bytes implements Comparable<Bytes> { * time is no slower than comparing 4 bytes at a time even on 32-bit. * On the other hand, it is substantially faster on 64-bit. */ - for (int i = 0; i < minWords * SIZEOF_LONG; i += SIZEOF_LONG) { + // This is the end offset of long parts. + int j = minWords << 3; // Same as minWords * SIZEOF_LONG + for (int i = 0; i < j; i += SIZEOF_LONG) { long lw = theUnsafe.getLong(buffer1, offset1Adj + (long) i); long rw = theUnsafe.getLong(buffer2, offset2Adj + (long) i); long diff = lw ^ rw; - if(littleEndian){ - lw = Long.reverseBytes(lw); - rw = Long.reverseBytes(rw); - } if (diff != 0) { return lessThanUnsignedLong(lw, rw) ? -1 : 1; } } - int offset = minWords * SIZEOF_LONG; + int offset = j; if (minLength - offset >= SIZEOF_INT) { int il = theUnsafe.getInt(buffer1, offset1Adj + offset); int ir = theUnsafe.getInt(buffer2, offset2Adj + offset); - if(littleEndian){ - il = Integer.reverseBytes(il); - ir = Integer.reverseBytes(ir); - } - if(il != ir){ + if (il != ir) { return lessThanUnsignedInt(il, ir) ? -1: 1; } - offset += SIZEOF_INT; + offset += SIZEOF_INT; } if (minLength - offset >= SIZEOF_SHORT) { short sl = theUnsafe.getShort(buffer1, offset1Adj + offset); short sr = theUnsafe.getShort(buffer2, offset2Adj + offset); - if(littleEndian){ - sl = Short.reverseBytes(sl); - sr = Short.reverseBytes(sr); - } - if(sl != sr){ + if (sl != sr) { return lessThanUnsignedShort(sl, sr) ? -1: 1; } offset += SIZEOF_SHORT;
