/*******************************************************************************

 * Copyright (c) 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     Jens Kuebler - [126121] - Initial API

 *     Morgan Stanley - [126121] Updated parallel build patch by fixing concurrency issues 

 *******************************************************************************/

package org.eclipse.core.internal.events;

import org.eclipse.core.resources.IBuildConfiguration;

import org.eclipse.core.resources.IBuildContext;

import org.eclipse.core.resources.IBuildDescription;

/**

 * 

 */

public class BuildDescription implements IBuildDescription {

	private IBuildContext buildContext;

	private IBuildConfiguration buildConfiguration;

	public BuildDescription(IBuildContext buildContext, IBuildConfiguration buildConfiguration) {

		super();

		this.buildContext = buildContext;

		this.buildConfiguration = buildConfiguration;

	}

	public IBuildContext getBuildContext() {

		return buildContext;

	}

	public IBuildConfiguration getBuildConfiguration() {

		return buildConfiguration;

	}

}

 * 	   Jens Kuebler - [126121] - Initial changes to support parallel build

 * 	   Morgan Stanley - [126121] Fixing parallel build concurrency issues

			case IncrementalProjectBuilder.PARALLEL_FULL_BUILD :

			    return "PARALLEL_FULL_BUILD"; //$NON-NLS-1$

			case IncrementalProjectBuilder.PARALLEL_CLEAN_BUILD :

			    return "PARALLEL_CLEAN_BUILD"; //$NON-NLS-1$

    public void buildParallel(final int trigger, IProgressMonitor monitor, IBuildConfiguration[] configs) throws CoreException {        

        final boolean clean = (trigger == IncrementalProjectBuilder.PARALLEL_CLEAN_BUILD);

        long start = System.currentTimeMillis();

        if (clean) {            

            Policy.log(new ResourceStatus(IStatus.INFO, "Starting parallel cleaning of " + configs.length + " projects..."));

        } else {

            Policy.log(new ResourceStatus(IStatus.INFO, "Starting parallel build of " + configs.length + " projects..."));

        }

        final SharedProgressMonitor sharedProgress = new SharedProgressMonitor(Policy.monitorFor(monitor));

        List<IProject> projects = new ArrayList<IProject>();

        DirectedGraphs<IProject> directedGraphs = new DirectedGraphs<IProject>();

        for (IBuildConfiguration config : configs) {

            projects.add(config.getProject());

            directedGraphs.addNode(new Node<IProject>(config.getProject()));

        }

        // cleaning does not require building the graph

        if (trigger == IncrementalProjectBuilder.PARALLEL_FULL_BUILD) {

            for (IProject project : projects) {

                if (!project.isAccessible())

                    continue;

                ProjectDescription desc = ((Project)project).internalGetDescription();

                if (desc == null)

                    continue;

                IProject[] refs = desc.getAllReferences(false);

                Node<IProject> node = directedGraphs.getNodeWithContent(project);

                for (IProject referencedProject : refs) {

                    Node<IProject> node2 = directedGraphs.getNodeWithContent(referencedProject);

                    if(node2 != null) {

                        node2.addOutgoingEdge(node);

                    }

                }

            }

        }

        hookStartBuild(configs, trigger);

        final MultiStatus status = new MultiStatus(ResourcesPlugin.PI_RESOURCES, IResourceStatus.INTERNAL_ERROR, Messages.events_errors, null);

        if (clean) {

            sharedProgress.beginTask("Cleaning projects in parallel:", projects.size());

        } else {

            sharedProgress.beginTask("Building projects in parallel:", projects.size());

        }

        ThreadPoolBuilder threadPoolBuilder = new ThreadPoolBuilder();

        try {           

            IBuildExecutor buildExecutor = new IBuildExecutor() {

                public void executeBuild(IBuildDescription buildDescription, SharedProgressMonitor sharedProgress) {

                    IProgressMonitor progressMonitor = new NullProgressMonitor();

                    try {

                        sharedProgress.addProjectName(buildDescription.getBuildConfiguration().getProject().getName());

                        basicBuild(buildDescription.getBuildConfiguration(), trigger, buildDescription.getBuildContext(), status, progressMonitor);

                    } finally {

                        sharedProgress.removeProjectName(buildDescription.getBuildConfiguration().getProject().getName());

                        sharedProgress.worked(1);

                    }

                }};

                threadPoolBuilder.run(directedGraphs, buildExecutor, sharedProgress);

        } catch (InterruptedException e) {

            status.add(new Status(IStatus.ERROR, ResourcesPlugin.PI_RESOURCES, Messages.events_errors, e));

        } finally {

            hookEndBuild(trigger);

            long finish = System.currentTimeMillis();

            if (clean) {

                Policy.log(new ResourceStatus(IStatus.INFO, "Finished parallel clean in " + (finish - start) + "ms"));

            } else {

                Policy.log(new ResourceStatus(IStatus.INFO, "Finished parallel build in " + (finish - start) + "ms"));              

            }

            sharedProgress.done();

        } 

    }

    private IncrementalProjectBuilder getParallelBuilder(IBuildConfiguration buildConfiguration, BuildCommand command, int buildSpecIndex, MultiStatus status, IBuildContext buildContext) throws CoreException {

        // always construct a new builder for parallel builds (think about pooling here)

        InternalBuilder result = initializeBuilder(command.getBuilderName(), buildConfiguration, buildSpecIndex, status);

        command.setBuilders(result);

        result.setCommand(command);

        result.setBuildConfig(buildConfiguration);

        result.startupOnInitialize();

        //      }

        if (!validateNature(result, command.getBuilderName())) {

            //skip this builder and null its last built tree because it is invalid

            //if the nature gets added or re-enabled a full build will be triggered

            result.setLastBuiltTree(null);

            return null;

        }

        return (IncrementalProjectBuilder) result;

    }	

/*******************************************************************************

 * Copyright (c) 2000, 2005 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Jens Kuebler - [126121] - Initial changes to support parallel build

 *     Morgan Stanley - [126121] Fixing parallel build concurrency issues

*******************************************************************************/

package org.eclipse.core.internal.events;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.BlockingQueue;

import org.eclipse.core.internal.resources.BuildConfiguration;

import org.eclipse.core.resources.IProject;

// The worker instance that is executed in a ThreadPool worker thread

public final class BuildRunnable implements Runnable {

	private final Node<IProject> currentNode;

	private final BlockingQueue<Node<IProject>> queue;

	private final IBuildExecutor executor;

	private final SharedProgressMonitor sharedProgress;

	protected BuildRunnable(Node<IProject> currentNode, BlockingQueue<Node<IProject>> queue, IBuildExecutor executor, SharedProgressMonitor sharedMonitor) {

		this.currentNode = currentNode;

		this.queue = queue;

		this.executor = executor;

		this.sharedProgress = sharedMonitor;

	}

	public void run() {			

			if (sharedProgress.isCanceled()) {

				return;

			}			

//			System.out.println("start compile " + currentNode.getContent()); //$NON-NLS-1$

			BuildDescription buildDescription = new BuildDescription(null, new BuildConfiguration(currentNode.getContent()));

			executor.executeBuild(buildDescription, sharedProgress);

//			System.out.println("end compile " + currentNode.getContent()); //$NON-NLS-1$

			List<Node<IProject>> outgoingNodes = new ArrayList<Node<IProject>>(currentNode.getOutgoingEdges()); 

			currentNode.removeAllOutgoingEdges();

			for (Node<IProject> node : outgoingNodes) {

				if(node.getIncomingEdges().isEmpty()) {

					queue.add(node);

				}

			}

	}

}

/*******************************************************************************

 * Copyright (c) 2000, 2005 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Jens Kuebler - [126121] - Initial changes to support parallel build

 *******************************************************************************/

package org.eclipse.core.internal.events;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.Set;

/**

 * A directed graph holds all nodes. Nodes need not be connected which is why a container object is required

 * 

 * @author jens

 *

 */

public class DirectedGraphs<T> {

	private Set<Node<T>> nodes;

	public DirectedGraphs() {

		nodes = Collections.synchronizedSet(new HashSet<Node<T>>());

	}

	public void addNode(Node<T> node) {

		nodes.add(node);

	}

	public void removeNode(Node<T> node) {

		nodes.remove(node);

	}

	public void addAll(Collection<Node<T>> nodesToBeAdded) {

		nodes.addAll(nodesToBeAdded);

	}

	public Node<T> getNodeWithContent(T content) {

		for (Node<T> node : nodes) {

			if(content.equals(node.getContent())) {

				return node;

			}

		}

		return null;

	}

	public synchronized Set<Node<T>> getRootNodes() {

		Set<Node<T>> set = new LinkedHashSet<Node<T>>();

		for (Node<T> node : nodes) {

			if(node.getIncomingEdges().isEmpty()) {

				set.add(node);

			}

		}

		return set;

	}

	public boolean isEmtpy() {

		return nodes.isEmpty();

	}

}

/*******************************************************************************

 * Copyright (c) 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     Jens Kuebler - [126121] - Initial changes to support parallel build

 *******************************************************************************/

package org.eclipse.core.internal.events;

import org.eclipse.core.resources.IBuildDescription;

/**

 * 

 */

public interface IBuildExecutor {

	public void executeBuild(IBuildDescription buildDescription, SharedProgressMonitor sharedProgress);

}

/*******************************************************************************

 * Copyright (c) 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Jens Kuebler - [126121] - Initial changes to support parallel build

 *******************************************************************************/

package org.eclipse.core.internal.events;

import java.text.MessageFormat;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.Set;

/**

 * A simple node object having references to other node objects 

 *

 * @param <T>

 */

public class Node<T> {

	private Set<Node<T>> incomingEdges;

	private Set<Node<T>> outgoingEdges;

	private T content;

	public Node(T content) {

		this.content = content;

		incomingEdges = new LinkedHashSet<Node<T>>(); 

		outgoingEdges = new LinkedHashSet<Node<T>>(); 

	}

	public T getContent() {

		return content;

	}

	public void setContent(T content) {

		this.content = content;

	}

	public synchronized Set<Node<T>> getIncomingEdges() {

		return incomingEdges;

	}

	public synchronized Set<Node<T>> getOutgoingEdges() {

		return outgoingEdges;

	}

	public synchronized void addIncomingEdge(Node<T> node) {

		if(!incomingEdges.contains(node)) {

			incomingEdges.add(node);

			node.addOutgoingEdge(this);

		}

	}

	public synchronized void addOutgoingEdge(Node<T> node) {

		if(!outgoingEdges.contains(node)) {

			outgoingEdges.add(node);

			node.addIncomingEdge(this);

		}

	}

	public synchronized void removeOutgoingEdge(Node<T> node) {

		if(outgoingEdges.contains(node)) {

			outgoingEdges.remove(node);

			node.removeIncomingEdge(this);

		}

	}

	public synchronized void removeIncomingEdge(Node<T> node) {

		if(incomingEdges.contains(node)) {

			incomingEdges.remove(node);

			node.removeOutgoingEdge(this);

		}

	}

	public synchronized void removeAllOutgoingEdges() {

		for (Iterator<Node<T>> iterator = outgoingEdges.iterator(); iterator.hasNext();) {

			Node<T> node = iterator.next();

			node.internalRemoveIncomingEdge(this);

			iterator.remove();

		}

	}

	public synchronized void removeAllIncomingEdges() {

		for (Iterator<Node<T>> iterator = incomingEdges.iterator(); iterator.hasNext();) {

			Node<T> node = iterator.next();

			node.internalRemoveOutgoingEdge(this);

			iterator.remove();

		}

	}

	synchronized void internalRemoveOutgoingEdge(Node<T> node) {

		outgoingEdges.remove(node);

	}

	synchronized void internalRemoveIncomingEdge(Node<T> node) {

		incomingEdges.remove(node);

	}

	@Override

	public int hashCode() {

		final int prime = 31;

		int result = 1;

		result = prime * result + ((content == null) ? 0 : content.hashCode());

		return result;

	}

	@Override

	public boolean equals(Object obj) {

		if (this == obj)

			return true;

		if (obj == null)

			return false;

		if (getClass() != obj.getClass())

			return false;

		Node other = (Node) obj;

		if (content == null) {

			if (other.content != null)

				return false;

		} else if (!content.equals(other.content))

			return false;

		return true;

	}

	@Override

	public String toString() {

		return MessageFormat.format("Node [content={0}]", content); //$NON-NLS-1$

	}

}

/*******************************************************************************

 * Copyright (c) 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Morgan Stanley - [126121] Fixing parallel build concurrency issues

 *******************************************************************************/

package org.eclipse.core.internal.events;

import java.util.LinkedHashSet;

import java.util.Set;

import org.eclipse.core.runtime.IProgressMonitor;

/**

 * Simple thread-safe {@link IProgressMonitor} wrapper used by the parallel builder to add/remove names of

 * projects that are actually building.

 */

public class SharedProgressMonitor implements IProgressMonitor {

	private final IProgressMonitor progressMonitor;

	private final Set<String> projectNames = new LinkedHashSet<String>();

	private String taskNamePrefix = "";

	public SharedProgressMonitor(IProgressMonitor progressMonitor) {

		this.progressMonitor = progressMonitor;

	}

	public synchronized void beginTask(String name, int totalWork) {

		taskNamePrefix = name;

		progressMonitor.beginTask(name, totalWork);

	}

	public synchronized void done() {

		progressMonitor.done();

	}

	public synchronized void internalWorked(double work) {

		progressMonitor.internalWorked(work);

	}

	public boolean isCanceled() {

		return progressMonitor.isCanceled();

	}

	public synchronized void setCanceled(boolean value) {

		progressMonitor.setCanceled(value);

	}

	public synchronized void setTaskName(String name) {

		progressMonitor.setTaskName(name);

	}

	public synchronized void subTask(String name) {

		progressMonitor.subTask(name);

	}

	public synchronized void worked(int work) {

		progressMonitor.worked(work);

	}

	public synchronized void addProjectName(String projName) {

		projectNames.add(projName);

		setTaskName(taskNamePrefix + " " + getProjectNames(projectNames));

	}

	public synchronized void removeProjectName(String projName) {

		projectNames.remove(projName);

		setTaskName(taskNamePrefix + " " + getProjectNames(projectNames));

	}	

	private static String getProjectNames(Set<String> projectNames) {

		StringBuilder builder = new StringBuilder("[");

		boolean first = true;

		for (String name : projectNames) {

			if (first) {

				first = false;

			} else {

				builder.append(", ");

			}

			builder.append(name);

		}

		builder.append("]");

		return builder.toString();

	}

}

/*******************************************************************************

 * Copyright (c) 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Jens Kuebler - [126121] - Initial changes to support parallel build

 *     Morgan Stanley - [126121] Fixing parallel build concurrency issues

 *******************************************************************************/

package org.eclipse.core.internal.events;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

import org.eclipse.core.resources.IProject;

public class ThreadPoolBuilder {

	private ExecutorService threadPool;

	private BlockingQueue<Node<IProject>> queue;

	public ThreadPoolBuilder() {

		final int threadNum = Runtime.getRuntime().availableProcessors() > 1 ? Runtime.getRuntime().availableProcessors() - 1 : 1;

		threadPool = Executors.newFixedThreadPool(threadNum);

		queue = new ArrayBlockingQueue<Node<IProject>>(6000);

	}

	public void run(DirectedGraphs<IProject> directedGraphs, IBuildExecutor runnable, SharedProgressMonitor sharedProgress) throws InterruptedException {

//		System.out.println("ThreadPool started...");

		queue.addAll(directedGraphs.getRootNodes());

		while (!threadPool.isShutdown()) {

			if(directedGraphs.isEmtpy() || sharedProgress.isCanceled()) {

				threadPool.shutdown();

			} else {

				Node<IProject>nodeToCompile = queue.take();

				directedGraphs.removeNode((Node<IProject>) nodeToCompile);

				threadPool.execute(new BuildRunnable(nodeToCompile, queue, runnable, sharedProgress));

			}

		}

		// blocking the main builder thread (Worker-N) until all the threads finishes 

		threadPool.awaitTermination(60, TimeUnit.SECONDS);

//		System.out.println("ThreadPool finished...");

	}

}

/*******************************************************************************

 * Copyright (c) 2011 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.core.resources;

/**

 * 

 */

public interface IBuildDescription {

	IBuildContext getBuildContext();

	IBuildConfiguration getBuildConfiguration();

}

 * Jens Kuebler - [126121] - Initial changes to support parallel build

 * Morgan Stanley - [126121] Adding support for parallel clean build

    public static final int PARALLEL_FULL_BUILD = 7;

	public static final int PARALLEL_CLEAN_BUILD = 16;