private void tymeacLoops () {
  
  /*
   * Tymeac server setup. we're not timing the Tymeac setup-time here.
   */
  
  // passed args when starting server   
  String[] in = {"-threads", // use threads override (default currently 4)
                 "" + parallelism, // this many threads
                 "-no",      // no verbose - comment line for start up messages
                 "-s"        // stand-a-lone mode (no DBMS)
                };
  
  s = new InternalServer(); // internal, no RMI/IIOP etc      
  ti = s.createServer(in); // start the server with above args
    
  // When failed, stop
  if  (ti == null) { 
      System.out.println("ti is null, createServer failed");
      System.exit(0);
  }
    
  // class data for submitted work
  WaitMAsyncTask myI = new WaitMAsyncTask();  
  Class<? extends Task>  innaC = myI.getClass();  
  
  /*
   * end of server setup
   */
  
  start = System.nanoTime();
  
  TymeacReturn back = null; // return from server
  
  // submit all nested tasks
  for (int i = 0; i < outerLoop; i++) {
    
    // parm for the server: work class, input for that class
    TymeacParm tp = 
        new TymeacParm( innaC, 
                        new WaitMPassClass( i, innerLoop));
        
    try {        
      // call tymeac with an asynchronous request
      back = ti.asyncRequest(tp);       
    
    } catch (Exception e) {      
      System.out.println(e.toString());      
      System.exit(1);      
    } // end-catch  
    
    // When any invalid return, bye
    if  (back.getReturnCode() != 0) {
      
        System.out.println("RC=" + back.getReturnCode() );
        System.exit(1);
    }       
    
  } // end-for 
  
  // wait for all outer loop requests to complete
  //  count decremented in post()
  while (outerCount > 0) {
            
    synchronized (waitM) {  
      
      if  (!awaken) {
    
          try {
            waitM.wait();
          }
          catch (InterruptedException ignore) {}   
      
      } // endif         
    } // end-sync
                  
    /*
     * process results from an async request 
     *   
     *   There could be many threads doing a post() while the processing
     *   takes place. Not every post() will release a wait(). Therefore,
     *   when finished with all processing here, set awaken to false.
     *   
     *   If a post() comes in just before the set of awaken to false, 
     *   we'll miss doing the work now although the results of the async 
     *   request will not be lost. 
     *   
     *     If it is NOT the last request, we'll just need to wait for the next 
     *     post(), no big thing. 
     *   
     *     If it IS the last request or there were multiple post()'s just before
     *     the set and all async requests are complete, then each post() 
     *     decrements the count until it is zero, the while-loop will fall thru, 
     *     and the processing will be handled after the while-loop. 
     *   
     *   If the last request finishes here, then it "appears" there could be a 
     *   never ending wait() since no further async requests will post(). 
     *   BUT since post() decrements the count, the while-loop will fall thru 
     *   and we'll never get to the wait().   
     */
    process();
        
    // will try to wait() until more work
    awaken = false;  
      
  } // end-while
  
  /*
   * process results from any last async request that squeaked in just before
   *   the set of awaken to false. 
   */  
  process();
    
  end = System.nanoTime();  
  
} // end-method