Java tutorial
/* * 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(); }