HBASE-14063 Use BufferBackedCell in read path after HBASE-12213 and

HBASE-12295 (ram)

hbase-common/src/main/java/org/apache/hadoop/hbase/OffheapKeyOnlyKeyValue.java → hbase-common/src/main/java/org/apache/hadoop/hbase/ByteBufferedKeyOnlyKeyValue.java

@@ -1,5 +1,4 @@
 /**
- * Copyright The Apache Software Foundation
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
@@ -27,31 +26,55 @@
 
 /**
  * This is a key only Cell implementation which is identical to {@link KeyValue.KeyOnlyKeyValue}
- * with respect to key serialization but have its data in off heap memory.
+ * with respect to key serialization but have its data in the form of Byte buffer
+ * (onheap and offheap).
  */
 @InterfaceAudience.Private
-public class OffheapKeyOnlyKeyValue extends ByteBufferedCell {
+public class ByteBufferedKeyOnlyKeyValue extends ByteBufferedCell {
 
   private ByteBuffer buf;
   private int offset = 0; // offset into buffer where key starts at
   private int length = 0; // length of this.
   private short rowLen;
 
-  public OffheapKeyOnlyKeyValue(ByteBuffer buf, int offset, int length) {
-    assert buf.isDirect();
-    this.buf = buf;
+  /**
+   * Used in cases where we want to avoid lot of garbage by allocating new objects with different
+   * keys. Use the emtpy construtor and set the keys using {@link #setKey(ByteBuffer, int, int)}
+   */
+  public ByteBufferedKeyOnlyKeyValue() {
+  }
+
+  public ByteBufferedKeyOnlyKeyValue(ByteBuffer buf, int offset, int length) {
+    setKey(buf, offset, length);
+  }
+
+  /**
+   * A setter that helps to avoid object creation every time and whenever
+   * there is a need to create new OffheapKeyOnlyKeyValue.
+   * @param key
+   * @param offset
+   * @param length
+   */
+  public void setKey(ByteBuffer key, int offset, int length) {
+    this.buf = key;
     this.offset = offset;
     this.length = length;
     this.rowLen = ByteBufferUtils.toShort(this.buf, this.offset);
   }
 
   @Override
   public byte[] getRowArray() {
+    if (this.buf.hasArray()) {
+      return this.buf.array();
+    }
     return CellUtil.cloneRow(this);
   }
 
   @Override
   public int getRowOffset() {
+    if (this.buf.hasArray()) {
+      return getRowPositionInByteBuffer() + this.buf.arrayOffset();
+    }
     return 0;
   }
 
@@ -62,11 +85,17 @@ public short getRowLength() {
 
   @Override
   public byte[] getFamilyArray() {
+    if (this.buf.hasArray()) {
+      return this.buf.array();
+    }
     return CellUtil.cloneFamily(this);
   }
 
   @Override
   public int getFamilyOffset() {
+    if (this.buf.hasArray()) {
+      return getFamilyPositionInByteBuffer() + this.buf.arrayOffset();
+    }
     return 0;
   }
 
@@ -81,11 +110,17 @@ private byte getFamilyLength(int famLenPos) {
 
   @Override
   public byte[] getQualifierArray() {
+    if (this.buf.hasArray()) {
+      return this.buf.array();
+    }
     return CellUtil.cloneQualifier(this);
   }
 
   @Override
   public int getQualifierOffset() {
+    if (this.buf.hasArray()) {
+      return getQualifierPositionInByteBuffer() + this.buf.arrayOffset();
+    }
     return 0;
   }
 

hbase-common/src/main/java/org/apache/hadoop/hbase/KeyValue.java

@@ -37,9 +37,8 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.hadoop.hbase.classification.InterfaceAudience;
-import org.apache.hadoop.hbase.io.ByteBufferOutputStream;
 import org.apache.hadoop.hbase.io.HeapSize;
-import org.apache.hadoop.hbase.io.util.StreamUtils;
+import org.apache.hadoop.hbase.util.ByteBufferUtils;
 import org.apache.hadoop.hbase.util.Bytes;
 import org.apache.hadoop.hbase.util.ClassSize;
 import org.apache.hadoop.io.IOUtils;
@@ -2475,22 +2474,11 @@ public int write(OutputStream out, boolean withTags) throws IOException {
     if (!withTags) {
       length = this.getKeyLength() + this.getValueLength() + KEYVALUE_INFRASTRUCTURE_SIZE;
     }
-    writeInt(out, length);
+    ByteBufferUtils.putInt(out, length);
     out.write(this.bytes, this.offset, length);
     return length + Bytes.SIZEOF_INT;
   }
 
-  // This does same as DataOuput#writeInt (big-endian, etc.)
-  public static void writeInt(OutputStream out, int v) throws IOException {
-    // We have writeInt in ByteBufferOutputStream so that it can directly write int to underlying
-    // ByteBuffer in one step.
-    if (out instanceof ByteBufferOutputStream) {
-      ((ByteBufferOutputStream) out).writeInt(v);
-    } else {
-      StreamUtils.writeInt(out, v);
-    }
-  }
-
   /**
    * Comparator that compares row component only of a KeyValue.
    */

hbase-common/src/main/java/org/apache/hadoop/hbase/KeyValueUtil.java

@@ -589,11 +589,11 @@ public static void oswrite(final Cell cell, final OutputStream out, final boolea
       int tlen = cell.getTagsLength();
 
       // write total length
-      KeyValue.writeInt(out, length(rlen, flen, qlen, vlen, tlen, withTags));
+      ByteBufferUtils.putInt(out, length(rlen, flen, qlen, vlen, tlen, withTags));
       // write key length
-      KeyValue.writeInt(out, keyLength(rlen, flen, qlen));
+      ByteBufferUtils.putInt(out, keyLength(rlen, flen, qlen));
       // write value length
-      KeyValue.writeInt(out, vlen);
+      ByteBufferUtils.putInt(out, vlen);
       // Write rowkey - 2 bytes rk length followed by rowkey bytes
       StreamUtils.writeShort(out, rlen);
       out.write(cell.getRowArray(), cell.getRowOffset(), rlen);

hbase-common/src/main/java/org/apache/hadoop/hbase/NoTagsKeyValue.java

@@ -23,6 +23,7 @@
 import java.io.OutputStream;
 
 import org.apache.hadoop.hbase.classification.InterfaceAudience;
+import org.apache.hadoop.hbase.util.ByteBufferUtils;
 import org.apache.hadoop.hbase.util.Bytes;
 
 /**
@@ -43,7 +44,7 @@ public int getTagsLength() {
   public int write(OutputStream out, boolean withTags) throws IOException {
     // In KeyValueUtil#oswrite we do a Cell serialization as KeyValue. Any changes doing here, pls
     // check KeyValueUtil#oswrite also and do necessary changes.
-    writeInt(out, this.length);
+    ByteBufferUtils.putInt(out, this.length);
     out.write(this.bytes, this.offset, this.length);
     return this.length + Bytes.SIZEOF_INT;
   }