Mailing-List: contact commits-help@hbase.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@hbase.apache.org
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
From: anoopsamjohn@apache.org
To: commits@hbase.apache.org
Message-Id: <ba912fdcdaac4934af8e5e350ea76f86@git.apache.org>
Subject: hbase git commit: HBASE-13496 Make Bytes::compareTo inlineable.
Date: Thu, 23 Apr 2015 05:15:27 +0000 (UTC)

Repository: hbase
Updated Branches:
  refs/heads/branch-1.0 0184a5c99 -> 3d285cbad


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/3d285cba
Tree: http://git-wip-us.apache.org/repos/asf/hbase/tree/3d285cba
Diff: http://git-wip-us.apache.org/repos/asf/hbase/diff/3d285cba

Branch: refs/heads/branch-1.0
Commit: 3d285cbad80fd9a0e230867df2396d0061e223eb
Parents: 0184a5c
Author: anoopsjohn <anoopsamjohn@gmail.com>
Authored: Thu Apr 23 10:36:08 2015 +0530
Committer: anoopsjohn <anoopsamjohn@gmail.com>
Committed: Thu Apr 23 10:45:09 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/3d285cba/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 dd666e6..05d5ad1 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
@@ -1315,24 +1315,45 @@ public class 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);
       }
 
@@ -1376,40 +1397,30 @@ public class 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;