Index: contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/OpenIndexTask.java
===================================================================
--- contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/OpenIndexTask.java	(revision 608075)
+++ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/OpenIndexTask.java	(working copy)
@@ -61,12 +61,8 @@
     IndexWriter writer = new IndexWriter(dir, autoCommit, analyzer, false);
 
     // must update params for newly opened writer
-    if (flushAtRAMUsage > 0)
-      writer.setRAMBufferSizeMB(flushAtRAMUsage);
-    else if (mxbf != 0)
-      writer.setMaxBufferedDocs(mxbf);
-    else
-      throw new RuntimeException("either max.buffered or ram.flush.mb must be non-zero");
+    writer.setRAMBufferSizeMB(flushAtRAMUsage);
+    writer.setMaxBufferedDocs(mxbf);
     writer.setMaxFieldLength(mxfl);
     writer.setMergeFactor(mrgf);
     writer.setUseCompoundFile(cmpnd); // this one redundant?
Index: contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/CreateIndexTask.java
===================================================================
--- contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/CreateIndexTask.java	(revision 608075)
+++ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/CreateIndexTask.java	(working copy)
@@ -57,12 +57,8 @@
     iw.setUseCompoundFile(cmpnd);
     iw.setMergeFactor(mrgf);
     iw.setMaxFieldLength(mxfl);
-    if (flushAtRAMUsage > 0)
-      iw.setRAMBufferSizeMB(flushAtRAMUsage);
-    else if (mxbf != 0)
-      iw.setMaxBufferedDocs(mxbf);
-    else
-      throw new RuntimeException("either max.buffered or ram.flush.mb must be non-zero");
+    iw.setRAMBufferSizeMB(flushAtRAMUsage);
+    iw.setMaxBufferedDocs(mxbf);
     getRunData().setIndexWriter(iw);
     return 1;
   }
Index: contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/TaskSequence.java
===================================================================
--- contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/TaskSequence.java	(revision 608075)
+++ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/TaskSequence.java	(working copy)
@@ -38,6 +38,8 @@
   private String seqName;
   private boolean exhausted = false;
   private boolean resetExhausted = false;
+  private PerfTask[] tasksArray;
+  private boolean anyExhaustedTasks;
   
   public TaskSequence (PerfRunData runData, String name, TaskSequence parent, boolean parallel) {
     super(runData);
@@ -49,6 +51,18 @@
     tasks = new ArrayList();
   }
 
+  private void initTasksArray() {
+    if (tasksArray == null) {
+      final int numTasks = tasks.size();
+      tasksArray = new PerfTask[numTasks];
+      for(int k=0;k<numTasks;k++) {
+        tasksArray[k] = (PerfTask) tasks.get(k);
+        anyExhaustedTasks |= tasksArray[k] instanceof ResetInputsTask;
+        anyExhaustedTasks |= tasksArray[k] instanceof TaskSequence;
+      }
+    }
+  }
+
   /**
    * @return Returns the parallel.
    */
@@ -92,7 +106,7 @@
    * @see org.apache.lucene.benchmark.byTask.tasks.PerfTask#doLogic()
    */
   public int doLogic() throws Exception {
-    resetExhausted = false;
+    exhausted = resetExhausted = false;
     return ( parallel ? doParallelTasks() : doSerialTasks());
   }
 
@@ -101,18 +115,16 @@
       return doSerialTasksWithRate();
     }
     
+    initTasksArray();
     int count = 0;
     
-    final int numTasks = tasks.size();
-    final PerfTask[] tasksArray = new PerfTask[numTasks];
-    for(int k=0;k<numTasks;k++)
-      tasksArray[k] = (PerfTask) tasks.get(k);
-
     for (int k=0; (repetitions==REPEAT_EXHAUST && !exhausted) || k<repetitions; k++) {
-      for(int l=0;l<numTasks;l++)
+      for(int l=0;l<tasksArray.length;l++)
         try {
-          count += tasksArray[l].runAndMaybeStats(letChildReport);
-          updateExhausted(tasksArray[l]);
+          final PerfTask task = tasksArray[l];
+          count += task.runAndMaybeStats(letChildReport);
+          if (anyExhaustedTasks)
+            updateExhausted(task);
         } catch (NoMoreDataException e) {
           exhausted = true;
         }
@@ -121,12 +133,13 @@
   }
 
   private int doSerialTasksWithRate() throws Exception {
+    initTasksArray();
     long delayStep = (perMin ? 60000 : 1000) /rate;
     long nextStartTime = System.currentTimeMillis();
     int count = 0;
     for (int k=0; (repetitions==REPEAT_EXHAUST && !exhausted) || k<repetitions; k++) {
-      for (Iterator it = tasks.iterator(); it.hasNext();) {
-        PerfTask task = (PerfTask) it.next();
+      for (int l=0;l<tasksArray.length;l++) {
+        final PerfTask task = tasksArray[l];
         long waitMore = nextStartTime - System.currentTimeMillis();
         if (waitMore > 0) {
           //System.out.println("wait: "+waitMore+" for rate: "+ratePerMin+" (delayStep="+delayStep+")");
@@ -135,7 +148,8 @@
         nextStartTime += delayStep; // this aims at avarage rate. 
         try {
           count += task.runAndMaybeStats(letChildReport);
-          updateExhausted(task);
+          if (anyExhaustedTasks)
+            updateExhausted(task);
         } catch (NoMoreDataException e) {
           exhausted = true;
         }
@@ -149,28 +163,27 @@
     if (task instanceof ResetInputsTask) {
       exhausted = false;
       resetExhausted = true;
-    } else {
-      if (task instanceof TaskSequence) {
-        TaskSequence t = (TaskSequence) task;
-        if (t.resetExhausted) {
-          exhausted = false;
-          resetExhausted = true;
-          t.resetExhausted = false;
-        } else {
-          exhausted |= t.exhausted;
-        }
+    } else if (task instanceof TaskSequence) {
+      TaskSequence t = (TaskSequence) task;
+      if (t.resetExhausted) {
+        exhausted = false;
+        resetExhausted = true;
+        t.resetExhausted = false;
+      } else {
+        exhausted |= t.exhausted;
       }
     }
   }
 
   private int doParallelTasks() throws Exception {
+    initTasksArray();
     final int count [] = {0};
     Thread t[] = new Thread [repetitions * tasks.size()];
     // prepare threads
     int indx = 0;
     for (int k=0; k<repetitions; k++) {
-      for (int i = 0; i < tasks.size(); i++) {
-        final PerfTask task = (PerfTask) ((PerfTask) tasks.get(i)).clone();
+      for (int i = 0; i < tasksArray.length; i++) {
+        final PerfTask task = (PerfTask) tasksArray[i].clone();
         t[indx++] = new Thread() {
           public void run() {
             int n;
Index: contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/LineDocMaker.java
===================================================================
--- contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/LineDocMaker.java	(revision 608075)
+++ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/LineDocMaker.java	(working copy)
@@ -121,12 +121,10 @@
       while(true) {
         line = fileIn.readLine();
         if (line == null) {
+          // Reset the file
+          openFile();
           if (!forever)
             throw new NoMoreDataException();
-          else {
-            // Reset the file
-            openFile();
-          }
         } else {
           break;
         }