Index: src/test/org/apache/lucene/search/TestSort.java
===================================================================
--- src/test/org/apache/lucene/search/TestSort.java	(revision 724945)
+++ src/test/org/apache/lucene/search/TestSort.java	(working copy)
@@ -120,6 +120,8 @@
 	throws IOException {
 		RAMDirectory indexStore = new RAMDirectory ();
 		IndexWriter writer = new IndexWriter (indexStore, new SimpleAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
+    writer.setMaxBufferedDocs(2);
+    writer.setMergeFactor(1000);
 		for (int i=0; i<data.length; ++i) {
 			if (((i%2)==0 && even) || ((i%2)==1 && odd)) {
 				Document doc = new Document();
@@ -139,7 +141,7 @@
 				writer.addDocument (doc);
 			}
 		}
-		writer.optimize ();
+		//writer.optimize ();
 		writer.close ();
 		return new IndexSearcher (indexStore);
 	}
Index: src/test/org/apache/lucene/index/TestIndexReaderReopen.java
===================================================================
--- src/test/org/apache/lucene/index/TestIndexReaderReopen.java	(revision 724945)
+++ src/test/org/apache/lucene/index/TestIndexReaderReopen.java	(working copy)
@@ -320,7 +320,7 @@
       assertRefCountEquals(1, reader0);
 
       assertTrue(reader0 instanceof MultiSegmentReader);
-      SegmentReader[] subReaders0 = ((MultiSegmentReader) reader0).getSubReaders();
+      IndexReader[] subReaders0 = ((MultiSegmentReader) reader0).getSubReaders();
       for (int i = 0; i < subReaders0.length; i++) {
         assertRefCountEquals(1, subReaders0[i]);
       }
@@ -332,7 +332,7 @@
       
       IndexReader reader1 = refreshReader(reader0, true).refreshedReader;
       assertTrue(reader1 instanceof MultiSegmentReader);
-      SegmentReader[] subReaders1 = ((MultiSegmentReader) reader1).getSubReaders();
+      IndexReader[] subReaders1 = ((MultiSegmentReader) reader1).getSubReaders();
       assertEquals(subReaders0.length, subReaders1.length);
       
       for (int i = 0; i < subReaders0.length; i++) {
@@ -349,7 +349,7 @@
 
       IndexReader reader2 = refreshReader(reader1, true).refreshedReader;
       assertTrue(reader2 instanceof MultiSegmentReader);
-      SegmentReader[] subReaders2 = ((MultiSegmentReader) reader2).getSubReaders();
+      IndexReader[] subReaders2 = ((MultiSegmentReader) reader2).getSubReaders();
       assertEquals(subReaders1.length, subReaders2.length);
       
       for (int i = 0; i < subReaders2.length; i++) {
@@ -373,7 +373,7 @@
       
       IndexReader reader3 = refreshReader(reader0, true).refreshedReader;
       assertTrue(reader3 instanceof MultiSegmentReader);
-      SegmentReader[] subReaders3 = ((MultiSegmentReader) reader3).getSubReaders();
+      IndexReader[] subReaders3 = ((MultiSegmentReader) reader3).getSubReaders();
       assertEquals(subReaders3.length, subReaders0.length);
       
       // try some permutations
@@ -945,7 +945,7 @@
     
     if (checkSubReaders) {
       if (reader instanceof MultiSegmentReader) {
-        SegmentReader[] subReaders = ((MultiSegmentReader) reader).getSubReaders();
+        IndexReader[] subReaders = ((MultiSegmentReader) reader).getSubReaders();
         for (int i = 0; i < subReaders.length; i++) {
           assertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
         }
@@ -971,7 +971,7 @@
     reader.ensureOpen();
     
     if (reader instanceof MultiSegmentReader) {
-      SegmentReader[] subReaders = ((MultiSegmentReader) reader).getSubReaders();
+      IndexReader[] subReaders = ((MultiSegmentReader) reader).getSubReaders();
       for (int i = 0; i < subReaders.length; i++) {
         assertReaderOpen(subReaders[i]);
       }
Index: src/java/org/apache/lucene/search/MultiReaderTopFieldDocCollector.java
===================================================================
--- src/java/org/apache/lucene/search/MultiReaderTopFieldDocCollector.java	(revision 0)
+++ src/java/org/apache/lucene/search/MultiReaderTopFieldDocCollector.java	(revision 0)
@@ -0,0 +1,64 @@
+package org.apache.lucene.search;
+
+import java.io.IOException;
+
+import org.apache.lucene.index.IndexReader;
+
+public class MultiReaderTopFieldDocCollector extends TopDocCollector {
+
+  private FieldDoc reusableFD;
+  private int docBase;
+
+  /**
+   * Construct to collect a given number of hits.
+   * 
+   * @param reader
+   *          the index to be searched
+   * @param sort
+   *          the sort criteria
+   * @param numHits
+   *          the maximum number of hits to collect
+   */
+  public MultiReaderTopFieldDocCollector(IndexReader reader, Sort sort,
+      int numHits) throws IOException {
+    super(new FieldSortedHitQueue(reader, sort.fields, numHits));
+  }
+
+  public void setDocBase(int base) {
+    docBase = base;
+  }
+
+  // javadoc inherited
+  public void collect(int doc, float score) {
+    if (score > 0.0f) {
+      totalHits++;
+      if (reusableFD == null)
+        reusableFD = new FieldDoc(doc + docBase, score);
+      else {
+        // Whereas TopDocCollector can skip this if the
+        // score is not competitive, we cannot because the
+        // comparators in the FieldSortedHitQueue.lessThan
+        // aren't in general congruent with "higher score
+        // wins"
+        reusableFD.score = score;
+        reusableFD.doc = doc + docBase;
+      }
+      //System.out.println("collect:" + (doc + docBase) + " start:" + docBase);
+      reusableFD = (FieldDoc) hq.insertWithOverflow(reusableFD);
+    }
+  }
+
+  // javadoc inherited
+  public TopDocs topDocs() {
+    FieldSortedHitQueue fshq = (FieldSortedHitQueue) hq;
+    ScoreDoc[] scoreDocs = new ScoreDoc[fshq.size()];
+    for (int i = fshq.size() - 1; i >= 0; i--) {
+      // put docs in array
+      scoreDocs[i] = fshq.fillFields((FieldDoc) fshq.pop());
+      //System.out.println("score doc i:" + i + " " + scoreDocs[i].doc);
+    }
+
+    return new TopFieldDocs(totalHits, scoreDocs, fshq.getFields(), fshq
+        .getMaxScore());
+  }
+}

Property changes on: src/java/org/apache/lucene/search/MultiReaderTopFieldDocCollector.java
___________________________________________________________________
Name: svn:eol-style
   + native

Index: src/java/org/apache/lucene/search/IndexSearcher.java
===================================================================
--- src/java/org/apache/lucene/search/IndexSearcher.java	(revision 724945)
+++ src/java/org/apache/lucene/search/IndexSearcher.java	(working copy)
@@ -22,9 +22,12 @@
 import org.apache.lucene.index.CorruptIndexException;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.Term;
+import org.apache.lucene.index.TermEnum;
 import org.apache.lucene.store.Directory;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
 /** Implements search over a single IndexReader.
  *
@@ -117,16 +120,52 @@
   public TopFieldDocs search(Weight weight, Filter filter, final int nDocs,
                              Sort sort)
       throws IOException {
+    IndexReader[] readers = reader.getSubReaders();
+    if (readers.length <= 1) {
+      TopFieldDocCollector collector = new TopFieldDocCollector(reader, sort,
+          nDocs);
+      search(weight, filter, collector);
 
-    TopFieldDocCollector collector =
-      new TopFieldDocCollector(reader, sort, nDocs);
-    search(weight, filter, collector);
-    return (TopFieldDocs)collector.topDocs();
+      TopFieldDocs topdocs = (TopFieldDocs) collector.topDocs();
+
+      return topdocs;
+    }
+
+    return search(readers, weight, filter, nDocs, sort);
   }
+  
+  private TopFieldDocs search (IndexReader[] readers, Weight weight, Filter filter, int n, Sort sort)
+  throws IOException {
+    
+    int[] starts = new int[readers.length + 1];   // build starts array
+    int maxDoc = 0;
+    for (int i = 0; i < readers.length; i++) {
+      starts[i] = maxDoc;
+      maxDoc += readers[i].maxDoc();          // compute maxDocs
+    }
+    starts[readers.length] = maxDoc;
+    
+    MultiReaderTopFieldDocCollector collector = new MultiReaderTopFieldDocCollector(reader, sort, n);
+    
+    for (int i = 0; i < readers.length; i++) { // search each searcher
+      collector.setDocBase(starts[i]);
+      search (readers[i], weight, filter, collector);
+    }
+    
+    TopFieldDocs topdocs = (TopFieldDocs) collector.topDocs();
 
+    return topdocs;
+  }
+  
   // inherit javadoc
   public void search(Weight weight, Filter filter,
                      final HitCollector results) throws IOException {
+    search(reader, weight, filter, results);
+  }
+  
+  // inherit javadoc
+  public void search(IndexReader reader, Weight weight, Filter filter,
+                     final HitCollector results) throws IOException {
 
     Scorer scorer = weight.scorer(reader);
     if (scorer == null)
@@ -169,4 +208,5 @@
   public Explanation explain(Weight weight, int doc) throws IOException {
     return weight.explain(reader, doc);
   }
+ 
 }
Index: src/java/org/apache/lucene/index/ParallelReader.java
===================================================================
--- src/java/org/apache/lucene/index/ParallelReader.java	(revision 724945)
+++ src/java/org/apache/lucene/index/ParallelReader.java	(working copy)
@@ -421,7 +421,7 @@
   }
 
   // for testing
-  IndexReader[] getSubReaders() {
+  public IndexReader[] getSubReaders() {
     return (IndexReader[]) readers.toArray(new IndexReader[readers.size()]);
   }
 
Index: src/java/org/apache/lucene/index/MultiReader.java
===================================================================
--- src/java/org/apache/lucene/index/MultiReader.java	(revision 724945)
+++ src/java/org/apache/lucene/index/MultiReader.java	(working copy)
@@ -366,7 +366,7 @@
   }
   
   // for testing
-  IndexReader[] getSubReaders() {
+  public IndexReader[] getSubReaders() {
     return subReaders;
   }
 }
Index: src/java/org/apache/lucene/index/IndexReader.java
===================================================================
--- src/java/org/apache/lucene/index/IndexReader.java	(revision 724945)
+++ src/java/org/apache/lucene/index/IndexReader.java	(working copy)
@@ -1134,4 +1134,8 @@
   public static Collection listCommits(Directory dir) throws IOException {
     return DirectoryIndexReader.listCommits(dir);
   }
+
+  public IndexReader[] getSubReaders() {
+    return new IndexReader[] {this};
+  }
 }
Index: src/java/org/apache/lucene/index/MultiSegmentReader.java
===================================================================
--- src/java/org/apache/lucene/index/MultiSegmentReader.java	(revision 724945)
+++ src/java/org/apache/lucene/index/MultiSegmentReader.java	(working copy)
@@ -433,7 +433,7 @@
   } 
   
   // for testing
-  SegmentReader[] getSubReaders() {
+  public IndexReader[] getSubReaders() {
     return subReaders;
   }
 
Index: contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTask.java
===================================================================
--- contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTask.java	(revision 724945)
+++ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTask.java	(working copy)
@@ -95,7 +95,7 @@
       } else {
         hits = searcher.search(q);
       }
-      //System.out.println("searched: "+q);
+      //System.out.println("searched: "+q + " hitcount=" + hits.length());
 
       if (withTraverse() && hits != null) {
         int traversalSize = Math.min(hits.length(), traversalSize());