LUCENE-892: don't do extra buffer-to-buffer copies in CompoundFileReader.CSIndexInput

git-svn-id: https://svn.apache.org/repos/asf/lucene/java/trunk@553269 13f79535-47bb-0310-9956-ffa450edef68

CHANGES.txt

@@ -39,6 +39,9 @@ Optimizations
     postings per unique term and is directly flushed into a single
     segment.  (Mike McCandless)
  
+ 3. LUCENE-892: Fixed extra "buffer to buffer copy" that sometimes
+    takes place when using compound files.  (Mike McCandless)
+
 Documentation
 
 Build

src/java/org/apache/lucene/index/CompoundFileReader.java

@@ -237,7 +237,7 @@ class CompoundFileReader extends Directory {
               if(start + len > length)
                 throw new IOException("read past EOF");
               base.seek(fileOffset + start);
-              base.readBytes(b, offset, len);
+              base.readBytes(b, offset, len, false);
             }
         }
 

src/java/org/apache/lucene/store/BufferedIndexInput.java

@@ -84,8 +84,13 @@ public abstract class BufferedIndexInput extends IndexInput {
   }
 
   public void readBytes(byte[] b, int offset, int len) throws IOException {
+    readBytes(b, offset, len, true);
+  }
+
+  public void readBytes(byte[] b, int offset, int len, boolean useBuffer) throws IOException {
+
     if(len <= (bufferLength-bufferPosition)){
-      // the buffer contains enough data to satistfy this request
+      // the buffer contains enough data to satisfy this request
       if(len>0) // to allow b to be null if len is 0...
         System.arraycopy(buffer, bufferPosition, b, offset, len);
       bufferPosition+=len;
@@ -99,8 +104,9 @@ public abstract class BufferedIndexInput extends IndexInput {
         bufferPosition += available;
       }
       // and now, read the remaining 'len' bytes:
-      if(len<bufferSize){
-        // If the amount left to read is small enough, do it in the usual
+      if (useBuffer && len<bufferSize){
+        // If the amount left to read is small enough, and
+        // we are allowed to use our buffer, do it in the usual
         // buffered way: fill the buffer and copy from it:
         refill();
         if(bufferLength<len){
@@ -112,10 +118,13 @@ public abstract class BufferedIndexInput extends IndexInput {
           bufferPosition=len;
         }
       } else {
-        // The amount left to read is larger than the buffer - there's no
-        // performance reason not to read it all at once. Note that unlike
-        // the previous code of this function, there is no need to do a seek
-        // here, because there's no need to reread what we had in the buffer.
+        // The amount left to read is larger than the buffer
+        // or we've been asked to not use our buffer -
+        // there's no performance reason not to read it all
+        // at once. Note that unlike the previous code of
+        // this function, there is no need to do a seek
+        // here, because there's no need to reread what we
+        // had in the buffer.
         long after = bufferStart+bufferPosition+len;
         if(after > length())
           throw new IOException("read past EOF");

src/java/org/apache/lucene/store/IndexInput.java

@@ -40,6 +40,25 @@ public abstract class IndexInput implements Cloneable {
   public abstract void readBytes(byte[] b, int offset, int len)
     throws IOException;
 
+  /** Reads a specified number of bytes into an array at the
+   * specified offset with control over whether the read
+   * should be buffered (callers who have their own buffer
+   * should pass in "false" for useBuffer).  Currently only
+   * {@link BufferedIndexInput} respects this parameter.
+   * @param b the array to read bytes into
+   * @param offset the offset in the array to start storing bytes
+   * @param len the number of bytes to read
+   * @param useBuffer set to false if the caller will handle
+   * buffering.
+   * @see IndexOutput#writeBytes(byte[],int)
+   */
+  public void readBytes(byte[] b, int offset, int len, boolean useBuffer)
+    throws IOException
+  {
+    // Default to ignoring useBuffer entirely
+    readBytes(b, offset, len);
+  }
+
   /** Reads four bytes and returns an int.
    * @see IndexOutput#writeInt(int)
    */