From ee7d22e90ce67de3e7ee92f309c048a1d4be0bbe Mon Sep 17 00:00:00 2001
From: Colin Patrick Mccabe <cmccabe@cloudera.com>
Date: Wed, 21 Jan 2015 16:33:02 -0800
Subject: [PATCH] HADOOP-11466. FastByteComparisons: do not use UNSAFE_COMPARER
 on the SPARC architecture because it is slower there (Suman Somasundar via
 Colin P.  McCabe)

---
 .../hadoop-common/CHANGES.txt                 |  4 ++++
 .../apache/hadoop/io/FastByteComparisons.java | 21 ++++++++++++++++++-
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/hadoop-common-project/hadoop-common/CHANGES.txt b/hadoop-common-project/hadoop-common/CHANGES.txt
index 66fd138cb07..abe699a397e 100644
--- a/hadoop-common-project/hadoop-common/CHANGES.txt
+++ b/hadoop-common-project/hadoop-common/CHANGES.txt
@@ -737,6 +737,10 @@ Release 2.7.0 - UNRELEASED
     HADOOP-11327. BloomFilter#not() omits the last bit, resulting in an
     incorrect filter (Eric Payne via jlowe)
 
+    HADOOP-11466. FastByteComparisons: do not use UNSAFE_COMPARER on the SPARC
+    architecture because it is slower there (Suman Somasundar via Colin P.
+    McCabe)
+
 Release 2.6.0 - 2014-11-18
 
   INCOMPATIBLE CHANGES
diff --git a/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/io/FastByteComparisons.java b/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/io/FastByteComparisons.java
index 3f5881b2dd6..a3fea3115cb 100644
--- a/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/io/FastByteComparisons.java
+++ b/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/io/FastByteComparisons.java
@@ -24,6 +24,9 @@
 
 import sun.misc.Unsafe;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
 import com.google.common.primitives.Longs;
 import com.google.common.primitives.UnsignedBytes;
 
@@ -33,6 +36,7 @@
  * class to be able to compare arrays that start at non-zero offsets.
  */
 abstract class FastByteComparisons {
+  static final Log LOG = LogFactory.getLog(FastByteComparisons.class);
 
   /**
    * Lexicographically compare two byte arrays.
@@ -71,6 +75,13 @@ private static class LexicographicalComparerHolder {
      * implementation if unable to do so.
      */
     static Comparer<byte[]> getBestComparer() {
+      if (System.getProperty("os.arch").equals("sparc")) {
+        if (LOG.isTraceEnabled()) {
+          LOG.trace("Lexicographical comparer selected for "
+              + "byte aligned system architecture");
+        }
+        return lexicographicalComparerJavaImpl();
+      }
       try {
         Class<?> theClass = Class.forName(UNSAFE_COMPARER_NAME);
 
@@ -78,8 +89,16 @@ static Comparer<byte[]> getBestComparer() {
         @SuppressWarnings("unchecked")
         Comparer<byte[]> comparer =
           (Comparer<byte[]>) theClass.getEnumConstants()[0];
+        if (LOG.isTraceEnabled()) {
+          LOG.trace("Unsafe comparer selected for "
+              + "byte unaligned system architecture");
+        }
         return comparer;
       } catch (Throwable t) { // ensure we really catch *everything*
+        if (LOG.isTraceEnabled()) {
+          LOG.trace(t.getMessage());
+          LOG.trace("Lexicographical comparer selected");
+        }
         return lexicographicalComparerJavaImpl();
       }
     }
@@ -234,4 +253,4 @@ public int compareTo(byte[] buffer1, int offset1, int length1,
       }
     }
   }
-}
\ No newline at end of file
+}