2.4/dev/core/src/com/google/gwt/dev/PermutationWorkerFactory.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.dev;

 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.jjs.PermutationResult;
 import com.google.gwt.dev.jjs.UnifiedAst;
 import com.google.gwt.dev.util.FileBackedObject;
 import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;

 /**
  * Represents a factory for implementations of an endpoint that will invoke
  * CompilePerms. Implementations of PermutationWorkerFactory should be
  * default-instantiable and will have {@link #init} called immediately after
  * construction.
  */
 public abstract class PermutationWorkerFactory {

   /**
    * Coordinates the actions of a set of {@link PermutationWorker}s, running
    * each in its own thread.
    */
   private static class Manager {

     private static enum Result {
       SUCCESS, FAIL, WORKER_DEATH
     }

     /**
      * Runs a {@link PermutationWorker} on its own thread.
      */
     private class WorkerThread implements Runnable {
       private final PermutationWorker worker;

       public WorkerThread(PermutationWorker worker) {
         this.worker = worker;
       }

       public void run() {
         Result threadDeathResult = Result.FAIL;
         try {
           while (true) {
             Work work = workQueue.take();
             if (work == POISON_PILL) {
               return;
             }
             TreeLogger logger = work.getLogger();
             try {
               worker.compile(logger, work.getPerm(), work.getResultFile());
               logger.log(TreeLogger.DEBUG, "Successfully compiled permutation");
               resultsQueue.put(Result.SUCCESS);
             } catch (TransientWorkerException e) {
               logger.log(TreeLogger.DEBUG,
                   "Worker died, will retry Permutation", e);
               workQueue.add(work);
               threadDeathResult = Result.WORKER_DEATH;
               return;
             } catch (UnableToCompleteException e) {
               logger.log(TreeLogger.ERROR,
                   "Unrecoverable exception, shutting down", e);
               return;
             }
           }
         } catch (InterruptedException e) {
           return;
         } finally {
           // Record why I died.
           try {
             resultsQueue.put(threadDeathResult);
           } catch (InterruptedException ignored) {
           }
         }
       }
     }

     private static final Work POISON_PILL = new Work(null, null, null);

     public static void run(TreeLogger logger, List<Work> work,
         List<PermutationWorker> workers) throws UnableToCompleteException {
       new Manager().doRun(logger, work, workers);
     }

     /**
      * The queue of work to do.
      */
     BlockingQueue<Work> workQueue;

     /**
      * The queue of work to do.
      */
     BlockingQueue<Result> resultsQueue;

     private Manager() {
     }

     private void doRun(TreeLogger logger, List<Work> work,
         List<PermutationWorker> workers) throws UnableToCompleteException {

       // Initialize state.
       workQueue = new LinkedBlockingQueue<Work>(work);
       resultsQueue = new LinkedBlockingQueue<Result>();

       List<Thread> threads = new ArrayList<Thread>(workers.size());
       try {
         for (PermutationWorker worker : workers) {
           Thread thread = new Thread(new WorkerThread(worker), worker.getName());
           threads.add(thread);
           thread.start();
         }

         int workToDo = work.size();
         int aliveWorkers = workers.size();
         waitForWorkers : while (workToDo > 0 && aliveWorkers > 0) {
           Event blockedEvent = SpeedTracerLogger.start(CompilerEventType.BLOCKED);
           Result take = resultsQueue.take();
           blockedEvent.end();
           switch (take) {
             case SUCCESS:
               --workToDo;
               break;
             case FAIL:
               break waitForWorkers;
             case WORKER_DEATH:
               --aliveWorkers;
               break;
             default:
               throw new IncompatibleClassChangeError(Result.class.toString());
           }
         }

         workQueue.clear();
         for (int i = 0; i < aliveWorkers; ++i) {
           workQueue.add(POISON_PILL);
         }

         if (workToDo > 0) {
           logger.log(TreeLogger.ERROR,
               "Not all permutation were compiled , completed ("
                   + (work.size() - workToDo) + "/" + work.size() + ")");
           throw new UnableToCompleteException();
         }
       } catch (InterruptedException e) {
         logger.log(TreeLogger.ERROR,
             "Exiting without results due to interruption", e);
         throw new UnableToCompleteException();
       } finally {
         // Interrupt any outstanding threads.
         for (Thread thread : threads) {
           thread.interrupt();
         }
       }
     }
   }

   /**
    * Represents work to do.
    */
   private static class Work {
     private final TreeLogger logger;
     private final Permutation perm;
     private final FileBackedObject<PermutationResult> resultFile;

     public Work(TreeLogger logger, Permutation perm,
         FileBackedObject<PermutationResult> resultFile) {
       this.logger = logger;
       this.perm = perm;
       this.resultFile = resultFile;
     }

     public TreeLogger getLogger() {
       return logger;
     }

     public Permutation getPerm() {
       return perm;
     }

     public FileBackedObject<PermutationResult> getResultFile() {
       return resultFile;
     }
   }

   /**
    * The name of the system property used to define the workers.
    */
   public static final String FACTORY_IMPL_PROPERTY = "gwt.jjs.permutationWorkerFactory";

   /**
    * This value can be passed into {@link #setLocalWorkers(int)} to indicate
    * that a heuristic should be used to determine the total number of local
    * workers.
    */
   public static final int WORKERS_AUTO = 0;

   /**
    * Compiles all Permutations in a Precompilation and returns an array of Files
    * that can be consumed by Link using the system-default
    * PermutationWorkersFactories.
    */
   public static void compilePermutations(TreeLogger logger,
       Precompilation precompilation, int localWorkers,
       List<FileBackedObject<PermutationResult>> resultFiles)
       throws UnableToCompleteException {
     compilePermutations(logger, precompilation,
         precompilation.getPermutations(), localWorkers, resultFiles);
   }

   /**
    * Compiles a subset of the Permutations in a Precompilation and returns an
    * array of Files that can be consumed by Link using the system-default
    * PermutationWorkersFactories.
    *
    * @param localWorkers Set the maximum number of workers that should be
    *          executed on the local system by the PermutationWorkerFactory. The
    *          value {@link #WORKERS_AUTO} will allow the
    *          PermutationWorkerFactory to apply a heuristic to determine the
    *          correct number of local workers.
    * @param resultFiles the output files to write into; must be the same length
    *          as permutations
    */
   public static void compilePermutations(TreeLogger logger,
       Precompilation precompilation, Permutation[] permutations,
       int localWorkers, List<FileBackedObject<PermutationResult>> resultFiles)
       throws UnableToCompleteException {
     assert permutations.length == resultFiles.size();
     assert Arrays.asList(precompilation.getPermutations()).containsAll(
         Arrays.asList(permutations));

     // Create the work.
     List<Work> work = new ArrayList<Work>(permutations.length);
     for (int i = 0; i < permutations.length; ++i) {
       Permutation perm = permutations[i];
       if (logger.isLoggable(TreeLogger.DEBUG)) {
         logger.log(TreeLogger.DEBUG,
             "Creating worker permutation " + perm.getId() + " of " + permutations.length);
       }
       work.add(new Work(logger, perm, resultFiles.get(i)));
     }

     // Create the workers.
     List<PermutationWorker> workers = new ArrayList<PermutationWorker>();
     try {
       createWorkers(logger, precompilation.getUnifiedAst(), work.size(),
           localWorkers, workers);

       // Get it done!
       Manager.run(logger, work, workers);
     } finally {
       Throwable caught = null;
       for (PermutationWorker worker : workers) {
         try {
           worker.shutdown();
         } catch (Throwable e) {
           caught = e;
         }
       }
       if (caught != null) {
         throw new RuntimeException(
             "One of the workers threw an exception while shutting down", caught);
       }
     }
   }

   /**
    * Creates one or more implementations of worker factories. This will treat
    * the value of the {@value #FACTORY_IMPL_PROPERTY} system property as a
    * comma-separated list of type names.
    */
   private static synchronized List<PermutationWorkerFactory> createAll(
       TreeLogger logger) throws UnableToCompleteException {
     // NB: This is the much-derided FactoryFactory pattern

     logger = logger.branch(TreeLogger.TRACE,
         "Creating PermutationWorkerFactory instances");

     List<PermutationWorkerFactory> mutableFactories = new ArrayList<PermutationWorkerFactory>();
     String classes = System.getProperty(FACTORY_IMPL_PROPERTY,
         ThreadedPermutationWorkerFactory.class.getName() + ","
             + ExternalPermutationWorkerFactory.class.getName());
     if (logger.isLoggable(TreeLogger.SPAM)) {
       logger.log(TreeLogger.SPAM, "Factory impl property is " + classes);
     }

     String[] classParts = classes.split(",");
     for (String className : classParts) {
       try {
         Class<? extends PermutationWorkerFactory> clazz = Class.forName(
             className).asSubclass(PermutationWorkerFactory.class);
         PermutationWorkerFactory factory = clazz.newInstance();
         factory.init(logger);
         mutableFactories.add(factory);
         if (logger.isLoggable(TreeLogger.SPAM)) {
           logger.log(TreeLogger.SPAM, "Added PermutationWorkerFactory "
               + clazz.getName());
         }
       } catch (ClassCastException e) {
         logger.log(TreeLogger.ERROR, className + " is not a "
             + PermutationWorkerFactory.class.getName());
       } catch (ClassNotFoundException e) {
         logger.log(TreeLogger.ERROR,
             "Unable to find PermutationWorkerFactory named " + className);
       } catch (InstantiationException e) {
         logger.log(TreeLogger.ERROR,
             "Unable to instantiate PermutationWorkerFactory " + className, e);
       } catch (IllegalAccessException e) {
         logger.log(TreeLogger.ERROR,
             "Unable to instantiate PermutationWorkerFactory " + className, e);
       }
     }

     if (mutableFactories.size() == 0) {
       logger.log(TreeLogger.ERROR,
           "No usable PermutationWorkerFactories available");
       throw new UnableToCompleteException();
     }

     return Collections.unmodifiableList(mutableFactories);
   }

   /**
    * Create as many workers as possible to service the Permutations.
    */
   private static void createWorkers(TreeLogger logger, UnifiedAst unifiedAst,
       int workersNeeded, int localWorkers, List<PermutationWorker> workers)
       throws UnableToCompleteException {
     if (localWorkers <= WORKERS_AUTO) {
       // TODO: something smarter?
       localWorkers = 1;
     }

     for (PermutationWorkerFactory factory : PermutationWorkerFactory.createAll(logger)) {
       if (workersNeeded <= 0) {
         break;
       }

       int wanted = factory.isLocal() ? Math.min(workersNeeded, localWorkers)
           : workersNeeded;
       if (wanted <= 0) {
         continue;
       }

       Collection<PermutationWorker> newWorkers = factory.getWorkers(logger,
           unifiedAst, wanted);

       workers.addAll(newWorkers);
       workersNeeded -= newWorkers.size();
       if (factory.isLocal()) {
         localWorkers -= newWorkers.size();
       }
     }

     if (workers.size() == 0) {
       logger.log(TreeLogger.ERROR, "No PermutationWorkers created");
       throw new UnableToCompleteException();
     }
   }

   /**
    * Return some number of PermutationWorkers.
    *
    * @param unifiedAst a UnifiedAst
    * @param numWorkers the desired number of workers
    * @return a collection of PermutationWorkers, the size of which may be less
    *         than <code>numWorkers</code>
    */
   public abstract Collection<PermutationWorker> getWorkers(TreeLogger logger,
       UnifiedAst unifiedAst, int numWorkers) throws UnableToCompleteException;

   /**
    * Initialize the PermutationWorkerFactory.
    */
   public abstract void init(TreeLogger logger) throws UnableToCompleteException;

   /**
    * Indicates if the PermutationWorkers created by the factory consume
    * computational or memory resources on the local system, as opposed to the
    * per-permutation work being performed on a remote system.
    */
   public abstract boolean isLocal();
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.dev;

	import com.google.gwt.core.ext.TreeLogger;
	import com.google.gwt.core.ext.UnableToCompleteException;
	import com.google.gwt.dev.jjs.PermutationResult;
	import com.google.gwt.dev.jjs.UnifiedAst;
	import com.google.gwt.dev.util.FileBackedObject;
	import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
	import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
	import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;
	import java.util.concurrent.BlockingQueue;
	import java.util.concurrent.LinkedBlockingQueue;

	/**
	* Represents a factory for implementations of an endpoint that will invoke
	* CompilePerms. Implementations of PermutationWorkerFactory should be
	* default-instantiable and will have {@link #init} called immediately after
	* construction.
	*/
	public abstract class PermutationWorkerFactory {

	/**
	* Coordinates the actions of a set of {@link PermutationWorker}s, running
	* each in its own thread.
	*/
	private static class Manager {

	private static enum Result {
	SUCCESS, FAIL, WORKER_DEATH
	}

	/**
	* Runs a {@link PermutationWorker} on its own thread.
	*/
	private class WorkerThread implements Runnable {
	private final PermutationWorker worker;

	public WorkerThread(PermutationWorker worker) {
	this.worker = worker;
	}

	public void run() {
	Result threadDeathResult = Result.FAIL;
	try {
	while (true) {
	Work work = workQueue.take();
	if (work == POISON_PILL) {
	return;
	}
	TreeLogger logger = work.getLogger();
	try {
	worker.compile(logger, work.getPerm(), work.getResultFile());
	logger.log(TreeLogger.DEBUG, "Successfully compiled permutation");
	resultsQueue.put(Result.SUCCESS);
	} catch (TransientWorkerException e) {
	logger.log(TreeLogger.DEBUG,
	"Worker died, will retry Permutation", e);
	workQueue.add(work);
	threadDeathResult = Result.WORKER_DEATH;
	return;
	} catch (UnableToCompleteException e) {
	logger.log(TreeLogger.ERROR,
	"Unrecoverable exception, shutting down", e);
	return;
	}
	}
	} catch (InterruptedException e) {
	return;
	} finally {
	// Record why I died.
	try {
	resultsQueue.put(threadDeathResult);
	} catch (InterruptedException ignored) {
	}
	}
	}
	}

	private static final Work POISON_PILL = new Work(null, null, null);

	public static void run(TreeLogger logger, List<Work> work,
	List<PermutationWorker> workers) throws UnableToCompleteException {
	new Manager().doRun(logger, work, workers);
	}

	/**
	* The queue of work to do.
	*/
	BlockingQueue<Work> workQueue;

	/**
	* The queue of work to do.
	*/
	BlockingQueue<Result> resultsQueue;

	private Manager() {
	}

	private void doRun(TreeLogger logger, List<Work> work,
	List<PermutationWorker> workers) throws UnableToCompleteException {

	// Initialize state.
	workQueue = new LinkedBlockingQueue<Work>(work);
	resultsQueue = new LinkedBlockingQueue<Result>();

	List<Thread> threads = new ArrayList<Thread>(workers.size());
	try {
	for (PermutationWorker worker : workers) {
	Thread thread = new Thread(new WorkerThread(worker), worker.getName());
	threads.add(thread);
	thread.start();
	}

	int workToDo = work.size();
	int aliveWorkers = workers.size();
	waitForWorkers : while (workToDo > 0 && aliveWorkers > 0) {
	Event blockedEvent = SpeedTracerLogger.start(CompilerEventType.BLOCKED);
	Result take = resultsQueue.take();
	blockedEvent.end();
	switch (take) {
	case SUCCESS:
	--workToDo;
	break;
	case FAIL:
	break waitForWorkers;
	case WORKER_DEATH:
	--aliveWorkers;
	break;
	default:
	throw new IncompatibleClassChangeError(Result.class.toString());
	}
	}

	workQueue.clear();
	for (int i = 0; i < aliveWorkers; ++i) {
	workQueue.add(POISON_PILL);
	}

	if (workToDo > 0) {
	logger.log(TreeLogger.ERROR,
	"Not all permutation were compiled , completed ("
	+ (work.size() - workToDo) + "/" + work.size() + ")");
	throw new UnableToCompleteException();
	}
	} catch (InterruptedException e) {
	logger.log(TreeLogger.ERROR,
	"Exiting without results due to interruption", e);
	throw new UnableToCompleteException();
	} finally {
	// Interrupt any outstanding threads.
	for (Thread thread : threads) {
	thread.interrupt();
	}
	}
	}
	}

	/**
	* Represents work to do.
	*/
	private static class Work {
	private final TreeLogger logger;
	private final Permutation perm;
	private final FileBackedObject<PermutationResult> resultFile;

	public Work(TreeLogger logger, Permutation perm,
	FileBackedObject<PermutationResult> resultFile) {
	this.logger = logger;
	this.perm = perm;
	this.resultFile = resultFile;
	}

	public TreeLogger getLogger() {
	return logger;
	}

	public Permutation getPerm() {
	return perm;
	}

	public FileBackedObject<PermutationResult> getResultFile() {
	return resultFile;
	}
	}

	/**
	* The name of the system property used to define the workers.
	*/
	public static final String FACTORY_IMPL_PROPERTY = "gwt.jjs.permutationWorkerFactory";

	/**
	* This value can be passed into {@link #setLocalWorkers(int)} to indicate
	* that a heuristic should be used to determine the total number of local
	* workers.
	*/
	public static final int WORKERS_AUTO = 0;

	/**
	* Compiles all Permutations in a Precompilation and returns an array of Files
	* that can be consumed by Link using the system-default
	* PermutationWorkersFactories.
	*/
	public static void compilePermutations(TreeLogger logger,
	Precompilation precompilation, int localWorkers,
	List<FileBackedObject<PermutationResult>> resultFiles)
	throws UnableToCompleteException {
	compilePermutations(logger, precompilation,
	precompilation.getPermutations(), localWorkers, resultFiles);
	}

	/**
	* Compiles a subset of the Permutations in a Precompilation and returns an
	* array of Files that can be consumed by Link using the system-default
	* PermutationWorkersFactories.
	*
	* @param localWorkers Set the maximum number of workers that should be
	* executed on the local system by the PermutationWorkerFactory. The
	* value {@link #WORKERS_AUTO} will allow the
	* PermutationWorkerFactory to apply a heuristic to determine the
	* correct number of local workers.
	* @param resultFiles the output files to write into; must be the same length
	* as permutations
	*/
	public static void compilePermutations(TreeLogger logger,
	Precompilation precompilation, Permutation[] permutations,
	int localWorkers, List<FileBackedObject<PermutationResult>> resultFiles)
	throws UnableToCompleteException {
	assert permutations.length == resultFiles.size();
	assert Arrays.asList(precompilation.getPermutations()).containsAll(
	Arrays.asList(permutations));

	// Create the work.
	List<Work> work = new ArrayList<Work>(permutations.length);
	for (int i = 0; i < permutations.length; ++i) {
	Permutation perm = permutations[i];
	if (logger.isLoggable(TreeLogger.DEBUG)) {
	logger.log(TreeLogger.DEBUG,
	"Creating worker permutation " + perm.getId() + " of " + permutations.length);
	}
	work.add(new Work(logger, perm, resultFiles.get(i)));
	}

	// Create the workers.
	List<PermutationWorker> workers = new ArrayList<PermutationWorker>();
	try {
	createWorkers(logger, precompilation.getUnifiedAst(), work.size(),
	localWorkers, workers);

	// Get it done!
	Manager.run(logger, work, workers);
	} finally {
	Throwable caught = null;
	for (PermutationWorker worker : workers) {
	try {
	worker.shutdown();
	} catch (Throwable e) {
	caught = e;
	}
	}
	if (caught != null) {
	throw new RuntimeException(
	"One of the workers threw an exception while shutting down", caught);
	}
	}
	}

	/**
	* Creates one or more implementations of worker factories. This will treat
	* the value of the {@value #FACTORY_IMPL_PROPERTY} system property as a
	* comma-separated list of type names.
	*/
	private static synchronized List<PermutationWorkerFactory> createAll(
	TreeLogger logger) throws UnableToCompleteException {
	// NB: This is the much-derided FactoryFactory pattern

	logger = logger.branch(TreeLogger.TRACE,
	"Creating PermutationWorkerFactory instances");

	List<PermutationWorkerFactory> mutableFactories = new ArrayList<PermutationWorkerFactory>();
	String classes = System.getProperty(FACTORY_IMPL_PROPERTY,
	ThreadedPermutationWorkerFactory.class.getName() + ","
	+ ExternalPermutationWorkerFactory.class.getName());
	if (logger.isLoggable(TreeLogger.SPAM)) {
	logger.log(TreeLogger.SPAM, "Factory impl property is " + classes);
	}

	String[] classParts = classes.split(",");
	for (String className : classParts) {
	try {
	Class<? extends PermutationWorkerFactory> clazz = Class.forName(
	className).asSubclass(PermutationWorkerFactory.class);
	PermutationWorkerFactory factory = clazz.newInstance();
	factory.init(logger);
	mutableFactories.add(factory);
	if (logger.isLoggable(TreeLogger.SPAM)) {
	logger.log(TreeLogger.SPAM, "Added PermutationWorkerFactory "
	+ clazz.getName());
	}
	} catch (ClassCastException e) {
	logger.log(TreeLogger.ERROR, className + " is not a "
	+ PermutationWorkerFactory.class.getName());
	} catch (ClassNotFoundException e) {
	logger.log(TreeLogger.ERROR,
	"Unable to find PermutationWorkerFactory named " + className);
	} catch (InstantiationException e) {
	logger.log(TreeLogger.ERROR,
	"Unable to instantiate PermutationWorkerFactory " + className, e);
	} catch (IllegalAccessException e) {
	logger.log(TreeLogger.ERROR,
	"Unable to instantiate PermutationWorkerFactory " + className, e);
	}
	}

	if (mutableFactories.size() == 0) {
	logger.log(TreeLogger.ERROR,
	"No usable PermutationWorkerFactories available");
	throw new UnableToCompleteException();
	}

	return Collections.unmodifiableList(mutableFactories);
	}

	/**
	* Create as many workers as possible to service the Permutations.
	*/
	private static void createWorkers(TreeLogger logger, UnifiedAst unifiedAst,
	int workersNeeded, int localWorkers, List<PermutationWorker> workers)
	throws UnableToCompleteException {
	if (localWorkers <= WORKERS_AUTO) {
	// TODO: something smarter?
	localWorkers = 1;
	}

	for (PermutationWorkerFactory factory : PermutationWorkerFactory.createAll(logger)) {
	if (workersNeeded <= 0) {
	break;
	}

	int wanted = factory.isLocal() ? Math.min(workersNeeded, localWorkers)
	: workersNeeded;
	if (wanted <= 0) {
	continue;
	}

	Collection<PermutationWorker> newWorkers = factory.getWorkers(logger,
	unifiedAst, wanted);

	workers.addAll(newWorkers);
	workersNeeded -= newWorkers.size();
	if (factory.isLocal()) {
	localWorkers -= newWorkers.size();
	}
	}

	if (workers.size() == 0) {
	logger.log(TreeLogger.ERROR, "No PermutationWorkers created");
	throw new UnableToCompleteException();
	}
	}

	/**
	* Return some number of PermutationWorkers.
	*
	* @param unifiedAst a UnifiedAst
	* @param numWorkers the desired number of workers
	* @return a collection of PermutationWorkers, the size of which may be less
	* than <code>numWorkers</code>
	*/
	public abstract Collection<PermutationWorker> getWorkers(TreeLogger logger,
	UnifiedAst unifiedAst, int numWorkers) throws UnableToCompleteException;

	/**
	* Initialize the PermutationWorkerFactory.
	*/
	public abstract void init(TreeLogger logger) throws UnableToCompleteException;

	/**
	* Indicates if the PermutationWorkers created by the factory consume
	* computational or memory resources on the local system, as opposed to the
	* per-permutation work being performed on a remote system.
	*/
	public abstract boolean isLocal();
	}