getBlobIds() {
+ return blobNodes.keySet();
+ }
+
+ public BlobNode getBlobNode(Token blobID) {
+ return blobNodes.get(blobID);
+ }
+
+ /**
+ * TODO: We may need to make the class {@link BlobNode} public and move
+ * these functions to {@link BlobNode}.
+ *
+ * Returns output edges of a blob. This method is added on [2014-03-01].
+ *
+ * @param blobID
+ * @return
+ */
+ public ImmutableSet getOutputs(Token blobID) {
+ return blobNodes.get(blobID).outputs;
+ }
+
+ /**
+ * TODO: We may need to make the class {@link BlobNode} public and move
+ * these functions to {@link BlobNode}.
+ *
+ * Returns input edges of a blob. This method is added on [2014-03-01].
+ *
+ * @param blobID
+ * @return
+ */
+ public ImmutableSet getInputs(Token blobID) {
+ return blobNodes.get(blobID).inputs;
+ }
+
+ /**
+ * A Drainer can be set to the {@link BlobGraph} to perform draining.
+ *
+ * @param drainer
+ */
+ public void setDrainer(AbstractDrainer drainer) {
+ for (BlobNode bn : blobNodes.values()) {
+ bn.setDrainer(drainer);
+ }
+ }
+
+ public void clearDrainData() {
+ for (BlobNode node : blobNodes.values()) {
+ node.snDrainData = null;
+ }
+ }
+
+ /**
+ * @return the sourceBlobNode
+ */
+ BlobNode getSourceBlobNode() {
+ return sourceBlobNode;
+ }
+
+ /**
+ * Does a depth first traversal to detect cycles in the graph.
+ *
+ * @param blobNodes
+ */
+ private void checkCycles(Collection blobNodes) {
+ Map colorMap = new HashMap<>();
+ for (BlobNode b : blobNodes) {
+ colorMap.put(b, Color.WHITE);
+ }
+ for (BlobNode b : blobNodes) {
+ if (colorMap.get(b) == Color.WHITE)
+ if (DFS(b, colorMap))
+ throw new StreamCompilationFailedException(
+ "Cycles found among blobs");
+ }
+ }
+
+ /**
+ * A cycle exits in a directed graph if a back edge is detected during a DFS
+ * traversal. A back edge exists in a directed graph if the currently
+ * explored vertex has an adjacent vertex that was already colored gray
+ *
+ * @param vertex
+ * @param colorMap
+ * @return true if cycle found, false otherwise.
+ */
+ private boolean DFS(BlobNode vertex, Map colorMap) {
+ colorMap.put(vertex, Color.GRAY);
+ for (BlobNode adj : vertex.getSuccessors()) {
+ if (colorMap.get(adj) == Color.GRAY)
+ return true;
+ if (colorMap.get(adj) == Color.WHITE)
+ if (DFS(adj, colorMap))
+ return true;
+ }
+ colorMap.put(vertex, Color.BLACK);
+ return false;
+ }
+
+ /**
+ * Just used to build the input and output tokens of a partitioned blob
+ * workers. imitate a {@link Blob}.
+ */
+ private final class DummyBlob {
+ private final ImmutableSet inputs;
+ private final ImmutableSet outputs;
+ private final Token id;
+
+ private DummyBlob(Set> workers) {
+ ImmutableSet.Builder inputBuilder = new ImmutableSet.Builder<>();
+ ImmutableSet.Builder outputBuilder = new ImmutableSet.Builder<>();
+ for (IOInfo info : IOInfo.externalEdges(workers)) {
+ (info.isInput() ? inputBuilder : outputBuilder).add(info
+ .token());
+ }
+
+ inputs = inputBuilder.build();
+ outputs = outputBuilder.build();
+ id = Collections.min(inputs);
+ }
+ }
+
+ /**
+ * [14 Feb, 2015] This class was an inner class of {@link AbstractDrainer}.
+ * I have re factored {@link AbstractDrainer} and moved this class to here.
+ * {@link AbstractDrainer} directly accessed lots of fields and methods of
+ * this class when this was an inner class of it. So those fields and
+ * methods of this class have been made as package private when re
+ * factoring.
+ *
+ * [14 Feb, 2015] TODO: {@link AbstractDrainer#schExecutorService} and
+ * {@link AbstractDrainer#state} have been made package private during the
+ * re factoring. We can make those fields private by moving
+ * {@link BlobNode#drain()} and {@link BlobNode#drained()} to
+ * {@link AbstractDrainer}.
+ *
+ *
+ * BlobNode represents the vertex in the blob graph ({@link BlobGraph} ). It
+ * represents a {@link Blob} and carry the draining process of that blob.
+ *
+ * @author Sumanan
+ */
+ static final class BlobNode {
+
+ /**
+ * Intermediate drain data.
+ */
+ SNDrainedData snDrainData;
+
+ private AbstractDrainer drainer;
+ /**
+ * The blob that wrapped by this blob node.
+ */
+ final Token blobID;
+ /**
+ * Predecessor blob nodes of this blob node.
+ */
+ private List predecessors;
+ /**
+ * Successor blob nodes of this blob node.
+ */
+ private List successors;
+ /**
+ * The number of undrained predecessors of this blobs. Everytime, when a
+ * predecessor finished draining, dependencyCount will be decremented
+ * and once it reached to 0 this blob will be called for draining.
+ */
+ private AtomicInteger dependencyCount;
+
+ // TODO: add comments
+ AtomicInteger drainState;
+
+ /**
+ * All input channels of this blob. We need this information to globally
+ * determine buffer sizes to avoid deadlocks. This is added on
+ * [2014-03-01], when implementing global buffer size adjustment.
+ */
+ private final ImmutableSet inputs;
+
+ /**
+ * All output channels of this blob. We need this information to
+ * globally determine buffer sizes to avoid deadlocks. This is added on
+ * [2014-03-01], when implementing global buffer size adjustment.
+ */
+ private final ImmutableSet outputs;
+
+ private BlobNode(Token blob, ImmutableSet inputs,
+ ImmutableSet outputs) {
+ this.blobID = blob;
+ predecessors = new ArrayList<>();
+ successors = new ArrayList<>();
+ dependencyCount = new AtomicInteger(0);
+ drainState = new AtomicInteger(0);
+ this.inputs = inputs;
+ this.outputs = outputs;
+ }
+
+ /**
+ * Should be called when the draining of the current blob has been
+ * finished. This function stops all threads belong to the blob and
+ * inform its successors as well.
+ */
+ void drained() {
+ if (drainState.compareAndSet(1, 3)) {
+ for (BlobNode suc : this.successors) {
+ suc.predecessorDrained(this);
+ }
+ drainer.drainingDone(this);
+ } else if (drainState.compareAndSet(2, 3)) {
+ drainer.drainingDone(this);
+ }
+ }
+
+ /**
+ * Drain the blob mapped by this blob node.
+ */
+ void drain() {
+ checkNotNull(drainer);
+ if (!drainState.compareAndSet(0, 1)) {
+ throw new IllegalStateException(
+ "Drain of this blobNode has already been called");
+ }
+
+ DrainType drainType;
+ if (Options.useDrainData)
+ if (drainer.state == DrainerState.FINAL)
+ drainType = DrainType.FINAL;
+ else
+ drainType = DrainType.INTERMEDIATE;
+ else
+ drainType = DrainType.DISCARD;
+
+ drainer.drain(blobID, drainType);
+
+ // TODO: Verify the waiting time is reasonable.
+ if (Options.needDrainDeadlockHandler)
+ drainer.schExecutorService.schedule(deadLockHandler(), 6000,
+ TimeUnit.MILLISECONDS);
+ }
+
+ void setDrainData(SNDrainedData drainedData) {
+ if (this.snDrainData == null) {
+ this.snDrainData = drainedData;
+ drainState.set(4);
+ } else
+ throw new AssertionError(
+ "Multiple drain data has been received.");
+ }
+
+ private ImmutableList getSuccessors() {
+ return ImmutableList.copyOf(successors);
+ }
+
+ private void addPredecessor(BlobNode pred) {
+ assert !predecessors.contains(pred) : String.format(
+ "The BlobNode %s has already been set as a predecessors",
+ pred);
+ predecessors.add(pred);
+ dependencyCount.set(dependencyCount.get() + 1);
+ }
+
+ private void addSuccessor(BlobNode succ) {
+ assert !successors.contains(succ) : String
+ .format("The BlobNode %s has already been set as a successor",
+ succ);
+ successors.add(succ);
+ }
+
+ private void predecessorDrained(BlobNode pred) {
+ if (!predecessors.contains(pred))
+ throw new IllegalArgumentException("Illegal Predecessor");
+
+ assert dependencyCount.get() > 0 : String
+ .format("Graph mismatch : My predecessors count is %d. But more than %d of BlobNodes claim me as their successor",
+ predecessors.size(), predecessors.size());
+
+ if (dependencyCount.decrementAndGet() == 0) {
+ drain();
+ }
+ }
+
+ /**
+ * @return The number of undrained predecessors.
+ */
+ private int getDependencyCount() {
+ return dependencyCount.get();
+ }
+
+ private void setDrainer(AbstractDrainer drainer) {
+ checkNotNull(drainer);
+ this.drainer = drainer;
+ }
+
+ private Runnable deadLockHandler() {
+ Runnable r = new Runnable() {
+
+ @Override
+ public void run() {
+ if (drainState.compareAndSet(1, 2)) {
+ for (BlobNode suc : successors) {
+ suc.predecessorDrained(BlobNode.this);
+ }
+ System.out
+ .println("deadLockHandler: "
+ + blobID
+ + " - Deadlock during draining has been handled");
+ }
+ }
+ };
+ return r;
+ }
+ }
+
+ /**
+ * Color enumerator used by DFS algorithm to find cycles in the blob graph.
+ */
+ private enum Color {
+ WHITE, GRAY, BLACK
+ }
+}
diff --git a/src/edu/mit/streamjit/impl/concurrent/ConcurrentBlobFactory.java b/src/edu/mit/streamjit/impl/concurrent/ConcurrentBlobFactory.java
new file mode 100644
index 00000000..b9f1fc50
--- /dev/null
+++ b/src/edu/mit/streamjit/impl/concurrent/ConcurrentBlobFactory.java
@@ -0,0 +1,95 @@
+package edu.mit.streamjit.impl.concurrent;
+
+import java.util.Set;
+
+import edu.mit.streamjit.api.Worker;
+import edu.mit.streamjit.impl.blob.Blob;
+import edu.mit.streamjit.impl.blob.BlobFactory;
+import edu.mit.streamjit.impl.blob.DrainData;
+import edu.mit.streamjit.impl.common.Configuration;
+import edu.mit.streamjit.impl.common.Configuration.Parameter;
+import edu.mit.streamjit.impl.compiler2.Compiler2BlobFactory;
+import edu.mit.streamjit.impl.distributed.ConfigurationManager;
+import edu.mit.streamjit.impl.distributed.PartitionManager;
+import edu.mit.streamjit.impl.distributed.WorkerMachine;
+import edu.mit.streamjit.impl.distributed.common.Options;
+
+public class ConcurrentBlobFactory implements BlobFactory {
+
+ private int noOfBlobs;
+
+ private final PartitionManager partitionManager;
+
+ public ConcurrentBlobFactory(PartitionManager partitionManager,
+ int noOfBlobs) {
+ this.partitionManager = partitionManager;
+ this.noOfBlobs = noOfBlobs;
+ }
+
+ /**
+ * If {@link ConfigurationManager} is not passed as a constructor argument
+ * then {@link WorkerMachine} will be used as default one.
+ *
+ * @param noOfMachines
+ */
+ public ConcurrentBlobFactory(int noOfBlobs) {
+ this(new WorkerMachine(null), noOfBlobs);
+ }
+
+ @Override
+ public Blob makeBlob(Set> workers, Configuration config,
+ int maxNumCores, DrainData initialState) {
+ return new Compiler2BlobFactory().makeBlob(workers, config,
+ maxNumCores, initialState);
+ }
+
+ @Override
+ public Configuration getDefaultConfiguration(Set> workers) {
+ Configuration concurrentCfg;
+ if (this.noOfBlobs > 1)
+ concurrentCfg = partitionManager.getDefaultConfiguration(workers,
+ noOfBlobs);
+ else
+ concurrentCfg = Configuration.builder().build();
+
+ if (!Options.useCompilerBlob)
+ return concurrentCfg;
+
+ Configuration.Builder builder = Configuration.builder(concurrentCfg);
+ BlobFactory compilerBf = new Compiler2BlobFactory();
+ Configuration compilercfg = compilerBf.getDefaultConfiguration(workers);
+ for (Parameter p : compilercfg.getParametersMap().values())
+ builder.addParameter(p);
+ return builder.build();
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime
+ * result
+ + ((partitionManager == null) ? 0 : partitionManager.hashCode());
+ result = prime * result + noOfBlobs;
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ ConcurrentBlobFactory other = (ConcurrentBlobFactory) obj;
+ if (partitionManager == null) {
+ if (other.partitionManager != null)
+ return false;
+ } else if (!partitionManager.equals(other.partitionManager))
+ return false;
+ if (noOfBlobs != other.noOfBlobs)
+ return false;
+ return true;
+ }
+}
diff --git a/src/edu/mit/streamjit/impl/concurrent/ConcurrentDrainer.java b/src/edu/mit/streamjit/impl/concurrent/ConcurrentDrainer.java
index ebe5357d..165e06f6 100644
--- a/src/edu/mit/streamjit/impl/concurrent/ConcurrentDrainer.java
+++ b/src/edu/mit/streamjit/impl/concurrent/ConcurrentDrainer.java
@@ -21,16 +21,21 @@
*/
package edu.mit.streamjit.impl.concurrent;
+import static com.google.common.base.Preconditions.checkNotNull;
+
import java.util.Map;
import java.util.Set;
-import static com.google.common.base.Preconditions.*;
import com.google.common.collect.ImmutableMap;
import edu.mit.streamjit.impl.blob.Blob;
import edu.mit.streamjit.impl.blob.Blob.Token;
-import edu.mit.streamjit.impl.common.AbstractDrainer;
import edu.mit.streamjit.impl.common.BlobThread;
+import edu.mit.streamjit.impl.common.TimeLogger;
+import edu.mit.streamjit.impl.common.drainer.AbstractDrainer;
+import edu.mit.streamjit.impl.common.drainer.BlobGraph;
+import edu.mit.streamjit.impl.distributed.StreamJitApp;
+import edu.mit.streamjit.impl.distributed.common.CTRLRDrainElement.DrainType;
import edu.mit.streamjit.impl.distributed.common.Utils;
/**
@@ -52,8 +57,9 @@ public final class ConcurrentDrainer extends AbstractDrainer {
*/
ImmutableMap> threadMap;
- public ConcurrentDrainer(BlobGraph blobGraph,
- Map> threadMap) {
+ public ConcurrentDrainer(StreamJitApp app, TimeLogger logger,
+ BlobGraph blobGraph, Map> threadMap) {
+ super(app, logger);
setBlobGraph(blobGraph);
blobMap = buildBlobMap(threadMap.keySet());
this.threadMap = ImmutableMap.copyOf(threadMap);
@@ -65,7 +71,7 @@ protected void drainingDone(boolean isFinal) {
}
@Override
- protected void drain(Token blobID, boolean isFinal) {
+ protected void drain(Token blobID, DrainType drainType) {
Blob blob = blobMap.get(blobID);
checkNotNull(blob);
@@ -116,6 +122,5 @@ public void run() {
@Override
protected void prepareDraining(boolean isFinal) {
- // TODO Auto-generated method stub
}
}
diff --git a/src/edu/mit/streamjit/impl/concurrent/ConcurrentStreamCompiler.java b/src/edu/mit/streamjit/impl/concurrent/ConcurrentStreamCompiler.java
index 4f7b0799..299b6f53 100644
--- a/src/edu/mit/streamjit/impl/concurrent/ConcurrentStreamCompiler.java
+++ b/src/edu/mit/streamjit/impl/concurrent/ConcurrentStreamCompiler.java
@@ -44,8 +44,6 @@
import edu.mit.streamjit.impl.blob.Blob.Token;
import edu.mit.streamjit.impl.blob.Buffer;
import edu.mit.streamjit.impl.blob.ConcurrentArrayBuffer;
-import edu.mit.streamjit.impl.common.AbstractDrainer;
-import edu.mit.streamjit.impl.common.AbstractDrainer.BlobGraph;
import edu.mit.streamjit.impl.common.BlobThread;
import edu.mit.streamjit.impl.common.Configuration;
import edu.mit.streamjit.impl.common.Configuration.IntParameter;
@@ -56,6 +54,9 @@
import edu.mit.streamjit.impl.common.OutputBufferFactory;
import edu.mit.streamjit.impl.common.Portals;
import edu.mit.streamjit.impl.common.VerifyStreamGraph;
+import edu.mit.streamjit.impl.common.drainer.AbstractDrainer;
+import edu.mit.streamjit.impl.common.drainer.BlobGraph;
+import edu.mit.streamjit.impl.distributed.DistributedStreamCompiler;
import edu.mit.streamjit.impl.interp.ChannelFactory;
import edu.mit.streamjit.impl.interp.Interpreter;
import edu.mit.streamjit.partitioner.HorizontalPartitioner;
@@ -63,7 +64,14 @@
/**
* A stream compiler that partitions a streamgraph into multiple blobs and
- * execute it on multiple threads.
+ * execute them on a single node. This {@link StreamCompiler} can be used for
+ * following purposes
+ *
+ * - Single blob online tuning.
+ *
- Multiple blobs on a single node. This will simulate
+ * {@link DistributedStreamCompiler} on a single node to find out deadlocks and
+ * other issues.
+ *
*
* @author Sumanan sumanan@mit.edu
* @since Apr 8, 2013
@@ -72,9 +80,8 @@ public class ConcurrentStreamCompiler implements StreamCompiler {
int noOfBlobs;
/**
- * @param Patrions
- * a stream graph up to noOfBlobs many blobs and executes each
- * blob on each thread.
+ * @param noOfBlobs
+ * Maximum number of blobs that can be created.
*/
public ConcurrentStreamCompiler(int noOfBlobs) {
if (noOfBlobs < 1)
@@ -83,15 +90,20 @@ public ConcurrentStreamCompiler(int noOfBlobs) {
this.noOfBlobs = noOfBlobs;
}
- public ConcurrentStreamCompiler(Configuration cfg) {
+ public ConcurrentStreamCompiler() {
+ this(1);
+ }
- IntParameter threadCount = cfg.getParameter("threadCount",
- IntParameter.class);
- this.noOfBlobs = threadCount.getValue();
- if (noOfBlobs < 1)
- throw new IllegalArgumentException(
- "noOfBlobs should be 1 or greater");
- this.noOfBlobs = noOfBlobs;
+ public ConcurrentStreamCompiler(Configuration cfg) {
+ IntParameter nBlobs = cfg.getParameter("noOfBlobs", IntParameter.class);
+ if (nBlobs == null)
+ this.noOfBlobs = 1;
+ else {
+ this.noOfBlobs = nBlobs.getValue();
+ if (noOfBlobs < 1)
+ throw new IllegalArgumentException(
+ "noOfBlobs should be 1 or greater");
+ }
}
@Override
diff --git a/src/edu/mit/streamjit/impl/distributed/ConfigurationManager.java b/src/edu/mit/streamjit/impl/distributed/ConfigurationManager.java
index 022631b2..4074cdd6 100644
--- a/src/edu/mit/streamjit/impl/distributed/ConfigurationManager.java
+++ b/src/edu/mit/streamjit/impl/distributed/ConfigurationManager.java
@@ -21,372 +21,65 @@
*/
package edu.mit.streamjit.impl.distributed;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.Map.Entry;
-import edu.mit.streamjit.api.Filter;
-import edu.mit.streamjit.api.Joiner;
-import edu.mit.streamjit.api.Splitter;
+import edu.mit.streamjit.api.StreamCompilationFailedException;
import edu.mit.streamjit.api.Worker;
-import edu.mit.streamjit.impl.blob.BlobFactory;
-import edu.mit.streamjit.impl.blob.Blob.Token;
import edu.mit.streamjit.impl.common.Configuration;
-import edu.mit.streamjit.impl.common.Workers;
-import edu.mit.streamjit.impl.common.Configuration.PartitionParameter;
-import edu.mit.streamjit.impl.distributed.common.GlobalConstants;
-import edu.mit.streamjit.impl.distributed.common.Utils;
-import edu.mit.streamjit.impl.distributed.node.StreamNode;
-import edu.mit.streamjit.impl.interp.Interpreter;
-import edu.mit.streamjit.partitioner.AbstractPartitioner;
+import edu.mit.streamjit.impl.common.drainer.BlobGraph;
+import edu.mit.streamjit.tuner.OnlineTuner;
-/**
- * ConfigurationManager deals with {@link Configuration}. Mainly, It does
- * following two tasks.
- *
- * - Generates configuration for with appropriate tuning parameters for
- * tuning.
- *
- Dispatch the configuration given by the open tuner and make blobs
- * accordingly.
- *
- *
- * One can implement this interface to try different search space designs as
- * they want.
- *
- * @author Sumanan sumanan@mit.edu
- * @since Jan 16, 2014
- *
- */
-public interface ConfigurationManager {
+public class ConfigurationManager {
- /**
- * Generates default configuration with all tuning parameters for tuning.
- *
- * @param streamGraph
- * @param source
- * @param sink
- * @param noOfMachines
- * @return
- */
- public Configuration getDefaultConfiguration(Set> workers,
- int noOfMachines);
+ private final StreamJitApp app;
+
+ private final PartitionManager partitionManager;
+
+ public ConfigurationManager(StreamJitApp app,
+ PartitionManager partitionManager) {
+ this.app = app;
+ this.partitionManager = partitionManager;
+ }
/**
- * When opentuner gives a new configuration, this method may be called to
- * interpret the configuration and execute the steramjit app with the new
+ * This method may be called to by the {@link OnlineTuner} to interpret a
+ * new configuration and execute the steramjit app with the new
* configuration.
+ *
+ * Builds partitionsMachineMap and {@link BlobGraph} from the new
+ * Configuration, and verifies for any cycles among blobs. If it is a valid
+ * configuration, (i.e., no cycles among the blobs), then {@link #app}
+ * object's member variables {@link StreamJitApp#blobConfiguration},
+ * {@link StreamJitApp#blobGraph} and
+ * {@link StreamJitApp#partitionsMachineMap} will be assigned according to
+ * reflect the new configuration, no changes otherwise.
*
* @param config
- * configuration from opentuner.
+ * configuration from {@link OnlineTuner}.
* @return true iff valid configuration is passed.
*/
- public boolean newConfiguration(Configuration config);
-
- /**
- * Generates static information of the app that is needed by steramnodes.
- * This configuration will be sent to streamnodes when setting up a new app
- * for execution (Only once).
- *
- * @return static information of the app that is needed by steramnodes.
- */
- public Configuration getStaticConfiguration();
-
- /**
- * For every reconfiguration, this method may be called by the appropriate
- * class to get new configuration information that can be sent to all
- * participating {@link StreamNode}s.
- *
- * @return new partition information
- */
- public Configuration getDynamicConfiguration();
-
- /**
- * Implements the functions those can be called by runtimer to send
- * configuration information to streamnodes.
- *
- * @author Sumanan sumanan@mit.edu
- * @since Jan 17, 2014
- */
- public static abstract class AbstractConfigurationManager
- implements
- ConfigurationManager {
-
- protected final StreamJitApp app;
-
- AbstractConfigurationManager(StreamJitApp app) {
- this.app = app;
+ public boolean newConfiguration(Configuration config) {
+ // for (Parameter p : config.getParametersMap().values()) {
+ // if (p instanceof IntParameter) {
+ // IntParameter ip = (IntParameter) p;
+ // System.out.println(ip.getName() + " - " + ip.getValue());
+ // } else if (p instanceof SwitchParameter) {
+ // SwitchParameter sp = (SwitchParameter) p;
+ // System.out.println(sp.getName() + " - " + sp.getValue());
+ // } else
+ // System.out.println(p.getName() + " - Unknown type");
+ // }
+
+ Map>>> partitionsMachineMap = partitionManager
+ .partitionMap(config);
+ try {
+ app.verifyConfiguration(partitionsMachineMap);
+ } catch (StreamCompilationFailedException ex) {
+ return false;
}
-
- @Override
- public Configuration getStaticConfiguration() {
- Configuration.Builder builder = Configuration.builder();
- builder.putExtraData(GlobalConstants.JARFILE_PATH, app.jarFilePath)
- .putExtraData(GlobalConstants.TOPLEVEL_WORKER_NAME,
- app.topLevelClass);
- return builder.build();
- }
-
- @Override
- public Configuration getDynamicConfiguration() {
- Configuration.Builder builder = Configuration.builder();
-
- Map coresPerMachine = new HashMap<>();
- for (Entry>>> machine : app.partitionsMachineMap
- .entrySet()) {
- coresPerMachine
- .put(machine.getKey(), machine.getValue().size());
- }
-
- PartitionParameter.Builder partParam = PartitionParameter.builder(
- GlobalConstants.PARTITION, coresPerMachine);
-
- BlobFactory factory = new Interpreter.InterpreterBlobFactory();
- partParam.addBlobFactory(factory);
-
- app.blobtoMachineMap = new HashMap<>();
-
- for (Integer machineID : app.partitionsMachineMap.keySet()) {
- List>> blobList = app.partitionsMachineMap
- .get(machineID);
- for (Set> blobWorkers : blobList) {
- // TODO: One core per blob. Need to change this.
- partParam.addBlob(machineID, 1, factory, blobWorkers);
-
- // TODO: Temp fix to build.
- Token t = Utils.getblobID(blobWorkers);
- app.blobtoMachineMap.put(t, machineID);
- }
- }
-
- builder.addParameter(partParam.build());
- if (app.blobConfiguration != null)
- builder.addSubconfiguration("blobConfigs",
- app.blobConfiguration);
- return builder.build();
- }
-
- /**
- * Copied form {@link AbstractPartitioner} class. But modified to
- * support nested splitjoiners.
Returns all {@link Worker}s in a
- * splitjoin.
- *
- * @param splitter
- * @return Returns all {@link Filter}s in a splitjoin.
- */
- protected void getAllChildWorkers(Splitter splitter,
- Set> childWorkers) {
- childWorkers.add(splitter);
- Joiner joiner = getJoiner(splitter);
- Worker cur;
- for (Worker childWorker : Workers.getSuccessors(splitter)) {
- cur = childWorker;
- while (cur != joiner) {
- if (cur instanceof Filter)
- childWorkers.add(cur);
- else if (cur instanceof Splitter) {
- getAllChildWorkers((Splitter) cur, childWorkers);
- cur = getJoiner((Splitter) cur);
- } else
- throw new IllegalStateException(
- "Some thing wrong in the algorithm.");
-
- assert Workers.getSuccessors(cur).size() == 1 : "Illegal State encounted : cur can only be either a filter or a joner";
- cur = Workers.getSuccessors(cur).get(0);
- }
- }
- childWorkers.add(joiner);
- }
-
- /**
- * Find and returns the corresponding {@link Joiner} for the passed
- * {@link Splitter}.
- *
- * @param splitter
- * : {@link Splitter} that needs it's {@link Joiner}.
- * @return Corresponding {@link Joiner} of the passed {@link Splitter}.
- */
- protected Joiner getJoiner(Splitter splitter) {
- Worker cur = Workers.getSuccessors(splitter).get(0);
- int innerSplitjoinCount = 0;
- while (!(cur instanceof Joiner) || innerSplitjoinCount != 0) {
- if (cur instanceof Splitter)
- innerSplitjoinCount++;
- if (cur instanceof Joiner)
- innerSplitjoinCount--;
- assert innerSplitjoinCount >= 0 : "Joiner Count is more than splitter count. Check the algorithm";
- cur = Workers.getSuccessors(cur).get(0);
- }
- assert cur instanceof Joiner : "Error in algorithm. Not returning a Joiner";
- return (Joiner) cur;
- }
-
- protected String getParamName(Integer id) {
- assert id > -1 : "Worker id cannot be negative";
- return String.format("worker%dtomachine", id);
- }
-
- /**
- * Goes through all workers in workerset which is passed as argument,
- * find the workers which are interconnected and group them as a blob
- * workers. i.e., Group the workers which are connected.
- *
- * TODO: If any dynamic edges exists then should create interpreter
- * blob.
- *
- * @param workerset
- * @return list of workers set which contains interconnected workers.
- * Each worker set in the list is supposed to run in an
- * individual blob.
- */
- protected List>> getConnectedComponents(
- Set> workerset) {
- List>> ret = new ArrayList>>();
- while (!workerset.isEmpty()) {
- Deque> queue = new ArrayDeque<>();
- Set> blobworkers = new HashSet<>();
- Worker w = workerset.iterator().next();
- blobworkers.add(w);
- workerset.remove(w);
- queue.offer(w);
- while (!queue.isEmpty()) {
- Worker wrkr = queue.poll();
- for (Worker succ : Workers.getSuccessors(wrkr)) {
- if (workerset.contains(succ)) {
- blobworkers.add(succ);
- workerset.remove(succ);
- queue.offer(succ);
- }
- }
-
- for (Worker pred : Workers.getPredecessors(wrkr)) {
- if (workerset.contains(pred)) {
- blobworkers.add(pred);
- workerset.remove(pred);
- queue.offer(pred);
- }
- }
- }
- ret.add(blobworkers);
- }
- return ret;
- }
-
- /**
- * Cycles can occur iff splitter and joiner happened to fall into a blob
- * while some workers of that splitjoin falls into other blob. Here, we
- * check for the above mention condition. If cycles exists, split then
- * in to several blobs.
- *
- * @param blobworkers
- * @return
- */
- protected List>> breakCycles(
- Set> blobworkers) {
- Map, Joiner> rfctrSplitJoin = new HashMap<>();
- Set> splitterSet = getSplitters(blobworkers);
- for (Splitter s : splitterSet) {
- Joiner j = getJoiner(s);
- if (blobworkers.contains(j)) {
- Set> childWorkers = new HashSet<>();
- getAllChildWorkers(s, childWorkers);
- if (!blobworkers.containsAll(childWorkers)) {
- rfctrSplitJoin.put(s, j);
- }
- }
- }
-
- List>> ret = new ArrayList<>();
-
- for (Splitter s : rfctrSplitJoin.keySet()) {
- if (blobworkers.contains(s)) {
- ret.add(getSplitterReachables(s, blobworkers,
- rfctrSplitJoin));
- }
- }
- ret.addAll(getConnectedComponents(blobworkers));
- return ret;
- }
-
- /**
- * Goes through the passed set of workers, add workers those are
- * reachable from the splitter s, but not any conflicting splitter or
- * joiner.
- *
- * This function has side effect. Modifies the argument.
- *
- * @param s
- * @param blobworkers
- * @return
- */
- protected Set> getSplitterReachables(Splitter s,
- Set> blobworkers,
- Map, Joiner> rfctrSplitJoin) {
- assert blobworkers.contains(s) : "Splitter s in not in blobworkers";
- Set> ret = new HashSet<>();
- Set> exclude = new HashSet<>();
- Deque> queue = new ArrayDeque<>();
- ret.add(s);
- exclude.add(rfctrSplitJoin.get(s));
- blobworkers.remove(s);
- queue.offer(s);
- while (!queue.isEmpty()) {
- Worker wrkr = queue.poll();
- for (Worker succ : Workers.getSuccessors(wrkr)) {
- process(succ, blobworkers, rfctrSplitJoin, exclude, queue,
- ret);
- }
-
- for (Worker pred : Workers.getPredecessors(wrkr)) {
- process(pred, blobworkers, rfctrSplitJoin, exclude, queue,
- ret);
- }
- }
- return ret;
- }
-
- /**
- * Since the code in this method repeated in two places in
- * getSplitterReachables() method, It is re-factored into a private
- * method to avoid code duplication.
- */
- protected void process(Worker wrkr,
- Set> blobworkers,
- Map, Joiner> rfctrSplitJoin,
- Set> exclude, Deque> queue,
- Set> ret) {
- if (blobworkers.contains(wrkr) && !exclude.contains(wrkr)) {
- ret.add(wrkr);
- blobworkers.remove(wrkr);
- queue.offer(wrkr);
-
- for (Entry, Joiner> e : rfctrSplitJoin
- .entrySet()) {
- if (e.getValue().equals(wrkr)) {
- exclude.add(e.getKey());
- break;
- } else if (e.getKey().equals(wrkr)) {
- exclude.add(e.getValue());
- break;
- }
- }
- }
- }
-
- protected Set> getSplitters(Set> blobworkers) {
- Set> splitterSet = new HashSet<>();
- for (Worker w : blobworkers) {
- if (w instanceof Splitter) {
- splitterSet.add((Splitter) w);
- }
- }
- return splitterSet;
- }
-
+ app.setConfiguration(config);
+ return true;
}
}
diff --git a/src/edu/mit/streamjit/impl/distributed/ConnectionManager.java b/src/edu/mit/streamjit/impl/distributed/ConnectionManager.java
new file mode 100644
index 00000000..be47742d
--- /dev/null
+++ b/src/edu/mit/streamjit/impl/distributed/ConnectionManager.java
@@ -0,0 +1,371 @@
+package edu.mit.streamjit.impl.distributed;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import edu.mit.streamjit.api.Worker;
+import edu.mit.streamjit.impl.blob.Blob.Token;
+import edu.mit.streamjit.impl.common.Configuration;
+import edu.mit.streamjit.impl.common.Configuration.Builder;
+import edu.mit.streamjit.impl.common.Configuration.Parameter;
+import edu.mit.streamjit.impl.common.Configuration.SwitchParameter;
+import edu.mit.streamjit.impl.common.Workers;
+import edu.mit.streamjit.impl.distributed.common.AsyncTCPConnection.AsyncTCPConnectionInfo;
+import edu.mit.streamjit.impl.distributed.common.BoundaryChannel;
+import edu.mit.streamjit.impl.distributed.common.Connection;
+import edu.mit.streamjit.impl.distributed.common.Connection.ConnectionInfo;
+import edu.mit.streamjit.impl.distributed.common.Connection.ConnectionType;
+import edu.mit.streamjit.impl.distributed.common.Connection.GenericConnectionInfo;
+import edu.mit.streamjit.impl.distributed.common.TCPConnection.TCPConnectionInfo;
+import edu.mit.streamjit.impl.distributed.node.StreamNode;
+
+/**
+ * Generates configuration parameters to tune the {@link Connection}'s
+ * communication type such as blocking TCP connection, asynchronous TCP
+ * connection, Infiniband, etc.
+ *
+ * @author Sumanan sumanan@mit.edu
+ * @since Jun 23, 2014
+ *
+ */
+public interface ConnectionManager {
+
+ /**
+ * Generates parameters to tune {@link BoundaryChannel} and add those into
+ * the {@link Configuration.Builder}.
+ *
+ * @param cfgBuilder
+ * @param workers
+ */
+ public void addConnectionParameters(Configuration.Builder cfgBuilder,
+ Set> workers);
+
+ /**
+ * Generates parameters to tune {@link BoundaryChannel} and return those as
+ * a new {@link Configuration}.
+ *
+ * @param workers
+ * @return
+ */
+ public Configuration getDefaultConfiguration(Set> workers);
+
+ /**
+ * Decides {@link Connection} type for each inter-blob connection based on
+ * the {@link cfg}.
+ *
+ * @param cfg
+ * @param partitionsMachineMap
+ * @param source
+ * @param sink
+ * @return
+ */
+ public Map conInfoMap(Configuration cfg,
+ Map>>> partitionsMachineMap,
+ Worker source, Worker sink);
+
+ /**
+ * Sometimes an assigned TCP ports may not available to make new connection
+ * at {@link StreamNode}s side. In this case a new {@link ConnectionInfo}
+ * must be created to replace already created {@link ConnectionInfo}.
+ *
+ * @param conInfo
+ * : Problematic {@link ConnectionInfo}.
+ * @return : New {@link ConnectionInfo} to replace problematic
+ * {@link ConnectionInfo}.
+ */
+ public ConnectionInfo replaceConInfo(ConnectionInfo conInfo);
+
+ public abstract static class AbstractConnectionManager implements
+ ConnectionManager {
+
+ private final int controllerNodeID;
+
+ protected Set currentConInfos;
+
+ protected int startPortNo = 24896; // Just a random magic number.
+
+ public AbstractConnectionManager(int controllerNodeID) {
+ this.controllerNodeID = controllerNodeID;
+ this.currentConInfos = new HashSet<>();
+ }
+
+ public Map conInfoMap(Configuration cfg,
+ Map>>> partitionsMachineMap,
+ Worker source, Worker sink) {
+
+ assert partitionsMachineMap != null : "partitionsMachineMap is null";
+
+ Set usedConInfos = new HashSet<>();
+ Map conInfoMap = new HashMap<>();
+
+ for (Integer machineID : partitionsMachineMap.keySet()) {
+ List>> blobList = partitionsMachineMap
+ .get(machineID);
+ Set> allWorkers = new HashSet<>(); // Contains all
+ // workers those
+ // are
+ // assigned to
+ // the
+ // current
+ // machineID
+ // machine.
+ for (Set> blobWorkers : blobList) {
+ allWorkers.addAll(blobWorkers);
+ }
+
+ for (Worker w : allWorkers) {
+ for (Worker succ : Workers.getSuccessors(w)) {
+ if (allWorkers.contains(succ))
+ continue;
+ int dstMachineID = getAssignedMachine(succ,
+ partitionsMachineMap);
+ Token t = new Token(w, succ);
+ addtoconInfoMap(machineID, dstMachineID, t,
+ usedConInfos, conInfoMap, cfg);
+ }
+ }
+ }
+
+ Token headToken = Token.createOverallInputToken(source);
+ int dstMachineID = getAssignedMachine(source, partitionsMachineMap);
+ addtoconInfoMap(controllerNodeID, dstMachineID, headToken,
+ usedConInfos, conInfoMap, cfg);
+
+ Token tailToken = Token.createOverallOutputToken(sink);
+ int srcMahineID = getAssignedMachine(sink, partitionsMachineMap);
+ addtoconInfoMap(srcMahineID, controllerNodeID, tailToken,
+ usedConInfos, conInfoMap, cfg);
+
+ return conInfoMap;
+ }
+
+ /**
+ * @param worker
+ * @return the machineID where on which the passed worker is assigned.
+ */
+ private int getAssignedMachine(Worker worker,
+ Map>>> partitionsMachineMap) {
+ for (Integer machineID : partitionsMachineMap.keySet()) {
+ for (Set> workers : partitionsMachineMap
+ .get(machineID)) {
+ if (workers.contains(worker))
+ return machineID;
+ }
+ }
+
+ throw new IllegalArgumentException(String.format(
+ "%s is not assigned to anyof the machines", worker));
+ }
+
+ protected abstract void addtoconInfoMap(int srcID, int dstID, Token t,
+ Set usedConInfos,
+ Map conInfoMap, Configuration cfg);
+
+ protected List getTcpConInfo(ConnectionInfo conInfo) {
+ List conList = new ArrayList<>();
+ for (ConnectionInfo tcpconInfo : currentConInfos) {
+ if (conInfo.equals(tcpconInfo))
+ conList.add(tcpconInfo);
+ }
+ return conList;
+ }
+
+ protected String getParamName(Token t) {
+ return String.format("ConnectionType-%d:%d",
+ t.getUpstreamIdentifier(), t.getDownstreamIdentifier());
+ }
+
+ public ConnectionInfo replaceConInfo(ConnectionInfo conInfo) {
+ if (currentConInfos.contains(conInfo))
+ currentConInfos.remove(conInfo);
+ ConnectionInfo newConinfo;
+ if (conInfo.getSrcID() == 0)
+ newConinfo = new TCPConnectionInfo(conInfo.getSrcID(),
+ conInfo.getDstID(), startPortNo++);
+ else
+ newConinfo = new AsyncTCPConnectionInfo(conInfo.getSrcID(),
+ conInfo.getDstID(), startPortNo++);
+ currentConInfos.add(newConinfo);
+
+ return newConinfo;
+ }
+ }
+
+ public static abstract class NoParams extends AbstractConnectionManager {
+
+ public NoParams(int controllerNodeID) {
+ super(controllerNodeID);
+ }
+
+ @Override
+ public void addConnectionParameters(Builder cfgBuilder,
+ Set> workers) {
+ return;
+ }
+
+ @Override
+ public Configuration getDefaultConfiguration(Set> workers) {
+ return Configuration.builder().build();
+ }
+
+ protected void addtoconInfoMap(int srcID, int dstID, Token t,
+ Set usedConInfos,
+ Map conInfoMap, Configuration cfg) {
+
+ ConnectionInfo conInfo = new GenericConnectionInfo(srcID, dstID);
+
+ List conSet = getTcpConInfo(conInfo);
+ ConnectionInfo tcpConInfo = null;
+
+ for (ConnectionInfo con : conSet) {
+ if (!usedConInfos.contains(con)) {
+ tcpConInfo = con;
+ break;
+ }
+ }
+
+ if (tcpConInfo == null) {
+ tcpConInfo = makeConnectionInfo(srcID, dstID);
+ this.currentConInfos.add(tcpConInfo);
+ }
+
+ conInfoMap.put(t, tcpConInfo);
+ usedConInfos.add(tcpConInfo);
+ }
+
+ protected abstract ConnectionInfo makeConnectionInfo(int srcID,
+ int dstID);
+ }
+
+ public static class BlockingTCPNoParams extends NoParams {
+
+ public BlockingTCPNoParams(int controllerNodeID) {
+ super(controllerNodeID);
+ }
+
+ @Override
+ protected ConnectionInfo makeConnectionInfo(int srcID, int dstID) {
+ return new TCPConnectionInfo(srcID, dstID, startPortNo++);
+ }
+ }
+
+ public static class AsyncTCPNoParams extends NoParams {
+
+ public AsyncTCPNoParams(int controllerNodeID) {
+ super(controllerNodeID);
+ }
+
+ @Override
+ protected ConnectionInfo makeConnectionInfo(int srcID, int dstID) {
+ return new AsyncTCPConnectionInfo(srcID, dstID, startPortNo++);
+ }
+ }
+
+ public static class AllConnectionParams extends AbstractConnectionManager {
+ public AllConnectionParams(int controllerNodeID) {
+ super(controllerNodeID);
+ }
+
+ @Override
+ public void addConnectionParameters(Builder cfgBuilder,
+ Set> workers) {
+ for (Worker w : workers) {
+ for (Worker succ : Workers.getSuccessors(w)) {
+ Token t = new Token(w, succ);
+ Parameter p = new Configuration.SwitchParameter(
+ getParamName(t), ConnectionType.class,
+ ConnectionType.BTCP, Arrays.asList(ConnectionType
+ .values()));
+ cfgBuilder.addParameter(p);
+ }
+ }
+
+ // Add Parameter for global input channel.
+ Set> heads = Workers.getTopmostWorkers(workers);
+ assert heads.size() == 1 : "Multiple first workers";
+ for (Worker firstWorker : heads) {
+ Token t = Token.createOverallInputToken(firstWorker);
+ Parameter p = new Configuration.SwitchParameter(
+ getParamName(t), ConnectionType.class,
+ ConnectionType.BTCP, Arrays.asList(ConnectionType
+ .values()));
+ cfgBuilder.addParameter(p);
+ }
+
+ // Add Parameter for global output channel.
+ Set> tail = Workers.getBottommostWorkers(workers);
+ assert tail.size() == 1 : "Multiple first workers";
+ for (Worker lastWorker : tail) {
+ Token t = Token.createOverallOutputToken(lastWorker);
+ Parameter p = new Configuration.SwitchParameter(
+ getParamName(t), ConnectionType.class,
+ ConnectionType.BTCP, Arrays.asList(ConnectionType
+ .values()));
+ cfgBuilder.addParameter(p);
+ }
+ }
+
+ @Override
+ public Configuration getDefaultConfiguration(Set> workers) {
+ Configuration.Builder cfgBuilder = Configuration.builder();
+ addConnectionParameters(cfgBuilder, workers);
+ return cfgBuilder.build();
+ }
+
+ protected void addtoconInfoMap(int srcID, int dstID, Token t,
+ Set usedConInfos,
+ Map conInfoMap, Configuration cfg) {
+
+ ConnectionInfo conInfo = new GenericConnectionInfo(srcID, dstID);
+
+ List conSet = getTcpConInfo(conInfo);
+ ConnectionInfo tcpConInfo = null;
+
+ for (ConnectionInfo con : conSet) {
+ if (!usedConInfos.contains(con)) {
+ tcpConInfo = con;
+ break;
+ }
+ }
+
+ if (tcpConInfo == null) {
+ tcpConInfo = makeConnectionInfo(srcID, dstID, t, cfg);
+ this.currentConInfos.add(tcpConInfo);
+ }
+
+ conInfoMap.put(t, tcpConInfo);
+ usedConInfos.add(tcpConInfo);
+ }
+
+ private ConnectionInfo makeConnectionInfo(int srcID, int dstID,
+ Token t, Configuration cfg) {
+ SwitchParameter p = cfg.getParameter(
+ getParamName(t), SwitchParameter.class,
+ ConnectionType.class);
+
+ if (p == null)
+ throw new IllegalStateException(String.format(
+ "No tuning parameter for connection %s", t));
+
+ ConnectionInfo conInfo;
+ switch (p.getValue()) {
+ case BTCP :
+ conInfo = new TCPConnectionInfo(srcID, dstID, startPortNo++);
+ break;
+ case ATCP :
+ conInfo = new AsyncTCPConnectionInfo(srcID, dstID,
+ startPortNo++);
+ break;
+ default :
+ throw new IllegalStateException(String.format(
+ "Unsupported connection type - %s", p.getValue()));
+ }
+ return conInfo;
+ }
+ }
+}
diff --git a/src/edu/mit/streamjit/impl/distributed/DistributedAppRunner.java b/src/edu/mit/streamjit/impl/distributed/DistributedAppRunner.java
index 030691d0..441e981a 100644
--- a/src/edu/mit/streamjit/impl/distributed/DistributedAppRunner.java
+++ b/src/edu/mit/streamjit/impl/distributed/DistributedAppRunner.java
@@ -24,13 +24,10 @@
import edu.mit.streamjit.api.CompiledStream;
import edu.mit.streamjit.api.Output;
import edu.mit.streamjit.api.StreamCompiler;
-import edu.mit.streamjit.impl.distributed.common.GlobalConstants;
-import edu.mit.streamjit.impl.interp.DebugStreamCompiler;
import edu.mit.streamjit.test.Benchmark;
-import edu.mit.streamjit.test.BenchmarkProvider;
import edu.mit.streamjit.test.Benchmark.Dataset;
+import edu.mit.streamjit.test.BenchmarkProvider;
import edu.mit.streamjit.test.apps.channelvocoder7.ChannelVocoder7;
-import edu.mit.streamjit.test.apps.fmradio.FMRadio.FMRadioBenchmarkProvider;
public class DistributedAppRunner {
@@ -85,8 +82,6 @@ public static void main(String[] args) throws InterruptedException {
}
}
- GlobalConstants.tunerMode = 1;
-
Benchmark benchmark = bp.iterator().next();
// StreamCompiler compiler = new Compiler2StreamCompiler();
StreamCompiler compiler = new DistributedStreamCompiler(noOfNodes);
diff --git a/src/edu/mit/streamjit/impl/distributed/DistributedBlobFactory.java b/src/edu/mit/streamjit/impl/distributed/DistributedBlobFactory.java
index f11ebd92..d3c8d397 100644
--- a/src/edu/mit/streamjit/impl/distributed/DistributedBlobFactory.java
+++ b/src/edu/mit/streamjit/impl/distributed/DistributedBlobFactory.java
@@ -29,7 +29,10 @@
import edu.mit.streamjit.impl.blob.DrainData;
import edu.mit.streamjit.impl.common.Configuration;
import edu.mit.streamjit.impl.common.Configuration.Parameter;
+import edu.mit.streamjit.impl.compiler.CompilerBlobFactory;
import edu.mit.streamjit.impl.compiler2.Compiler2BlobFactory;
+import edu.mit.streamjit.impl.distributed.ConnectionManager.BlockingTCPNoParams;
+import edu.mit.streamjit.impl.distributed.common.Options;
import edu.mit.streamjit.impl.interp.Interpreter.InterpreterBlobFactory;
/**
@@ -45,53 +48,69 @@
*
* TODO: For the moment this factory just deal with compiler blob. Need to make
* interpreter blob as well based on the dynamic edges.
- *
+ *
* @author Sumanan sumanan@mit.edu
* @since Sep 24, 2013
*/
public class DistributedBlobFactory implements BlobFactory {
- private int noOfMachines;
+ private final int noOfMachines;
+
+ private final PartitionManager partitionManager;
- private final ConfigurationManager cfgManager;
+ private final ConnectionManager connectionManager;
- public DistributedBlobFactory(ConfigurationManager cfgManager,
- int noOfMachines) {
- this.cfgManager = cfgManager;
+ public DistributedBlobFactory(PartitionManager partitionManager,
+ ConnectionManager connectionManager, int noOfMachines) {
+ this.partitionManager = partitionManager;
this.noOfMachines = noOfMachines;
+ this.connectionManager = connectionManager;
}
/**
- * If {@link ConfigurationManager} is not passed as a constructor argument
- * then {@link WorkerMachine} will be used as default one.
- *
+ * If {@link PartitionManager} is not passed as a constructor argument then
+ * {@link WorkerMachine} will be used as default one.
+ *
* @param noOfMachines
*/
public DistributedBlobFactory(int noOfMachines) {
- this(new WorkerMachine(null), noOfMachines);
+ this(new WorkerMachine(null), new BlockingTCPNoParams(0), noOfMachines);
}
@Override
public Blob makeBlob(Set> workers, Configuration config,
int maxNumCores, DrainData initialState) {
- return new Compiler2BlobFactory().makeBlob(workers, config, maxNumCores, initialState);
+ return new Compiler2BlobFactory().makeBlob(workers, config,
+ maxNumCores, initialState);
}
@Override
public Configuration getDefaultConfiguration(Set> workers) {
+ Configuration distCfg = partitionManager.getDefaultConfiguration(
+ workers, noOfMachines);
+ if (!Options.useCompilerBlob)
+ return distCfg;
- Configuration distCfg = cfgManager.getDefaultConfiguration(workers,
- noOfMachines);
Configuration.Builder builder = Configuration.builder(distCfg);
-
BlobFactory compilerBf = new Compiler2BlobFactory();
Configuration compilercfg = compilerBf.getDefaultConfiguration(workers);
for (Parameter p : compilercfg.getParametersMap().values())
builder.addParameter(p);
+ connectionManager.addConnectionParameters(builder, workers);
+ // addMaxCoreParam(builder);
return builder.build();
}
+ private void addMaxCoreParam(Configuration.Builder builder) {
+ int min = 1;
+ int val = Options.maxNumCores / 2;
+ val = min > val ? min : val;
+ Parameter p = new Configuration.IntParameter("maxNumCores", min,
+ Options.maxNumCores, val);
+ builder.addParameter(p);
+ }
+
@Override
public boolean equals(Object o) {
return getClass() == o.getClass()
diff --git a/src/edu/mit/streamjit/impl/distributed/DistributedStreamCompiler.java b/src/edu/mit/streamjit/impl/distributed/DistributedStreamCompiler.java
index e51c451b..3262ce6f 100644
--- a/src/edu/mit/streamjit/impl/distributed/DistributedStreamCompiler.java
+++ b/src/edu/mit/streamjit/impl/distributed/DistributedStreamCompiler.java
@@ -21,11 +21,8 @@
*/
package edu.mit.streamjit.impl.distributed;
-import java.io.BufferedReader;
-import java.io.FileReader;
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -35,39 +32,36 @@
import com.google.common.collect.ImmutableMap;
import edu.mit.streamjit.api.CompiledStream;
-import edu.mit.streamjit.api.Filter;
import edu.mit.streamjit.api.Input;
import edu.mit.streamjit.api.Input.ManualInput;
import edu.mit.streamjit.api.OneToOneElement;
import edu.mit.streamjit.api.Output;
import edu.mit.streamjit.api.Pipeline;
-import edu.mit.streamjit.api.Portal;
import edu.mit.streamjit.api.Splitjoin;
-import edu.mit.streamjit.api.StreamCompilationFailedException;
import edu.mit.streamjit.api.StreamCompiler;
import edu.mit.streamjit.api.Worker;
import edu.mit.streamjit.impl.blob.Blob.Token;
import edu.mit.streamjit.impl.blob.BlobFactory;
import edu.mit.streamjit.impl.blob.Buffer;
-import edu.mit.streamjit.impl.common.AbstractDrainer;
import edu.mit.streamjit.impl.common.Configuration;
-import edu.mit.streamjit.impl.common.ConnectWorkersVisitor;
import edu.mit.streamjit.impl.common.InputBufferFactory;
-import edu.mit.streamjit.impl.common.MessageConstraint;
import edu.mit.streamjit.impl.common.OutputBufferFactory;
-import edu.mit.streamjit.impl.common.Portals;
-import edu.mit.streamjit.impl.common.VerifyStreamGraph;
+import edu.mit.streamjit.impl.common.TimeLogger;
import edu.mit.streamjit.impl.common.Workers;
+import edu.mit.streamjit.impl.common.drainer.AbstractDrainer;
import edu.mit.streamjit.impl.concurrent.ConcurrentStreamCompiler;
-import edu.mit.streamjit.impl.distributed.common.GlobalConstants;
+import edu.mit.streamjit.impl.distributed.HeadChannel.HeadBuffer;
+import edu.mit.streamjit.impl.distributed.common.Options;
import edu.mit.streamjit.impl.distributed.node.StreamNode;
import edu.mit.streamjit.impl.distributed.runtimer.CommunicationManager.CommunicationType;
import edu.mit.streamjit.impl.distributed.runtimer.Controller;
import edu.mit.streamjit.impl.distributed.runtimer.DistributedDrainer;
-import edu.mit.streamjit.impl.distributed.runtimer.OnlineTuner;
-import edu.mit.streamjit.impl.distributed.HeadChannel.HeadBuffer;
import edu.mit.streamjit.partitioner.HorizontalPartitioner;
import edu.mit.streamjit.partitioner.Partitioner;
+import edu.mit.streamjit.tuner.OnlineTuner;
+import edu.mit.streamjit.tuner.Reconfigurer;
+import edu.mit.streamjit.tuner.Verifier;
+import edu.mit.streamjit.util.ConfigurationUtils;
/**
*
@@ -89,106 +83,181 @@ public class DistributedStreamCompiler implements StreamCompiler {
/**
* Configuration from Opentuner.
*/
- Configuration cfg;
+ private Configuration cfg;
/**
* Total number of nodes including controller node.
*/
- int noOfnodes;
+ private int noOfnodes;
/**
- * @param noOfnodes
- * : Total number of nodes the stream application intended to run
- * - including controller node. If it is 1 then it means the
- * whole stream application is supposed to run on controller.
+ * Run the whole application on the controller node. No distributions. See
+ * {@link #DistributedStreamCompiler(int, Configuration)}
*/
- public DistributedStreamCompiler(int noOfnodes) {
- if (noOfnodes < 1)
- throw new IllegalArgumentException("noOfnodes must be 1 or greater");
- this.noOfnodes = noOfnodes;
+ public DistributedStreamCompiler() {
+ this(1, null);
}
/**
- * Run the whole application on the controller node.
+ * See {@link #DistributedStreamCompiler(int, Configuration)}. As no
+ * configuration is passed, tuner will activated to tune for better
+ * configuration.
*/
- public DistributedStreamCompiler() {
- this(1);
+ public DistributedStreamCompiler(int noOfnodes) {
+ this(noOfnodes, null);
}
/**
- * Run the application with the passed configureation.
+ * Run the application with the passed configuration. Pass null if the
+ * intention is to tune the application.
+ *
+ * @param noOfnodes
+ * : Total number of nodes the stream application intended to run
+ * including the controller node. If it is 1 then it means the
+ * whole stream application is supposed to run on controller.
+ * @param cfg
+ * Run the application with the passed {@link Configuration}. If
+ * it is null, tuner will be activated to tune for better
+ * configuration.
*/
public DistributedStreamCompiler(int noOfnodes, Configuration cfg) {
if (noOfnodes < 1)
throw new IllegalArgumentException("noOfnodes must be 1 or greater");
- this.noOfnodes = noOfnodes;
+ if (Options.singleNodeOnline) {
+ System.out
+ .println("Flag GlobalConstants.singleNodeOnline is enabled."
+ + " noOfNodes passed as compiler argument has no effect");
+ this.noOfnodes = 1;
+ } else
+ this.noOfnodes = noOfnodes;
+
this.cfg = cfg;
}
public CompiledStream compile(OneToOneElement stream,
Input input, Output output) {
+ StreamJitApp app = new StreamJitApp<>(stream);
+ Controller controller = establishController();
+
+ PartitionManager partitionManager = new HotSpotTuning(app);
+ ConfigurationManager cfgManager = new ConfigurationManager(app,
+ partitionManager);
+ ConnectionManager conManager = connectionManager(controller.controllerNodeID);
+
+ setConfiguration(controller, app, partitionManager, conManager,
+ cfgManager);
- checkforDefaultOneToOneElement(stream);
+ TimeLogger logger = new TimeLoggers.FileTimeLogger(app.name);
+ StreamJitAppManager manager = new StreamJitAppManager(controller, app,
+ conManager, logger);
+ final AbstractDrainer drainer = new DistributedDrainer(app, logger,
+ manager);
+ drainer.setBlobGraph(app.blobGraph);
- ConnectWorkersVisitor primitiveConnector = new ConnectWorkersVisitor();
- stream.visit(primitiveConnector);
- Worker source = (Worker) primitiveConnector.getSource();
- Worker sink = (Worker) primitiveConnector.getSink();
+ boolean needTermination = setBufferMap(input, output, drainer, app);
+
+ manager.reconfigure(1);
+ CompiledStream cs = new DistributedCompiledStream(drainer);
+
+ if (Options.tune > 0 && this.cfg != null) {
+ Reconfigurer configurer = new Reconfigurer(drainer, manager, app,
+ cfgManager, logger);
+ tuneOrVerify(configurer, needTermination);
+ }
+ return cs;
+ }
+
+ private ConnectionManager connectionManager(int controllerNodeID) {
+ switch (Options.connectionManager) {
+ case 0 :
+ return new ConnectionManager.AllConnectionParams(
+ controllerNodeID);
+ case 1 :
+ return new ConnectionManager.BlockingTCPNoParams(
+ controllerNodeID);
+ default :
+ return new ConnectionManager.AsyncTCPNoParams(controllerNodeID);
+ }
+ }
- VerifyStreamGraph verifier = new VerifyStreamGraph();
- stream.visit(verifier);
+ private Configuration cfgFromFile(StreamJitApp app,
+ Controller controller, Configuration defaultCfg) {
+ Configuration cfg1 = ConfigurationUtils.readConfiguration(app.name,
+ null);
+ if (cfg1 == null) {
+ controller.closeAll();
+ throw new IllegalConfigurationException();
+ } else if (!verifyCfg(defaultCfg, cfg1)) {
+ System.err
+ .println("Reading the configuration from configuration file");
+ System.err
+ .println("No matching between parameters in the read "
+ + "configuration and parameters in the default configuration");
+ controller.closeAll();
+ throw new IllegalConfigurationException();
+ }
+ return cfg1;
+ }
+ private Controller establishController() {
Map conTypeCount = new HashMap<>();
- // conTypeCount.put(CommunicationType.LOCAL, 1);
- conTypeCount.put(CommunicationType.TCP, this.noOfnodes);
+
+ if (this.noOfnodes == 1)
+ conTypeCount.put(CommunicationType.LOCAL, 1);
+ else
+ conTypeCount.put(CommunicationType.TCP, this.noOfnodes - 1);
Controller controller = new Controller();
controller.connect(conTypeCount);
+ return controller;
+ }
- StreamJitApp app = new StreamJitApp(stream, source, sink);
- ConfigurationManager cfgManager = new HotSpotTuning(app);
- BlobFactory bf = new DistributedBlobFactory(cfgManager, noOfnodes);
- this.cfg = bf.getDefaultConfiguration(Workers
- .getAllWorkersInGraph(source));
+ private Map>>> getMachineWorkerMap(
+ Integer[] machineIds, OneToOneElement stream,
+ Worker source, Worker sink) {
+ int totalCores = machineIds.length;
- if (GlobalConstants.tune) {
+ Partitioner horzPartitioner = new HorizontalPartitioner<>();
+ List>> partitionList = horzPartitioner
+ .partitionEqually(stream, source, sink, totalCores);
- } else {
- this.cfg = readConfiguration(stream.getClass().getSimpleName());
+ Map>>> partitionsMachineMap = new HashMap>>>();
+ for (Integer machineID : machineIds) {
+ partitionsMachineMap.put(machineID,
+ new ArrayList>>());
}
- if (cfg == null) {
- System.err
- .println("Configuration is null. Runs the app with horizontal partitioning.");
- Integer[] machineIds = new Integer[this.noOfnodes];
- for (int i = 0; i < machineIds.length; i++) {
- machineIds[i] = i + 1;
+ int index = 0;
+ while (index < partitionList.size()) {
+ for (Integer machineID : partitionsMachineMap.keySet()) {
+ if (!(index < partitionList.size()))
+ break;
+ partitionsMachineMap.get(machineID).add(
+ partitionList.get(index++));
}
- Map>>> partitionsMachineMap = getMachineWorkerMap(
- machineIds, stream, source, sink);
- app.newPartitionMap(partitionsMachineMap);
- } else
- cfgManager.newConfiguration(cfg);
-
- // TODO: Copied form DebugStreamCompiler. Need to be verified for this
- // context.
- List constraints = MessageConstraint
- .findConstraints(source);
- Set> portals = new HashSet<>();
- for (MessageConstraint mc : constraints)
- portals.add(mc.getPortal());
- for (Portal portal : portals)
- Portals.setConstraints(portal, constraints);
+ }
+ return partitionsMachineMap;
+ }
- StreamJitAppManager manager = new StreamJitAppManager(controller, app,
- cfgManager);
- final AbstractDrainer drainer = new DistributedDrainer(manager);
- drainer.setBlobGraph(app.blobGraph);
+ private void manualPartition(StreamJitApp app) {
+ Integer[] machineIds = new Integer[this.noOfnodes - 1];
+ for (int i = 0; i < machineIds.length; i++) {
+ machineIds[i] = i + 1;
+ }
+ Map>>> partitionsMachineMap = getMachineWorkerMap(
+ machineIds, app.streamGraph, app.source, app.sink);
+ app.newPartitionMap(partitionsMachineMap);
+ }
+ /**
+ * Sets head and tail buffers.
+ */
+ private boolean setBufferMap(Input input, Output output,
+ final AbstractDrainer drainer, StreamJitApp app) {
// TODO: derive a algorithm to find good buffer size and use here.
Buffer head = InputBufferFactory.unwrap(input).createReadableBuffer(
- 1000);
+ 10000);
Buffer tail = OutputBufferFactory.unwrap(output).createWritableBuffer(
- 1000);
+ 10000);
boolean needTermination;
@@ -201,7 +270,8 @@ public CompiledStream compile(OneToOneElement stream,
head) {
@Override
public void drain() {
- drainer.startDraining(2);
+ // drainer.startDraining(2);
+ drainer.drainFinal(false);
}
});
} else {
@@ -212,80 +282,55 @@ public void drain() {
ImmutableMap.Builder bufferMapBuilder = ImmutableMap
. builder();
- bufferMapBuilder.put(Token.createOverallInputToken(source), head);
- bufferMapBuilder.put(Token.createOverallOutputToken(sink), tail);
+ bufferMapBuilder.put(Token.createOverallInputToken(app.source), head);
+ bufferMapBuilder.put(Token.createOverallOutputToken(app.sink), tail);
app.bufferMap = bufferMapBuilder.build();
- app.constraints = constraints;
-
- manager.reconfigure();
- CompiledStream cs = new DistributedCompiledStream(drainer);
-
- if (GlobalConstants.tune && this.cfg != null) {
- OnlineTuner tuner = new OnlineTuner(drainer, manager, app,
- cfgManager, needTermination);
- new Thread(tuner, "OnlineTuner").start();
- }
- return cs;
- }
-
- private Configuration readConfiguration(String simpeName) {
- String name = String.format("%s.cfg", simpeName);
- try {
- BufferedReader reader = new BufferedReader(new FileReader(name));
- String json = reader.readLine();
- reader.close();
- return Configuration.fromJson(json);
- } catch (Exception ex) {
- System.err.println(String.format(
- "File reader error. No %s configuration file.", name));
- }
- return null;
+ return needTermination;
}
- private Map>>> getMachineWorkerMap(
- Integer[] machineIds, OneToOneElement stream,
- Worker source, Worker sink) {
- int totalCores = machineIds.length;
-
- Partitioner horzPartitioner = new HorizontalPartitioner<>();
- List>> partitionList = horzPartitioner
- .partitionEqually(stream, source, sink, totalCores);
+ private void setConfiguration(Controller controller,
+ StreamJitApp app, PartitionManager partitionManager,
+ ConnectionManager conManager, ConfigurationManager cfgManager) {
+ BlobFactory bf = new DistributedBlobFactory(partitionManager,
+ conManager, Math.max(noOfnodes - 1, 1));
+ Configuration defaultCfg = bf.getDefaultConfiguration(Workers
+ .getAllWorkersInGraph(app.source));
+
+ if (this.cfg != null) {
+ if (!verifyCfg(defaultCfg, this.cfg)) {
+ System.err
+ .println("No matching between parameters in the passed "
+ + "configuration and parameters in the default configuration");
+ controller.closeAll();
+ throw new IllegalConfigurationException();
+ }
+ } else if (Options.tune == 0) {
+ this.cfg = cfgFromFile(app, controller, defaultCfg);
+ } else
+ this.cfg = defaultCfg;
- Map>>> partitionsMachineMap = new HashMap>>>();
- for (Integer machineID : machineIds) {
- partitionsMachineMap.put(machineID,
- new ArrayList>>());
- }
+ cfgManager.newConfiguration(this.cfg);
+ }
- int index = 0;
- while (index < partitionList.size()) {
- for (Integer machineID : partitionsMachineMap.keySet()) {
- if (!(index < partitionList.size()))
- break;
- partitionsMachineMap.get(machineID).add(
- partitionList.get(index++));
- }
- }
- return partitionsMachineMap;
+ private boolean verifyCfg(Configuration defaultCfg, Configuration cfg) {
+ if (defaultCfg.getParametersMap().keySet()
+ .equals(cfg.getParametersMap().keySet()))
+ return true;
+ return false;
}
- /**
- * TODO: Need to check for other default subtypes of {@link OneToOneElement}
- * s. Now only checks for first generation children.
- *
- * @param stream
- * @throws StreamCompilationFailedException
- * if stream is default subtype of OneToOneElement
- */
- private void checkforDefaultOneToOneElement(
- OneToOneElement stream) {
-
- if (stream.getClass() == Pipeline.class
- || stream.getClass() == Splitjoin.class
- || stream.getClass() == Filter.class) {
- throw new StreamCompilationFailedException(
- "Default subtypes of OneToOneElement are not accepted for compilation by this compiler. OneToOneElement that passed should be unique");
+ private void tuneOrVerify(Reconfigurer configurer, boolean needTermination) {
+ Runnable r;
+ if (Options.tune == 1) {
+ r = new OnlineTuner(configurer, needTermination);
+ new Thread(r, "OnlineTuner").start();
+ } else if (Options.tune == 2) {
+ r = new Verifier(configurer);
+ new Thread(r, "Verifier").start();
+ } else {
+ throw new IllegalStateException(
+ "Neither OnlineTuner nor Verifer has been started.");
}
}
@@ -297,11 +342,6 @@ public DistributedCompiledStream(AbstractDrainer drainer) {
this.drainer = drainer;
}
- @Override
- public boolean isDrained() {
- return drainer.isDrained();
- }
-
@Override
public void awaitDrained() throws InterruptedException {
drainer.awaitDrained();
@@ -313,5 +353,25 @@ public void awaitDrained(long timeout, TimeUnit unit)
throws InterruptedException, TimeoutException {
drainer.awaitDrained(timeout, unit);
}
+
+ @Override
+ public boolean isDrained() {
+ return drainer.isDrained();
+ }
+ }
+
+ private class IllegalConfigurationException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ private static final String tag = "IllegalConfigurationException";
+
+ private IllegalConfigurationException() {
+ super(tag);
+ }
+
+ private IllegalConfigurationException(String msg) {
+ super(String.format("%s : %s", tag, msg));
+ }
}
}
\ No newline at end of file
diff --git a/src/edu/mit/streamjit/impl/distributed/HeadChannel.java b/src/edu/mit/streamjit/impl/distributed/HeadChannel.java
index b21665dc..4dd5a1b1 100644
--- a/src/edu/mit/streamjit/impl/distributed/HeadChannel.java
+++ b/src/edu/mit/streamjit/impl/distributed/HeadChannel.java
@@ -25,10 +25,11 @@
import edu.mit.streamjit.impl.blob.AbstractReadOnlyBuffer;
import edu.mit.streamjit.impl.blob.Buffer;
-import edu.mit.streamjit.impl.common.AbstractDrainer;
-import edu.mit.streamjit.impl.distributed.common.TCPConnection.TCPConnectionInfo;
-import edu.mit.streamjit.impl.distributed.common.TCPConnection.TCPConnectionProvider;
-import edu.mit.streamjit.impl.distributed.node.TCPOutputChannel;
+import edu.mit.streamjit.impl.common.drainer.AbstractDrainer;
+import edu.mit.streamjit.impl.distributed.common.Connection.ConnectionInfo;
+import edu.mit.streamjit.impl.distributed.common.Connection.ConnectionProvider;
+import edu.mit.streamjit.impl.distributed.node.AsyncOutputChannel;
+import edu.mit.streamjit.impl.distributed.node.BlockingOutputChannel;
/**
* Head Channel is just a wrapper to TCPOutputChannel that skips
@@ -37,15 +38,79 @@
* @author Sumanan sumanan@mit.edu
* @since Oct 21, 2013
*/
-public class HeadChannel extends TCPOutputChannel {
+public class HeadChannel {
- public HeadChannel(Buffer buffer, TCPConnectionProvider conProvider,
- TCPConnectionInfo conInfo, String bufferTokenName, int debugPrint) {
- super(buffer, conProvider, conInfo, bufferTokenName, debugPrint);
+ public static class TCPHeadChannel extends BlockingOutputChannel {
+
+ public TCPHeadChannel(Buffer buffer, ConnectionProvider conProvider,
+ ConnectionInfo conInfo, String bufferTokenName, int debugLevel) {
+ super(buffer, conProvider, conInfo, bufferTokenName, debugLevel);
+ }
+
+ protected void fillUnprocessedData() {
+ this.unProcessedData = ImmutableList.of();
+ }
}
- protected void fillUnprocessedData() {
- this.unProcessedData = ImmutableList.of();
+ public static class AsyncHeadChannel extends AsyncOutputChannel {
+
+ final Buffer readBuffer;
+ private volatile boolean stopCalled;
+ private volatile boolean isFinal;
+
+ public AsyncHeadChannel(Buffer buffer, ConnectionProvider conProvider,
+ ConnectionInfo conInfo, String bufferTokenName, int debugLevel) {
+ super(conProvider, conInfo, bufferTokenName, debugLevel);
+ readBuffer = buffer;
+ stopCalled = false;
+ }
+
+ @Override
+ public Runnable getRunnable() {
+ final Runnable supperRunnable = super.getRunnable();
+ return new Runnable() {
+ @Override
+ public void run() {
+ supperRunnable.run();
+ final Buffer writeBuffer = getBuffer();
+ final int dataLength = 10000;
+ final Object[] data = new Object[dataLength];
+ int read = 1;
+ int written = 0;
+ while (!stopCalled) {
+ read = readBuffer.read(data, 0, data.length);
+ written = 0;
+ while (written < read) {
+ written += writeBuffer.write(data, written, read
+ - written);
+ if (written == 0) {
+ try {
+ // TODO: Verify this sleep time.
+ Thread.sleep(500);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+ stopSuper(isFinal);
+ }
+ };
+ }
+
+ protected void fillUnprocessedData() {
+ throw new Error("Method not implemented");
+ }
+
+ @Override
+ public void stop(boolean isFinal) {
+ this.isFinal = isFinal;
+ this.stopCalled = true;
+ }
+
+ private void stopSuper(boolean isFinal) {
+ super.stop(isFinal);
+ }
}
/**
@@ -77,6 +142,25 @@ public Object read() {
return o;
}
+ @Override
+ public int read(Object[] data, int offset, int length) {
+ int read = buffer.read(data, offset, length);
+ if (read == 0) {
+ new DrainerThread().start();
+ }
+ return read;
+ }
+
+ @Override
+ public boolean readAll(Object[] data) {
+ return buffer.readAll(data);
+ }
+
+ @Override
+ public boolean readAll(Object[] data, int offset) {
+ return buffer.readAll(data, offset);
+ }
+
@Override
public int size() {
return buffer.size();
@@ -89,7 +173,8 @@ class DrainerThread extends Thread {
public void run() {
System.out.println("Input data finished");
- drainer.startDraining(2);
+ // drainer.startDraining(2);
+ drainer.drainFinal(false);
}
}
}
diff --git a/src/edu/mit/streamjit/impl/distributed/HotSpotTuning.java b/src/edu/mit/streamjit/impl/distributed/HotSpotTuning.java
index 5e82260d..67c4403e 100644
--- a/src/edu/mit/streamjit/impl/distributed/HotSpotTuning.java
+++ b/src/edu/mit/streamjit/impl/distributed/HotSpotTuning.java
@@ -21,6 +21,8 @@
*/
package edu.mit.streamjit.impl.distributed;
+import static com.google.common.base.Preconditions.checkArgument;
+
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
@@ -34,18 +36,16 @@
import edu.mit.streamjit.api.Pipeline;
import edu.mit.streamjit.api.Splitjoin;
import edu.mit.streamjit.api.Splitter;
-import edu.mit.streamjit.api.StreamCompilationFailedException;
import edu.mit.streamjit.api.StreamVisitor;
import edu.mit.streamjit.api.Worker;
import edu.mit.streamjit.impl.common.Configuration;
import edu.mit.streamjit.impl.common.Configuration.IntParameter;
+import edu.mit.streamjit.impl.common.Configuration.Parameter;
import edu.mit.streamjit.impl.common.Configuration.SwitchParameter;
import edu.mit.streamjit.impl.common.Workers;
-import edu.mit.streamjit.impl.common.Configuration.Parameter;
-import edu.mit.streamjit.impl.distributed.ConfigurationManager.AbstractConfigurationManager;
-import edu.mit.streamjit.tuner.OfflineTuner;
+import edu.mit.streamjit.impl.distributed.PartitionManager.AbstractPartitionManager;
-public final class HotSpotTuning extends AbstractConfigurationManager {
+public final class HotSpotTuning extends AbstractPartitionManager {
Map>> partitionGroup;
Map, Set>> skippedSplitters;
@@ -57,36 +57,14 @@ public HotSpotTuning(StreamJitApp app) {
@Override
public Configuration getDefaultConfiguration(Set> workers,
int noOfMachines) {
+ checkArgument(noOfMachines > 0, String.format(
+ "noOfMachines = %d, It must be > 0", noOfMachines));
PickHotSpots visitor = new PickHotSpots(noOfMachines);
app.streamGraph.visit(visitor);
return visitor.builder.build();
}
- @Override
- public boolean newConfiguration(Configuration config) {
-
- for (Parameter p : config.getParametersMap().values()) {
- if (p instanceof IntParameter) {
- IntParameter ip = (IntParameter) p;
- System.out.println(ip.getName() + " - " + ip.getValue());
- } else if (p instanceof SwitchParameter) {
- SwitchParameter sp = (SwitchParameter) p;
- System.out.println(sp.getName() + " - " + sp.getValue());
- } else
- System.out.println(p.getName() + " - Unknown type");
- }
-
- Map>>> partitionsMachineMap = getMachineWorkerMap(config);
- try {
- app.varifyConfiguration(partitionsMachineMap);
- } catch (StreamCompilationFailedException ex) {
- return false;
- }
- app.blobConfiguration = config;
- return true;
- }
-
- private Map>>> getMachineWorkerMap(
+ public Map>>> partitionMap(
Configuration config) {
Map>> partition = new HashMap<>();
@@ -186,11 +164,10 @@ private class PickHotSpots extends StreamVisitor {
private Joiner skipJoiner;
- private int minSplitjoinSize = 20;
+ private int minSplitjoinSize = 8;
/**
- * Workers those are going to be part {@link OfflineTuner}
- * {@link #currentHotSpot}.
+ * Workers those are going to be part of {@link #currentHotSpot}.
*/
List> workerGropups;
diff --git a/src/edu/mit/streamjit/impl/distributed/PartitionManager.java b/src/edu/mit/streamjit/impl/distributed/PartitionManager.java
new file mode 100644
index 00000000..235c1b91
--- /dev/null
+++ b/src/edu/mit/streamjit/impl/distributed/PartitionManager.java
@@ -0,0 +1,296 @@
+package edu.mit.streamjit.impl.distributed;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import edu.mit.streamjit.api.Filter;
+import edu.mit.streamjit.api.Joiner;
+import edu.mit.streamjit.api.Splitter;
+import edu.mit.streamjit.api.Worker;
+import edu.mit.streamjit.impl.common.Configuration;
+import edu.mit.streamjit.impl.common.Workers;
+import edu.mit.streamjit.partitioner.AbstractPartitioner;
+
+/**
+ * PartitionManager is responsible to partition a stream graph for a cluster.
+ * Partitioning process can be tuned. Implementations of this interface must
+ * provide the following two tasks.
+ *
+ * - Generate configuration with appropriate tuning parameters (Based on the
+ * search space design strategy) for tuning.
+ *
- Dispatch a new configuration given by the open tuner and generate
+ * partition machine map.
+ *
+ *
+ * @author Sumanan sumanan@mit.edu
+ * @since Jan 16, 2014
+ *
+ */
+public interface PartitionManager {
+
+ /**
+ * Generates default configuration with all tuning parameters for tuning.
+ *
+ * @param streamGraph
+ * @param source
+ * @param sink
+ * @param noOfMachines
+ * @return
+ */
+ public Configuration getDefaultConfiguration(Set> workers,
+ int noOfMachines);
+
+ /**
+ * Reads the configuration and returns a map of nodeID to list of set of
+ * workers (list of blob workers). Value of the returned map is list of
+ * worker set where each worker set is an individual blob.
+ *
+ * @param config
+ * @return map of nodeID to list of set of workers which are assigned to the
+ * node.
+ */
+ public Map>>> partitionMap(
+ Configuration config);
+
+ /**
+ * Implements the functions those can be called by runtimer to send
+ * configuration information to streamnodes.
+ *
+ * @author Sumanan sumanan@mit.edu
+ * @since Jan 17, 2014
+ */
+ public static abstract class AbstractPartitionManager implements
+ PartitionManager {
+
+ protected final StreamJitApp app;
+
+ AbstractPartitionManager(StreamJitApp app) {
+ this.app = app;
+ }
+
+ /**
+ * Copied form {@link AbstractPartitioner} class. But modified to
+ * support nested splitjoiners.
Returns all {@link Worker}s in a
+ * splitjoin.
+ *
+ * @param splitter
+ * @return Returns all {@link Filter}s in a splitjoin.
+ */
+ protected void getAllChildWorkers(Splitter splitter,
+ Set> childWorkers) {
+ childWorkers.add(splitter);
+ Joiner joiner = getJoiner(splitter);
+ Worker cur;
+ for (Worker childWorker : Workers.getSuccessors(splitter)) {
+ cur = childWorker;
+ while (cur != joiner) {
+ if (cur instanceof Filter)
+ childWorkers.add(cur);
+ else if (cur instanceof Splitter) {
+ getAllChildWorkers((Splitter) cur, childWorkers);
+ cur = getJoiner((Splitter) cur);
+ } else
+ throw new IllegalStateException(
+ "Some thing wrong in the algorithm.");
+
+ assert Workers.getSuccessors(cur).size() == 1 : "Illegal State encounted : cur can only be either a filter or a joner";
+ cur = Workers.getSuccessors(cur).get(0);
+ }
+ }
+ childWorkers.add(joiner);
+ }
+
+ /**
+ * Find and returns the corresponding {@link Joiner} for the passed
+ * {@link Splitter}.
+ *
+ * @param splitter
+ * : {@link Splitter} that needs it's {@link Joiner}.
+ * @return Corresponding {@link Joiner} of the passed {@link Splitter}.
+ */
+ protected Joiner getJoiner(Splitter splitter) {
+ Worker cur = Workers.getSuccessors(splitter).get(0);
+ int innerSplitjoinCount = 0;
+ while (!(cur instanceof Joiner) || innerSplitjoinCount != 0) {
+ if (cur instanceof Splitter)
+ innerSplitjoinCount++;
+ if (cur instanceof Joiner)
+ innerSplitjoinCount--;
+ assert innerSplitjoinCount >= 0 : "Joiner Count is more than splitter count. Check the algorithm";
+ cur = Workers.getSuccessors(cur).get(0);
+ }
+ assert cur instanceof Joiner : "Error in algorithm. Not returning a Joiner";
+ return (Joiner) cur;
+ }
+
+ protected String getParamName(Integer id) {
+ assert id > -1 : "Worker id cannot be negative";
+ return String.format("worker%dtomachine", id);
+ }
+
+ /**
+ * Goes through all workers in workerset which is passed as argument,
+ * find the workers which are interconnected and group them as a blob
+ * workers. i.e., Group the workers which are connected.
+ *
+ * TODO: If any dynamic edges exists then should create interpreter
+ * blob.
+ *
+ * @param workerset
+ * @return list of workers set which contains interconnected workers.
+ * Each worker set in the list is supposed to run in an
+ * individual blob.
+ */
+ protected List>> getConnectedComponents(
+ Set> workerset) {
+ List>> ret = new ArrayList>>();
+ while (!workerset.isEmpty()) {
+ Deque> queue = new ArrayDeque<>();
+ Set> blobworkers = new HashSet<>();
+ Worker w = workerset.iterator().next();
+ blobworkers.add(w);
+ workerset.remove(w);
+ queue.offer(w);
+ while (!queue.isEmpty()) {
+ Worker wrkr = queue.poll();
+ for (Worker succ : Workers.getSuccessors(wrkr)) {
+ if (workerset.contains(succ)) {
+ blobworkers.add(succ);
+ workerset.remove(succ);
+ queue.offer(succ);
+ }
+ }
+
+ for (Worker pred : Workers.getPredecessors(wrkr)) {
+ if (workerset.contains(pred)) {
+ blobworkers.add(pred);
+ workerset.remove(pred);
+ queue.offer(pred);
+ }
+ }
+ }
+ ret.add(blobworkers);
+ }
+ return ret;
+ }
+
+ /**
+ * Cycles can occur iff splitter and joiner happened to fall into a blob
+ * while some workers of that splitjoin falls into other blob. Here, we
+ * check for the above mention condition. If cycles exists, split then
+ * in to several blobs.
+ *
+ * @param blobworkers
+ * @return
+ */
+ protected List>> breakCycles(
+ Set> blobworkers) {
+ Map, Joiner> rfctrSplitJoin = new HashMap<>();
+ Set> splitterSet = getSplitters(blobworkers);
+ for (Splitter s : splitterSet) {
+ Joiner j = getJoiner(s);
+ if (blobworkers.contains(j)) {
+ Set> childWorkers = new HashSet<>();
+ getAllChildWorkers(s, childWorkers);
+ if (!blobworkers.containsAll(childWorkers)) {
+ rfctrSplitJoin.put(s, j);
+ }
+ }
+ }
+
+ List>> ret = new ArrayList<>();
+
+ for (Splitter s : rfctrSplitJoin.keySet()) {
+ if (blobworkers.contains(s)) {
+ ret.add(getSplitterReachables(s, blobworkers,
+ rfctrSplitJoin));
+ }
+ }
+ ret.addAll(getConnectedComponents(blobworkers));
+ return ret;
+ }
+
+ /**
+ * Goes through the passed set of workers, add workers those are
+ * reachable from the splitter s, but not any conflicting splitter or
+ * joiner.
+ *
+ * This function has side effect. Modifies the argument.
+ *
+ * @param s
+ * @param blobworkers
+ * @return
+ */
+ protected Set> getSplitterReachables(Splitter s,
+ Set> blobworkers,
+ Map, Joiner> rfctrSplitJoin) {
+ assert blobworkers.contains(s) : "Splitter s in not in blobworkers";
+ Set> ret = new HashSet<>();
+ Set> exclude = new HashSet<>();
+ Deque> queue = new ArrayDeque<>();
+ ret.add(s);
+ exclude.add(rfctrSplitJoin.get(s));
+ blobworkers.remove(s);
+ queue.offer(s);
+ while (!queue.isEmpty()) {
+ Worker wrkr = queue.poll();
+ for (Worker succ : Workers.getSuccessors(wrkr)) {
+ process(succ, blobworkers, rfctrSplitJoin, exclude, queue,
+ ret);
+ }
+
+ for (Worker pred : Workers.getPredecessors(wrkr)) {
+ process(pred, blobworkers, rfctrSplitJoin, exclude, queue,
+ ret);
+ }
+ }
+ return ret;
+ }
+
+ /**
+ * Since the code in this method repeated in two places in
+ * getSplitterReachables() method, It is re-factored into a private
+ * method to avoid code duplication.
+ */
+ protected void process(Worker wrkr,
+ Set> blobworkers,
+ Map, Joiner> rfctrSplitJoin,
+ Set> exclude, Deque> queue,
+ Set> ret) {
+ if (blobworkers.contains(wrkr) && !exclude.contains(wrkr)) {
+ ret.add(wrkr);
+ blobworkers.remove(wrkr);
+ queue.offer(wrkr);
+
+ for (Entry, Joiner> e : rfctrSplitJoin
+ .entrySet()) {
+ if (e.getValue().equals(wrkr)) {
+ exclude.add(e.getKey());
+ break;
+ } else if (e.getKey().equals(wrkr)) {
+ exclude.add(e.getValue());
+ break;
+ }
+ }
+ }
+ }
+
+ protected Set> getSplitters(Set> blobworkers) {
+ Set> splitterSet = new HashSet<>();
+ for (Worker w : blobworkers) {
+ if (w instanceof Splitter) {
+ splitterSet.add((Splitter) w);
+ }
+ }
+ return splitterSet;
+ }
+
+ }
+}
diff --git a/src/edu/mit/streamjit/impl/distributed/StreamJitApp.java b/src/edu/mit/streamjit/impl/distributed/StreamJitApp.java
index 389c8cd6..6d52abe3 100644
--- a/src/edu/mit/streamjit/impl/distributed/StreamJitApp.java
+++ b/src/edu/mit/streamjit/impl/distributed/StreamJitApp.java
@@ -22,26 +22,51 @@
package edu.mit.streamjit.impl.distributed;
import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
import com.google.common.collect.ImmutableMap;
+import edu.mit.streamjit.api.Filter;
import edu.mit.streamjit.api.OneToOneElement;
+import edu.mit.streamjit.api.Pipeline;
+import edu.mit.streamjit.api.Portal;
+import edu.mit.streamjit.api.Splitjoin;
import edu.mit.streamjit.api.StreamCompilationFailedException;
import edu.mit.streamjit.api.Worker;
+import edu.mit.streamjit.impl.blob.AbstractReadOnlyBuffer;
+import edu.mit.streamjit.impl.blob.Blob;
+import edu.mit.streamjit.impl.blob.Blob.Token;
import edu.mit.streamjit.impl.blob.BlobFactory;
import edu.mit.streamjit.impl.blob.Buffer;
import edu.mit.streamjit.impl.blob.DrainData;
-import edu.mit.streamjit.impl.blob.Blob.Token;
-import edu.mit.streamjit.impl.common.AbstractDrainer.BlobGraph;
import edu.mit.streamjit.impl.common.Configuration;
+import edu.mit.streamjit.impl.common.Configuration.IntParameter;
+import edu.mit.streamjit.impl.common.Configuration.PartitionParameter;
+import edu.mit.streamjit.impl.common.Configuration.SwitchParameter;
+import edu.mit.streamjit.impl.common.ConnectWorkersVisitor;
import edu.mit.streamjit.impl.common.MessageConstraint;
+import edu.mit.streamjit.impl.common.Portals;
+import edu.mit.streamjit.impl.common.VerifyStreamGraph;
import edu.mit.streamjit.impl.common.Workers;
+import edu.mit.streamjit.impl.common.drainer.BlobGraph;
+import edu.mit.streamjit.impl.compiler2.Compiler2BlobFactory;
+import edu.mit.streamjit.impl.concurrent.ConcurrentChannelFactory;
+import edu.mit.streamjit.impl.distributed.common.GlobalConstants;
+import edu.mit.streamjit.impl.distributed.common.Options;
+import edu.mit.streamjit.impl.distributed.common.Utils;
+import edu.mit.streamjit.impl.distributed.node.StreamNode;
import edu.mit.streamjit.impl.distributed.runtimer.Controller;
-import edu.mit.streamjit.impl.distributed.runtimer.OnlineTuner;
+import edu.mit.streamjit.impl.interp.ChannelFactory;
+import edu.mit.streamjit.impl.interp.Interpreter;
+import edu.mit.streamjit.tuner.OnlineTuner;
+import edu.mit.streamjit.util.Pair;
/**
* This class contains all information about the current streamJit application
@@ -57,22 +82,22 @@
* @author Sumanan sumanan@mit.edu
* @since Oct 8, 2013
*/
-public class StreamJitApp {
+public class StreamJitApp {
/**
* Since this is final, lets make public
*/
public final String topLevelClass;
- public final Worker source;
+ public final Worker source;
- public final Worker sink;
+ public final Worker sink;
public final String jarFilePath;
public final String name;
- final OneToOneElement streamGraph;
+ final OneToOneElement streamGraph;
public BlobGraph blobGraph;
@@ -80,10 +105,12 @@ public class StreamJitApp {
public ImmutableMap bufferMap;
- public List constraints;
+ public final List constraints;
public DrainData drainData = null;
+ public final Visualizer visualizer;
+
/**
* Keeps track of assigned machine Ids of each blob. This information is
* need for draining. TODO: If possible use a better solution.
@@ -91,21 +118,24 @@ public class StreamJitApp {
public Map blobtoMachineMap;
/**
- * blobConfiguration contains decision variables that are tuned by
- * opentuner. Specifically, a {@link Configuration} that is generated by a
- * {@link BlobFactory#getDefaultConfiguration(java.util.Set)}.
+ * The latest valid {@link Configuration} that is received from OpenTuner.
+ * {@link BlobFactory#getDefaultConfiguration(java.util.Set) generates the
+ * initial configuration}.
*/
- public Configuration blobConfiguration = null;
+ private Configuration configuration = null;
- public StreamJitApp(OneToOneElement streamGraph, Worker source,
- Worker sink) {
+ public StreamJitApp(OneToOneElement streamGraph) {
this.streamGraph = streamGraph;
+ Pair, Worker> srcSink = visit(streamGraph);
this.name = streamGraph.getClass().getSimpleName();
this.topLevelClass = streamGraph.getClass().getName();
- this.source = source;
- this.sink = sink;
+ this.source = srcSink.first;
+ this.sink = srcSink.second;
this.jarFilePath = this.getClass().getProtectionDomain()
.getCodeSource().getLocation().getPath();
+ this.constraints = getConstrains();
+ Utils.newApp(name);
+ visualizer = new Visualizer.DotVisualizer(streamGraph);
}
/**
@@ -123,7 +153,7 @@ public StreamJitApp(OneToOneElement streamGraph, Worker source,
public boolean newPartitionMap(
Map>>> partitionsMachineMap) {
try {
- varifyConfiguration(partitionsMachineMap);
+ verifyConfiguration(partitionsMachineMap);
} catch (StreamCompilationFailedException ex) {
return false;
}
@@ -143,18 +173,13 @@ public boolean newPartitionMap(
* @throws StreamCompilationFailedException
* if any cycles found among blobs.
*/
- public void varifyConfiguration(
+ public void verifyConfiguration(
Map>>> partitionsMachineMap) {
- for (int machine : partitionsMachineMap.keySet()) {
- System.err.print("\nMachine - " + machine);
- for (Set> blobworkers : partitionsMachineMap
- .get(machine)) {
- System.err.print("\n\tBlob worker set : ");
- for (Worker w : blobworkers) {
- System.err.print(Workers.getIdentifier(w) + " ");
- }
- }
+
+ if (!Options.singleNodeOnline) {
+ // printPartition(partitionsMachineMap);
}
+
List>> partitionList = new ArrayList<>();
for (List>> lst : partitionsMachineMap.values()) {
partitionList.addAll(lst);
@@ -164,24 +189,29 @@ public void varifyConfiguration(
try {
bg = new BlobGraph(partitionList);
} catch (StreamCompilationFailedException ex) {
- System.err.print("Cycles found in the worker->blob assignment");
- // for (int machine : partitionsMachineMap.keySet()) {
- // System.err.print("\nMachine - " + machine);
- // for (Set> blobworkers : partitionsMachineMap
- // .get(machine)) {
- // System.err.print("\n\tBlob worker set : ");
- // for (Worker w : blobworkers) {
- // System.err.print(Workers.getIdentifier(w) + " ");
- // }
- // }
- // }
- System.err.println();
+ System.err.println("Cycles found in the worker->blob assignment");
+ printPartition(partitionsMachineMap);
throw ex;
}
this.blobGraph = bg;
this.partitionsMachineMap = partitionsMachineMap;
}
+ private void printPartition(
+ Map>>> partitionsMachineMap) {
+ for (int machine : partitionsMachineMap.keySet()) {
+ System.err.print("\nMachine - " + machine);
+ for (Set> blobworkers : partitionsMachineMap
+ .get(machine)) {
+ System.err.print("\n\tBlob worker set : ");
+ for (Worker w : blobworkers) {
+ System.err.print(Workers.getIdentifier(w) + " ");
+ }
+ }
+ }
+ System.err.println();
+ }
+
/**
* From aggregated drain data, get subset of it which is relevant to a
* particular machine. Builds and returns machineID to DrainData map.
@@ -203,6 +233,64 @@ public ImmutableMap getDrainData() {
return builder.build();
}
+ /**
+ * Uses an {@link Interpreter} blob to clear or minimize a {@link DrainData}
+ * . This method can be called after a final draining to clear the data in
+ * the intermediate buffers.
+ *
+ * @param drainData
+ * : {@link DrainData} that is received after a draining.
+ * @return : A {@link DrainData} that remains after running an
+ * {@link Interpreter} blob.
+ */
+ public DrainData minimizeDrainData(DrainData drainData) {
+ Interpreter.InterpreterBlobFactory interpFactory = new Interpreter.InterpreterBlobFactory();
+ Blob interp = interpFactory.makeBlob(Workers
+ .getAllWorkersInGraph(source), interpFactory
+ .getDefaultConfiguration(Workers.getAllWorkersInGraph(source)),
+ 1, drainData);
+ interp.installBuffers(bufferMapWithEmptyHead());
+ Runnable interpCode = interp.getCoreCode(0);
+ final AtomicBoolean interpFinished = new AtomicBoolean();
+ interp.drain(new Runnable() {
+ @Override
+ public void run() {
+ interpFinished.set(true);
+ }
+ });
+ while (!interpFinished.get())
+ interpCode.run();
+ return interp.getDrainData();
+ }
+
+ /**
+ * Remove the original headbuffer and replace it with a new empty buffer.
+ */
+ private ImmutableMap bufferMapWithEmptyHead() {
+ ImmutableMap.Builder bufMapBuilder = ImmutableMap
+ .builder();
+ Buffer head = new AbstractReadOnlyBuffer() {
+ @Override
+ public int size() {
+ return 0;
+ }
+
+ @Override
+ public Object read() {
+ return null;
+ }
+ };
+
+ Token headToken = Token.createOverallInputToken(source);
+ for (Map.Entry en : bufferMap.entrySet()) {
+ if (en.getKey().equals(headToken))
+ bufMapBuilder.put(headToken, head);
+ else
+ bufMapBuilder.put(en);
+ }
+ return bufMapBuilder.build();
+ }
+
private Set getWorkerIds(List>> blobList) {
Set workerIds = new HashSet<>();
for (Set> blobworkers : blobList) {
@@ -212,4 +300,163 @@ private Set getWorkerIds(List>> blobList) {
}
return workerIds;
}
+
+ /**
+ * @return the configuration
+ */
+ public Configuration getConfiguration() {
+ return configuration;
+ }
+
+ /**
+ * @param configuration
+ * the configuration to set
+ */
+ public void setConfiguration(Configuration configuration) {
+ this.configuration = configuration;
+ visualizer.newConfiguration(configuration);
+ visualizer.newPartitionMachineMap(partitionsMachineMap);
+ }
+
+ private Pair, Worker> visit(OneToOneElement stream) {
+ checkforDefaultOneToOneElement(stream);
+ ConnectWorkersVisitor primitiveConnector = new ConnectWorkersVisitor();
+ stream.visit(primitiveConnector);
+ Worker source = (Worker) primitiveConnector.getSource();
+ Worker sink = (Worker) primitiveConnector.getSink();
+
+ VerifyStreamGraph verifier = new VerifyStreamGraph();
+ stream.visit(verifier);
+ return new Pair, Worker>(source, sink);
+ }
+
+ /**
+ * TODO: Need to check for other default subtypes of {@link OneToOneElement}
+ * s. Now only checks for first generation children.
+ *
+ * @param stream
+ * @throws StreamCompilationFailedException
+ * if stream is default subtype of OneToOneElement
+ */
+ private void checkforDefaultOneToOneElement(OneToOneElement stream) {
+ if (stream.getClass() == Pipeline.class
+ || stream.getClass() == Splitjoin.class
+ || stream.getClass() == Filter.class) {
+ throw new StreamCompilationFailedException(
+ "Default subtypes of OneToOneElement are not accepted for"
+ + " compilation by this compiler. OneToOneElement"
+ + " that passed should be unique");
+ }
+ }
+
+ private List getConstrains() {
+ // TODO: Copied form DebugStreamCompiler. Need to be verified for this
+ // context.
+ List constraints = MessageConstraint
+ .findConstraints(source);
+ Set> portals = new HashSet<>();
+ for (MessageConstraint mc : constraints)
+ portals.add(mc.getPortal());
+ for (Portal portal : portals)
+ Portals.setConstraints(portal, constraints);
+ return constraints;
+ }
+
+ /**
+ * Uses {@link StreamPathBuilder} to generate all paths in the streamGraph
+ * of this {@link StreamJitApp}. Check {@link StreamPathBuilder} for more
+ * information.
+ *
+ * @return Set of all paths in the streamGraph of this {@link StreamJitApp}.
+ */
+ public Set> paths() {
+ return StreamPathBuilder.paths(streamGraph);
+ }
+
+ /**
+ * Static information of the {@link StreamJitApp} that is essential for
+ * {@link StreamNode}s to set up. This configuration will be sent to
+ * {@link StreamNode}s when setting up a new app (Only once).
+ *
+ * @return static information of the app that is needed by steramnodes.
+ */
+ public Configuration getStaticConfiguration() {
+ Configuration.Builder builder = Configuration.builder();
+ builder.putExtraData(GlobalConstants.JARFILE_PATH, jarFilePath)
+ .putExtraData(GlobalConstants.TOPLEVEL_WORKER_NAME,
+ topLevelClass);
+ return builder.build();
+ }
+
+ /**
+ * For every reconfiguration, this method may be called by an appropriate
+ * class to get new configuration information that can be sent to all
+ * participating {@link StreamNode}s. Mainly this configuration contains
+ * partition information.
+ *
+ * @return new partition information
+ */
+ public Configuration getDynamicConfiguration() {
+ Configuration.Builder builder = Configuration.builder();
+
+ int maxCores = maxCores();
+
+ Map machineCoreMap = new HashMap<>();
+ for (Entry>>> machine : partitionsMachineMap
+ .entrySet()) {
+ machineCoreMap.put(machine.getKey(), machine.getValue().size()
+ * maxCores);
+ }
+
+ PartitionParameter.Builder partParam = PartitionParameter.builder(
+ GlobalConstants.PARTITION, machineCoreMap);
+
+ BlobFactory intFactory = new Interpreter.InterpreterBlobFactory();
+ BlobFactory comp2Factory = new Compiler2BlobFactory();
+ partParam.addBlobFactory(intFactory);
+ partParam.addBlobFactory(comp2Factory);
+ blobtoMachineMap = new HashMap<>();
+
+ BlobFactory bf = Options.useCompilerBlob ? comp2Factory
+ : intFactory;
+ for (Integer machineID : partitionsMachineMap.keySet()) {
+ List>> blobList = partitionsMachineMap
+ .get(machineID);
+ for (Set> blobWorkers : blobList) {
+ // TODO: One core per blob. Need to change this.
+ partParam.addBlob(machineID, maxCores, bf, blobWorkers);
+
+ // TODO: Temp fix to build.
+ Token t = Utils.getblobID(blobWorkers);
+ blobtoMachineMap.put(t, machineID);
+ }
+ }
+
+ builder.addParameter(partParam.build());
+ if (Options.useCompilerBlob)
+ builder.addSubconfiguration("blobConfigs", getConfiguration());
+ else
+ builder.addSubconfiguration("blobConfigs", getInterpreterConfg());
+ return builder.build();
+ }
+
+ private Configuration getInterpreterConfg() {
+ Configuration.Builder builder = Configuration.builder();
+ List universe = Arrays
+ . asList(new ConcurrentChannelFactory());
+ SwitchParameter cfParameter = new SwitchParameter(
+ "channelFactory", ChannelFactory.class, universe.get(0),
+ universe);
+
+ builder.addParameter(cfParameter);
+ return builder.build();
+ }
+
+ private int maxCores() {
+ IntParameter maxCoreParam = configuration.getParameter("maxNumCores",
+ IntParameter.class);
+ if (maxCoreParam != null)
+ return maxCoreParam.getValue();
+ return Options.maxNumCores;
+ }
}
diff --git a/src/edu/mit/streamjit/impl/distributed/StreamJitAppManager.java b/src/edu/mit/streamjit/impl/distributed/StreamJitAppManager.java
index 690b1ef3..d2ee2cbf 100644
--- a/src/edu/mit/streamjit/impl/distributed/StreamJitAppManager.java
+++ b/src/edu/mit/streamjit/impl/distributed/StreamJitAppManager.java
@@ -21,59 +21,75 @@
*/
package edu.mit.streamjit.impl.distributed;
-import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import com.google.common.base.Stopwatch;
import com.google.common.collect.ImmutableMap;
import edu.mit.streamjit.api.CompiledStream;
import edu.mit.streamjit.api.Worker;
+import edu.mit.streamjit.impl.blob.Blob.Token;
import edu.mit.streamjit.impl.blob.Buffer;
import edu.mit.streamjit.impl.blob.DrainData;
-import edu.mit.streamjit.impl.blob.Blob.Token;
-import edu.mit.streamjit.impl.common.AbstractDrainer;
import edu.mit.streamjit.impl.common.Configuration;
+import edu.mit.streamjit.impl.common.TimeLogger;
+import edu.mit.streamjit.impl.common.drainer.AbstractDrainer;
import edu.mit.streamjit.impl.distributed.common.AppStatus;
+import edu.mit.streamjit.impl.distributed.common.AppStatus.AppStatusProcessor;
+import edu.mit.streamjit.impl.distributed.common.AsyncTCPConnection.AsyncTCPConnectionInfo;
+import edu.mit.streamjit.impl.distributed.common.BoundaryChannel.BoundaryInputChannel;
+import edu.mit.streamjit.impl.distributed.common.BoundaryChannel.BoundaryOutputChannel;
import edu.mit.streamjit.impl.distributed.common.CTRLRDrainElement;
+import edu.mit.streamjit.impl.distributed.common.CTRLRDrainElement.DrainType;
import edu.mit.streamjit.impl.distributed.common.CTRLRMessageElement;
import edu.mit.streamjit.impl.distributed.common.Command;
import edu.mit.streamjit.impl.distributed.common.ConfigurationString;
-import edu.mit.streamjit.impl.distributed.common.GlobalConstants;
-import edu.mit.streamjit.impl.distributed.common.AppStatus.AppStatusProcessor;
-import edu.mit.streamjit.impl.distributed.common.BoundaryChannel.BoundaryInputChannel;
-import edu.mit.streamjit.impl.distributed.common.BoundaryChannel.BoundaryOutputChannel;
-import edu.mit.streamjit.impl.distributed.common.ConfigurationString.ConfigurationStringProcessor.ConfigType;
+import edu.mit.streamjit.impl.distributed.common.ConfigurationString.ConfigurationProcessor.ConfigType;
+import edu.mit.streamjit.impl.distributed.common.Connection.ConnectionInfo;
+import edu.mit.streamjit.impl.distributed.common.Connection.ConnectionProvider;
import edu.mit.streamjit.impl.distributed.common.Error.ErrorProcessor;
+import edu.mit.streamjit.impl.distributed.common.GlobalConstants;
import edu.mit.streamjit.impl.distributed.common.MiscCtrlElements.NewConInfo;
+import edu.mit.streamjit.impl.distributed.common.Options;
import edu.mit.streamjit.impl.distributed.common.SNDrainElement.Drained;
-import edu.mit.streamjit.impl.distributed.common.SNDrainElement.DrainedData;
import edu.mit.streamjit.impl.distributed.common.SNDrainElement.SNDrainProcessor;
+import edu.mit.streamjit.impl.distributed.common.SNDrainElement.SNDrainedData;
import edu.mit.streamjit.impl.distributed.common.SNException;
import edu.mit.streamjit.impl.distributed.common.SNException.AddressBindException;
import edu.mit.streamjit.impl.distributed.common.SNException.SNExceptionProcessor;
+import edu.mit.streamjit.impl.distributed.common.SNTimeInfo.SNTimeInfoProcessor;
+import edu.mit.streamjit.impl.distributed.common.SNTimeInfoProcessorImpl;
import edu.mit.streamjit.impl.distributed.common.TCPConnection.TCPConnectionInfo;
+import edu.mit.streamjit.impl.distributed.common.Utils;
+import edu.mit.streamjit.impl.distributed.profiler.MasterProfiler;
+import edu.mit.streamjit.impl.distributed.profiler.ProfilerCommand;
import edu.mit.streamjit.impl.distributed.runtimer.Controller;
+import edu.mit.streamjit.util.ConfigurationUtils;
public class StreamJitAppManager {
- private SNDrainProcessorImpl dp = null;
+ private final StreamJitApp app;
- private SNExceptionProcessorImpl exP = null;
+ private AppStatusProcessorImpl apStsPro = null;
- private ErrorProcessor ep = null;
+ private Map conInfoMap;
- private AppStatusProcessorImpl apStsPro = null;
+ private final ConnectionManager conManager;
private final Controller controller;
- private final StreamJitApp app;
+ private SNDrainProcessorImpl dp = null;
- private final ConfigurationManager cfgManager;
+ private ErrorProcessor ep = null;
- private boolean isRunning;
+ private SNExceptionProcessorImpl exP = null;
+
+ private final MasterProfiler profiler;
/**
* A {@link BoundaryOutputChannel} for the head of the stream graph. If the
@@ -83,6 +99,14 @@ public class StreamJitAppManager {
*/
private BoundaryOutputChannel headChannel;
+ private Thread headThread;
+
+ private final Token headToken;
+
+ private boolean isRunning;
+
+ private volatile AppStatus status;
+
/**
* A {@link BoundaryInputChannel} for the tail of the whole stream graph. If
* the sink {@link Worker} happened to fall outside the {@link Controller},
@@ -91,44 +115,149 @@ public class StreamJitAppManager {
*/
private TailChannel tailChannel;
- private Thread headThread;
-
private Thread tailThread;
- private volatile AppStatus status;
+ private final Token tailToken;
+
+ /**
+ * [2014-03-15] Just to measure the draining time
+ */
+ AtomicReference stopwatchRef = new AtomicReference<>();
- Map conInfoMap;
+ private final TimeLogger logger;
- public StreamJitAppManager(Controller controller, StreamJitApp app,
- ConfigurationManager cfgManager) {
+ private final SNTimeInfoProcessor timeInfoProcessor;
+
+ public StreamJitAppManager(Controller controller, StreamJitApp app,
+ ConnectionManager conManager, TimeLogger logger) {
this.controller = controller;
this.app = app;
- this.cfgManager = cfgManager;
+ this.conManager = conManager;
+ this.logger = logger;
+ this.timeInfoProcessor = new SNTimeInfoProcessorImpl(logger);
this.status = AppStatus.NOT_STARTED;
this.exP = new SNExceptionProcessorImpl();
this.ep = new ErrorProcessorImpl();
this.apStsPro = new AppStatusProcessorImpl(controller.getAllNodeIDs()
.size());
controller.registerManager(this);
- controller.newApp(cfgManager.getStaticConfiguration()); // TODO: Find a
- // good calling
- // place.
+ controller.newApp(app.getStaticConfiguration()); // TODO: Find a
+ // good calling
+ // place.
isRunning = false;
+
+ headToken = Token.createOverallInputToken(app.source);
+ tailToken = Token.createOverallOutputToken(app.sink);
+ profiler = setupProfiler();
}
- public boolean reconfigure() {
- reset();
- Configuration.Builder builder = Configuration.builder(cfgManager
- .getDynamicConfiguration());
+ public AppStatusProcessor appStatusProcessor() {
+ return apStsPro;
+ }
+
+ public void drain(Token blobID, DrainType drainType) {
+ // System.out.println("Drain requested to blob " + blobID);
+ if (!app.blobtoMachineMap.containsKey(blobID))
+ throw new IllegalArgumentException(blobID
+ + " not found in the blobtoMachineMap");
+ int nodeID = app.blobtoMachineMap.get(blobID);
+ controller.send(nodeID,
+ new CTRLRDrainElement.DoDrain(blobID, drainType));
+ }
+
+ public void drainingFinished(boolean isFinal) {
+ System.out.println("App Manager : Draining Finished...");
+
+ if (headChannel != null) {
+ try {
+ headThread.join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ if (tailChannel != null) {
+ if (Options.useDrainData)
+ if (isFinal)
+ tailChannel.stop(DrainType.FINAL);
+ else
+ tailChannel.stop(DrainType.INTERMEDIATE);
+ else
+ tailChannel.stop(DrainType.DISCARD);
+
+ try {
+ tailThread.join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ if (isFinal)
+ stop();
+
+ isRunning = false;
- Map> tokenMachineMap = new HashMap<>();
- Map portIdMap = new HashMap<>();
+ Stopwatch sw = stopwatchRef.get();
+ if (sw != null && sw.isRunning()) {
+ sw.stop();
+ long time = sw.elapsed(TimeUnit.MILLISECONDS);
+ System.out.println("Draining time is " + time + " milli seconds");
+ }
+ }
+
+ public void drainingStarted(boolean isFinal) {
+ stopwatchRef.set(Stopwatch.createStarted());
+ if (headChannel != null) {
+ headChannel.stop(isFinal);
+ // [2014-03-16] Moved to drainingFinished. In any case if headThread
+ // blocked at tcp write, draining will also blocked.
+ // try {
+ // headThread.join();
+ // } catch (InterruptedException e) {
+ // e.printStackTrace();
+ // }
+ }
+ }
- conInfoMap = controller.buildConInfoMap(app.partitionsMachineMap,
- app.source, app.sink);
+ public SNDrainProcessor drainProcessor() {
+ return dp;
+ }
- builder.putExtraData(GlobalConstants.TOKEN_MACHINE_MAP, tokenMachineMap)
- .putExtraData(GlobalConstants.PORTID_MAP, portIdMap);
+ public ErrorProcessor errorProcessor() {
+ return ep;
+ }
+
+ public SNExceptionProcessor exceptionProcessor() {
+ return exP;
+ }
+
+ public SNTimeInfoProcessor timeInfoProcessor() {
+ return timeInfoProcessor;
+ }
+
+ public long getFixedOutputTime(long timeout) throws InterruptedException {
+ long time = tailChannel.getFixedOutputTime(timeout);
+ if (apStsPro.error) {
+ return -1l;
+ }
+ return time;
+ }
+
+ public AppStatus getStatus() {
+ return status;
+ }
+
+ public boolean isRunning() {
+ return isRunning;
+ }
+
+ public boolean reconfigure(int multiplier) {
+ reset();
+ Configuration.Builder builder = Configuration.builder(app
+ .getDynamicConfiguration());
+
+ conInfoMap = conManager.conInfoMap(app.getConfiguration(),
+ app.partitionsMachineMap, app.source, app.sink);
builder.putExtraData(GlobalConstants.CONINFOMAP, conInfoMap);
@@ -137,17 +266,17 @@ public boolean reconfigure() {
ImmutableMap drainDataMap = app.getDrainData();
+ logger.compilationStarted();
for (int nodeID : controller.getAllNodeIDs()) {
ConfigurationString json = new ConfigurationString(jsonStirng,
ConfigType.DYNAMIC, drainDataMap.get(nodeID));
controller.send(nodeID, json);
}
- setupHeadTail(conInfoMap, app.bufferMap,
- Token.createOverallInputToken(app.source),
- Token.createOverallOutputToken(app.sink));
+ setupHeadTail(conInfoMap, app.bufferMap, multiplier);
boolean isCompiled = apStsPro.waitForCompilation();
+ logger.compilationFinished(isCompiled, "");
if (isCompiled) {
start();
@@ -156,22 +285,52 @@ public boolean reconfigure() {
isRunning = false;
}
+ if (profiler != null) {
+ String cfgPrefix = ConfigurationUtils.getConfigPrefix(app
+ .getConfiguration());
+ profiler.logger().newConfiguration(cfgPrefix);
+ }
+
+ System.out.println("StraemJit app is running...");
+ Utils.printMemoryStatus();
return isRunning;
}
+ public void setDrainer(AbstractDrainer drainer) {
+ assert dp == null : "SNDrainProcessor has already been set";
+ this.dp = new SNDrainProcessorImpl(drainer);
+ }
+
+ public void stop() {
+ this.status = AppStatus.STOPPED;
+ tailChannel.reset();
+ controller.closeAll();
+ dp.drainer.stop();
+ }
+
+ private void reset() {
+ exP.exConInfos = new HashSet<>();
+ apStsPro.reset();
+ }
+
+ private MasterProfiler setupProfiler() {
+ MasterProfiler p = null;
+ if (Options.needProfiler) {
+ p = new MasterProfiler(app.name);
+ controller.sendToAll(ProfilerCommand.START);
+ }
+ return p;
+ }
/**
* Setup the headchannel and tailchannel.
*
* @param cfg
* @param bufferMap
- * @param headToken
- * @param tailToken
*/
- private void setupHeadTail(Map conInfoMap,
- ImmutableMap bufferMap, Token headToken,
- Token tailToken) {
+ private void setupHeadTail(Map conInfoMap,
+ ImmutableMap bufferMap, int multiplier) {
- TCPConnectionInfo headconInfo = conInfoMap.get(headToken);
+ ConnectionInfo headconInfo = conInfoMap.get(headToken);
assert headconInfo != null : "No head connection info exists in conInfoMap";
assert headconInfo.getSrcID() == controller.controllerNodeID
|| headconInfo.getDstID() == controller.controllerNodeID : "Head channel should start from the controller. "
@@ -181,11 +340,18 @@ private void setupHeadTail(Map conInfoMap,
throw new IllegalArgumentException(
"No head buffer in the passed bufferMap.");
- headChannel = new HeadChannel(bufferMap.get(headToken),
- controller.getConProvider(), headconInfo, "headChannel - "
- + headToken.toString(), 0);
-
- TCPConnectionInfo tailconInfo = conInfoMap.get(tailToken);
+ if (headconInfo instanceof TCPConnectionInfo)
+ headChannel = new HeadChannel.TCPHeadChannel(
+ bufferMap.get(headToken), controller.getConProvider(),
+ headconInfo, "headChannel - " + headToken.toString(), 0);
+ else if (headconInfo instanceof AsyncTCPConnectionInfo)
+ headChannel = new HeadChannel.AsyncHeadChannel(
+ bufferMap.get(headToken), controller.getConProvider(),
+ headconInfo, "headChannel - " + headToken.toString(), 0);
+ else
+ throw new IllegalStateException("Head ConnectionInfo doesn't match");
+
+ ConnectionInfo tailconInfo = conInfoMap.get(tailToken);
assert tailconInfo != null : "No tail connection info exists in conInfoMap";
assert tailconInfo.getSrcID() == controller.controllerNodeID
|| tailconInfo.getDstID() == controller.controllerNodeID : "Tail channel should ends at the controller. "
@@ -195,9 +361,30 @@ private void setupHeadTail(Map conInfoMap,
throw new IllegalArgumentException(
"No tail buffer in the passed bufferMap.");
- tailChannel = new TailChannel(bufferMap.get(tailToken),
- controller.getConProvider(), tailconInfo, "tailChannel - "
- + tailToken.toString(), 0, 1000);
+ int skipCount = Math.max(Options.outputCount, multiplier * 5);
+ tailChannel = tailChannel(bufferMap.get(tailToken), tailconInfo,
+ skipCount);
+ }
+
+ private TailChannel tailChannel(Buffer buffer, ConnectionInfo conInfo,
+ int skipCount) {
+ String appName = app.name;
+ int steadyCount = Options.outputCount;
+ int debugLevel = 0;
+ String bufferTokenName = "tailChannel - " + tailToken.toString();
+ ConnectionProvider conProvider = controller.getConProvider();
+ String cfgPrefix = ConfigurationUtils.getConfigPrefix(app
+ .getConfiguration());
+ switch (Options.tailChannel) {
+ case 1 :
+ return new TailChannels.BlockingTailChannel1(buffer,
+ conProvider, conInfo, bufferTokenName, debugLevel,
+ skipCount, steadyCount, appName, cfgPrefix);
+ default :
+ return new TailChannels.BlockingTailChannel2(buffer,
+ conProvider, conInfo, bufferTokenName, debugLevel,
+ skipCount, steadyCount, appName, cfgPrefix);
+ }
}
/**
@@ -216,101 +403,109 @@ private void start() {
controller.sendToAll(Command.START);
if (tailChannel != null) {
- tailChannel.reset();
tailThread = new Thread(tailChannel.getRunnable(),
tailChannel.name());
tailThread.start();
}
}
- public boolean isRunning() {
- return isRunning;
+ public MasterProfiler getProfiler() {
+ return profiler;
}
- public void drainingStarted(boolean isFinal) {
- if (headChannel != null) {
- headChannel.stop(isFinal);
- try {
- headThread.join();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ /**
+ * {@link AppStatusProcessor} at {@link Controller} side.
+ *
+ * @author Sumanan sumanan@mit.edu
+ * @since Aug 11, 2013
+ */
+ private class AppStatusProcessorImpl implements AppStatusProcessor {
+
+ private boolean compilationError;
+
+ private CountDownLatch compileLatch;
+
+ private volatile boolean error;
+
+ private final int noOfnodes;
+
+ private AppStatusProcessorImpl(int noOfnodes) {
+ this.noOfnodes = noOfnodes;
}
- }
- public void drain(Token blobID, boolean isFinal) {
- // System.out.println("Drain requested to blob " + blobID);
- if (!app.blobtoMachineMap.containsKey(blobID))
- throw new IllegalArgumentException(blobID
- + " not found in the blobtoMachineMap");
- int nodeID = app.blobtoMachineMap.get(blobID);
- controller
- .send(nodeID, new CTRLRDrainElement.DoDrain(blobID, !isFinal));
- }
+ @Override
+ public void processCOMPILATION_ERROR() {
+ System.err.println("Compilation error");
+ this.compilationError = true;
+ compileLatch.countDown();
+ }
- public void drainingFinished(boolean isFinal) {
- System.out.println("App Manager : Draining Finished...");
- if (tailChannel != null) {
- if (isFinal)
- tailChannel.stop(1);
- else if (GlobalConstants.useDrainData)
- tailChannel.stop(2);
- else
- tailChannel.stop(3);
- try {
- tailThread.join();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ @Override
+ public void processCOMPILED() {
+ compileLatch.countDown();
}
- if (isFinal) {
- this.status = AppStatus.STOPPED;
+ @Override
+ public void processERROR() {
+ this.error = true;
+ // This will release the OpenTuner thread which is waiting for fixed
+ // output.
tailChannel.reset();
- controller.closeAll();
}
- isRunning = false;
- }
- public void awaitForFixInput() throws InterruptedException {
- tailChannel.awaitForFixInput();
- }
+ @Override
+ public void processNO_APP() {
+ }
- public void setDrainer(AbstractDrainer drainer) {
- assert dp == null : "SNDrainProcessor has already been set";
- this.dp = new SNDrainProcessorImpl(drainer);
- }
+ @Override
+ public void processNOT_STARTED() {
+ }
- public SNDrainProcessor drainProcessor() {
- return dp;
- }
+ @Override
+ public void processRUNNING() {
+ }
- public SNExceptionProcessor exceptionProcessor() {
- return exP;
- }
+ @Override
+ public void processSTOPPED() {
+ }
- public ErrorProcessor errorProcessor() {
- return ep;
- }
+ private void reset() {
+ compileLatch = new CountDownLatch(noOfnodes);
+ this.compilationError = false;
+ this.error = false;
+ }
- public AppStatusProcessor appStatusProcessor() {
- return apStsPro;
+ private boolean waitForCompilation() {
+ try {
+ compileLatch.await();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ return !this.compilationError;
+ }
}
- public AppStatus getStatus() {
- return status;
- }
+ /**
+ * {@link ErrorProcessor} at {@link Controller} side.
+ *
+ * @author Sumanan sumanan@mit.edu
+ * @since Aug 11, 2013
+ */
+ private class ErrorProcessorImpl implements ErrorProcessor {
- private void reset() {
- exP.exConInfos = new HashSet<>();
- apStsPro.reset();
- }
+ @Override
+ public void processFILE_NOT_FOUND() {
+ System.err
+ .println("No application jar file in streamNode. Terminating...");
+ stop();
+ }
- public void stop() {
- this.status = AppStatus.STOPPED;
- tailChannel.reset();
- controller.closeAll();
- dp.drainer.stop();
+ @Override
+ public void processWORKER_NOT_FOUND() {
+ System.err
+ .println("No top level class in the jar file. Terminating...");
+ stop();
+ }
}
/**
@@ -333,9 +528,9 @@ public void process(Drained drained) {
}
@Override
- public void process(DrainedData drainedData) {
- if (GlobalConstants.useDrainData)
- drainer.newDrainData(drainedData);
+ public void process(SNDrainedData snDrainedData) {
+ if (Options.useDrainData)
+ drainer.newSNDrainData(snDrainedData);
}
}
@@ -343,16 +538,12 @@ private class SNExceptionProcessorImpl implements SNExceptionProcessor {
private final Object abExLock = new Object();
- private Set exConInfos;
+ private Set exConInfos;
private SNExceptionProcessorImpl() {
exConInfos = new HashSet<>();
}
- @Override
- public void process(SNException ex) {
- }
-
@Override
public void process(AddressBindException abEx) {
synchronized (abExLock) {
@@ -363,7 +554,7 @@ public void process(AddressBindException abEx) {
}
Token t = null;
- for (Map.Entry entry : conInfoMap
+ for (Map.Entry entry : conInfoMap
.entrySet()) {
if (abEx.conInfo.equals(entry.getValue())) {
t = entry.getKey();
@@ -376,8 +567,8 @@ public void process(AddressBindException abEx) {
"Illegal TCP connection - " + abEx.conInfo);
}
- TCPConnectionInfo coninfo = controller
- .getNewTCPConInfo(abEx.conInfo);
+ ConnectionInfo coninfo = conManager
+ .replaceConInfo(abEx.conInfo);
exConInfos.add(abEx.conInfo);
@@ -386,93 +577,9 @@ public void process(AddressBindException abEx) {
controller.send(coninfo.getDstID(), msg);
}
}
- }
-
- /**
- * {@link ErrorProcessor} at {@link Controller} side.
- *
- * @author Sumanan sumanan@mit.edu
- * @since Aug 11, 2013
- */
- private class ErrorProcessorImpl implements ErrorProcessor {
-
- @Override
- public void processFILE_NOT_FOUND() {
- System.err
- .println("No application jar file in streamNode. Terminating...");
- stop();
- }
-
- @Override
- public void processWORKER_NOT_FOUND() {
- System.err
- .println("No top level class in the jar file. Terminating...");
- stop();
- }
- }
-
- /**
- * {@link AppStatusProcessor} at {@link Controller} side.
- *
- * @author Sumanan sumanan@mit.edu
- * @since Aug 11, 2013
- */
- private class AppStatusProcessorImpl implements AppStatusProcessor {
-
- private CountDownLatch compileLatch;
-
- private boolean compilationError;
-
- private final int noOfnodes;
-
- private AppStatusProcessorImpl(int noOfnodes) {
- this.noOfnodes = noOfnodes;
- }
@Override
- public void processRUNNING() {
- }
-
- @Override
- public void processSTOPPED() {
- }
-
- @Override
- public void processERROR() {
- }
-
- @Override
- public void processNOT_STARTED() {
- }
-
- @Override
- public void processNO_APP() {
- }
-
- @Override
- public void processCOMPILED() {
- compileLatch.countDown();
- }
-
- @Override
- public void processCOMPILATION_ERROR() {
- System.err.println("Compilation error");
- this.compilationError = true;
- compileLatch.countDown();
- }
-
- private void reset() {
- compileLatch = new CountDownLatch(noOfnodes);
- this.compilationError = false;
- }
-
- private boolean waitForCompilation() {
- try {
- compileLatch.await();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- return !this.compilationError;
+ public void process(SNException ex) {
}
}
}
diff --git a/src/edu/mit/streamjit/impl/distributed/StreamPathBuilder.java b/src/edu/mit/streamjit/impl/distributed/StreamPathBuilder.java
new file mode 100644
index 00000000..dbef4b31
--- /dev/null
+++ b/src/edu/mit/streamjit/impl/distributed/StreamPathBuilder.java
@@ -0,0 +1,170 @@
+package edu.mit.streamjit.impl.distributed;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import com.google.common.collect.ImmutableSet;
+
+import edu.mit.streamjit.api.Filter;
+import edu.mit.streamjit.api.Joiner;
+import edu.mit.streamjit.api.OneToOneElement;
+import edu.mit.streamjit.api.Pipeline;
+import edu.mit.streamjit.api.Splitjoin;
+import edu.mit.streamjit.api.Splitter;
+import edu.mit.streamjit.api.StreamVisitor;
+import edu.mit.streamjit.api.Worker;
+import edu.mit.streamjit.impl.common.ConnectWorkersVisitor;
+import edu.mit.streamjit.impl.common.Workers;
+import edu.mit.streamjit.test.apps.filterbank6.FilterBank6;
+
+/**
+ * Generate all stream paths in a stream graph.
+ *
+ * @author sumanan
+ * @since 13 Jan, 2015
+ */
+public class StreamPathBuilder {
+
+ /**
+ * streamGraph must be connected before requesting for paths. Use
+ * {@link ConnectWorkersVisitor} to connect the streamGraph.
+ *
+ * @param streamGraph
+ * @return Set of all paths in the streamGraph.
+ */
+ public static Set> paths(OneToOneElement streamGraph) {
+ PathVisitor v = new PathVisitor();
+ streamGraph.visit(v);
+ return v.currentUnfinishedPathSet;
+ }
+
+ private static class PathVisitor extends StreamVisitor {
+
+ /**
+ * Paths those are currently being built. These paths will get extended
+ * as StreamPathBuilder visits through the stream graph.
+ */
+ private Set> currentUnfinishedPathSet;
+
+ /**
+ * Keeps track of paths to all {@link Splitter} encountered in a stack.
+ * Once corresponding {@link Joiner} is visited, path set will be popped
+ * from this stack.
+ */
+ private Deque>> pathToSplitterStack;
+
+ /**
+ * Unfinished path sets which are waiting for a correct joiner. Path set
+ * will be popped from this stack once correct joiner is reached.
+ */
+ private Deque>> waitingForJoinerStack;
+
+ private PathVisitor() {
+ currentUnfinishedPathSet = new HashSet<>();
+ pathToSplitterStack = new ArrayDeque<>();
+ waitingForJoinerStack = new ArrayDeque<>();
+ }
+
+ @Override
+ public void beginVisit() {
+ currentUnfinishedPathSet.clear();
+ pathToSplitterStack.clear();
+ waitingForJoinerStack.clear();
+ currentUnfinishedPathSet.add(new LinkedList());
+ }
+
+ @Override
+ public void visitFilter(Filter filter) {
+ addToCurrentPath(filter);
+ }
+
+ @Override
+ public boolean enterPipeline(Pipeline pipeline) {
+ return true;
+ }
+
+ @Override
+ public void exitPipeline(Pipeline pipeline) {
+ }
+
+ @Override
+ public boolean enterSplitjoin(Splitjoin splitjoin) {
+ return true;
+ }
+
+ @Override
+ public void visitSplitter(Splitter splitter) {
+ addToCurrentPath(splitter);
+ pathToSplitterStack.push(currentUnfinishedPathSet);
+ waitingForJoinerStack.push(new HashSet>());
+ }
+
+ @Override
+ public boolean enterSplitjoinBranch(OneToOneElement element) {
+ currentUnfinishedPathSet = new HashSet>();
+ for (List splitterPath : pathToSplitterStack.peek()) {
+ currentUnfinishedPathSet.add(new LinkedList(
+ splitterPath));
+ }
+ return true;
+ }
+
+ @Override
+ public void exitSplitjoinBranch(OneToOneElement element) {
+ waitingForJoinerStack.peek().addAll(currentUnfinishedPathSet);
+ }
+
+ @Override
+ public void visitJoiner(Joiner joiner) {
+ currentUnfinishedPathSet = waitingForJoinerStack.pop();
+ addToCurrentPath(joiner);
+ pathToSplitterStack.pop();
+ }
+
+ @Override
+ public void exitSplitjoin(Splitjoin splitjoin) {
+ }
+
+ @Override
+ public void endVisit() {
+ if (!waitingForJoinerStack.isEmpty())
+ throw new IllegalStateException("waitingForJoiner not empty");
+ if (!pathToSplitterStack.isEmpty())
+ throw new IllegalStateException("pathToSplitter not empty");
+ // printPaths();
+ }
+
+ /**
+ * Extends all current unfinished path set with the {@link Worker} w.
+ *
+ * @param w
+ */
+ private void addToCurrentPath(Worker w) {
+ int id = Workers.getIdentifier(w);
+ for (List path : currentUnfinishedPathSet)
+ path.add(id);
+ }
+
+ /**
+ * Prints all paths in the stream graph.
+ */
+ private void printPaths() {
+ for (List path : currentUnfinishedPathSet) {
+ for (Integer i : path) {
+ System.out.print(i.toString() + "->");
+ }
+ System.out.println();
+ }
+ }
+ }
+
+ public static void main(String[] args) {
+ OneToOneElement stream = new FilterBank6.FilterBankPipeline();
+ new StreamJitApp<>(stream); // Connects the stream into stream graph.
+ StreamPathBuilder.paths(stream);
+ }
+}
\ No newline at end of file
diff --git a/src/edu/mit/streamjit/impl/distributed/TailChannel.java b/src/edu/mit/streamjit/impl/distributed/TailChannel.java
index 791e6a3e..dd077533 100644
--- a/src/edu/mit/streamjit/impl/distributed/TailChannel.java
+++ b/src/edu/mit/streamjit/impl/distributed/TailChannel.java
@@ -21,93 +21,67 @@
*/
package edu.mit.streamjit.impl.distributed;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
-import com.google.common.base.Stopwatch;
-
-import edu.mit.streamjit.impl.blob.Buffer;
-import edu.mit.streamjit.impl.distributed.common.GlobalConstants;
-import edu.mit.streamjit.impl.distributed.common.TCPConnection.TCPConnectionInfo;
-import edu.mit.streamjit.impl.distributed.common.TCPConnection.TCPConnectionProvider;
-import edu.mit.streamjit.impl.distributed.node.TCPInputChannel;
-
-public class TailChannel extends TCPInputChannel {
-
- int limit;
-
- int count;
-
- private volatile CountDownLatch latch;
-
- public TailChannel(Buffer buffer, TCPConnectionProvider conProvider,
- TCPConnectionInfo conInfo, String bufferTokenName, int debugPrint,
- int limit) {
- super(buffer, conProvider, conInfo, bufferTokenName, debugPrint);
- this.limit = limit;
- count = 0;
- latch = new CountDownLatch(1);
- if (!GlobalConstants.tune)
- new performanceLogger().start();
- }
-
- @Override
- public void receiveData() {
- super.receiveData();
- count++;
- // System.err.println(count);
- if (count > limit)
- latch.countDown();
- }
-
- public void awaitForFixInput() throws InterruptedException {
- latch.await();
- }
-
- public void reset() {
- latch.countDown();
- latch = new CountDownLatch(1);
- count = 0;
- }
-
- private class performanceLogger extends Thread {
-
- public void run() {
- int i = 0;
- FileWriter writer;
- try {
- writer = new FileWriter("FixedOutPut.txt");
- } catch (IOException e1) {
- e1.printStackTrace();
- return;
- }
- while (++i < 30) {
- try {
- Stopwatch stopwatch = Stopwatch.createStarted();
- latch.await();
- stopwatch.stop();
- Long time = stopwatch.elapsed(TimeUnit.MILLISECONDS);
-
- System.out.println("Execution time is " + time
- + " milli seconds");
-
- writer.write(time.toString());
- writer.write('\n');
-
- reset();
-
- } catch (InterruptedException | IOException e) {
- e.printStackTrace();
- }
- }
- try {
- writer.close();
- } catch (IOException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- }
- }
-}
\ No newline at end of file
+import edu.mit.streamjit.impl.distributed.common.BoundaryChannel.BoundaryInputChannel;
+
+/**
+ * This is a {@link BoundaryInputChannel} with counting facility.
+ * Implementations need to count the number of elements received and provide
+ * other services based on the count.
+ *
+ * @author sumanan
+ * @since 24 Jan, 2015
+ */
+public interface TailChannel extends BoundaryInputChannel {
+
+ /**
+ * @return Number of elements received after the last reset()
+ */
+ public int count();
+
+ /**
+ * Returns the time to receive fixed number of outputs. The fixed number can
+ * be hard coded in side an implementation or passed as a constructor
+ * argument.
+ *
+ * The caller will be blocked until the fixed number of outputs are
+ * received.
+ *
+ * @return the time(ms) to receive fixed number of outputs.
+ *
+ * @throws InterruptedException
+ */
+ public long getFixedOutputTime() throws InterruptedException;
+
+ /**
+ * Returns the time to receive fixed number of outputs. The fixed number can
+ * be hard coded in side an implementation or passed as a constructor
+ * argument. Waits at most timeout time to receive fixed number
+ * of output. Returns -1 if timeout occurred.
+ *
+ *
+ * If timeout < 1, then the behavior this method is equivalent to calling
+ * {@link #getFixedOutputTime()}.
+ *
+ *
+ *
+ * The caller will be blocked until the fixed number of output is received
+ * or timeout occurred, whatever happens early.
+ *
+ * @param timeout
+ * Wait at most timeout time to receive fixed number of output.
+ *
+ * @return the time(ms) to receive fixed number of outputs or -1 if timeout
+ * occurred.
+ *
+ * @throws InterruptedException
+ */
+ public long getFixedOutputTime(long timeout) throws InterruptedException;
+
+ /**
+ * Resets all counters and other resources. Any thread blocked on either
+ * {@link #getFixedOutputTime()} or {@link #getFixedOutputTime(long)} should
+ * be released after this call.
+ */
+ public void reset();
+
+}
diff --git a/src/edu/mit/streamjit/impl/distributed/TailChannels.java b/src/edu/mit/streamjit/impl/distributed/TailChannels.java
new file mode 100644
index 00000000..b4135d82
--- /dev/null
+++ b/src/edu/mit/streamjit/impl/distributed/TailChannels.java
@@ -0,0 +1,521 @@
+package edu.mit.streamjit.impl.distributed;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.lang.management.RuntimeMXBean;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import com.google.common.base.Stopwatch;
+
+import edu.mit.streamjit.impl.blob.Buffer;
+import edu.mit.streamjit.impl.distributed.common.CTRLRDrainElement.DrainType;
+import edu.mit.streamjit.impl.distributed.common.Connection.ConnectionInfo;
+import edu.mit.streamjit.impl.distributed.common.Connection.ConnectionProvider;
+import edu.mit.streamjit.impl.distributed.common.Options;
+import edu.mit.streamjit.impl.distributed.common.Utils;
+import edu.mit.streamjit.impl.distributed.node.BlockingInputChannel;
+
+public class TailChannels {
+
+ private static class PerformanceLogger extends Thread {
+
+ private AtomicBoolean stopFlag;
+
+ private final String appName;
+
+ private final TailChannel tailChannel;
+
+ private PerformanceLogger(TailChannel tailChannel, String appName) {
+ super("PerformanceLogger");
+ stopFlag = new AtomicBoolean(false);
+ this.appName = appName;
+ this.tailChannel = tailChannel;
+ }
+
+ public void run() {
+ int i = 0;
+ FileWriter writer;
+ try {
+ writer = new FileWriter(String.format("%s%sFixedOutPut.txt",
+ appName, File.separator));
+ } catch (IOException e1) {
+ e1.printStackTrace();
+ return;
+ }
+
+ writeInitialInfo(writer);
+
+ Long sum = 0l;
+
+ while (++i < 10 && !stopFlag.get()) {
+ try {
+ Long time = tailChannel.getFixedOutputTime();
+
+ sum += time;
+ System.out.println("Execution time is " + time
+ + " milli seconds");
+
+ writer.write(time.toString());
+ writer.write('\n');
+ writer.flush();
+ } catch (InterruptedException | IOException e) {
+ e.printStackTrace();
+ }
+ }
+ try {
+ writer.write("Average = " + sum / (i - 1));
+ writer.write('\n');
+ writer.flush();
+ writer.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ System.out.println("PerformanceLogger exits. App will run till "
+ + "inputdata exhausted.");
+ }
+
+ private void writeInitialInfo(FileWriter writer) {
+ System.out.println(String.format(
+ "PerformanceLogger starts to log the time to"
+ + " produce %d number of outputs",
+ Options.outputCount));
+
+ try {
+ writer.write(String.format("GlobalConstants.outputCount = %d",
+ Options.outputCount));
+ writer.write('\n');
+ writer.flush();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public void stopLogging() {
+ stopFlag.set(true);
+ }
+ }
+
+ /**
+ * Periodically prints the number of outputs received by a
+ * {@link TailChannel}.
+ */
+ private static class OutputCountPrinter {
+
+ private final String appName;
+
+ private final TailChannel tailChannel;
+
+ /**
+ * The no of outputs received at the end of last period.
+ */
+ private int lastCount;
+
+ private FileWriter writer;
+
+ private RuntimeMXBean rb = ManagementFactory.getRuntimeMXBean();
+
+ private ScheduledExecutorService scheduledExecutorService;
+
+ OutputCountPrinter(TailChannel tailChannel, String appName) {
+ this.tailChannel = tailChannel;
+ this.appName = appName;
+ printOutputCount();
+ }
+
+ private void printOutputCount() {
+ if (Options.printOutputCountPeriod < 1)
+ return;
+ writer = Utils.fileWriter(appName, "outputCount.txt", true);
+ lastCount = 0;
+ scheduledExecutorService = Executors
+ .newSingleThreadScheduledExecutor();
+ scheduledExecutorService.scheduleAtFixedRate(
+ new Runnable() {
+ @Override
+ public void run() {
+ int currentCount = tailChannel.count();
+ int newOutputs = currentCount - lastCount;
+ lastCount = currentCount;
+ String msg = String.format("%d\t\t%d\t\t%d\n",
+ rb.getUptime(), currentCount, newOutputs);
+ try {
+ writer.write(msg);
+ writer.flush();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }, Options.printOutputCountPeriod,
+ Options.printOutputCountPeriod,
+ TimeUnit.MILLISECONDS);
+ }
+
+ private void stop() {
+ if (scheduledExecutorService != null)
+ scheduledExecutorService.shutdown();
+ if (writer != null)
+ try {
+ writer.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * This method writes to the file in a non thread safe way. But this is
+ * enough to serve the purpose.
+ *
+ * TODO: This method is just for debugging purpose, Remove this method
+ * and its usage later.
+ */
+ private boolean write(String msg) {
+ if (writer != null)
+ try {
+ writer.write(msg);
+ return true;
+ } catch (Exception e) {
+ }
+ return false;
+ }
+ }
+
+ private static abstract class AbstractBlockingTailChannel
+ extends
+ BlockingInputChannel implements TailChannel {
+
+ protected final int skipCount;
+
+ protected final int totalCount;
+
+ protected int count;
+
+ private PerformanceLogger pLogger = null;
+
+ private OutputCountPrinter outputCountPrinter = null;
+
+ private final String cfgPrefix;
+
+ protected abstract void releaseAndInitilize();
+
+ /**
+ * @param buffer
+ * @param conProvider
+ * @param conInfo
+ * @param bufferTokenName
+ * @param debugLevel
+ * @param skipCount
+ * : Skips this amount of output before evaluating the
+ * running time. This is added to avoid the noise from init
+ * schedule and the drain data. ( i.e., In order to get real
+ * steady state execution time)
+ * @param steadyCount
+ * : {@link #getFixedOutputTime()} calculates the time taken
+ * to get this amount of outputs ( after skipping skipCount
+ * number of outputs at the beginning).
+ */
+ public AbstractBlockingTailChannel(Buffer buffer,
+ ConnectionProvider conProvider, ConnectionInfo conInfo,
+ String bufferTokenName, int debugLevel, int skipCount,
+ int steadyCount, String appName, String cfgPrefix) {
+ super(buffer, conProvider, conInfo, bufferTokenName, debugLevel);
+ this.skipCount = skipCount;
+ this.totalCount = steadyCount + skipCount;
+ count = 0;
+ this.cfgPrefix = cfgPrefix;
+ if (Options.tune == 0) {
+ // TODO: Leaks this object from the constructor. May cause
+ // subtle bugs. Re-factor it.
+ pLogger = new PerformanceLogger(this, appName);
+ pLogger.start();
+ }
+ if (Options.printOutputCountPeriod > 0)
+ outputCountPrinter = new OutputCountPrinter(this, appName);
+ }
+
+ @Override
+ public void stop(DrainType type) {
+ super.stop(type);
+ if (pLogger != null) {
+ releaseAndInitilize();
+ pLogger.stopLogging();
+ }
+ if (outputCountPrinter != null)
+ outputCountPrinter.stop();
+ }
+
+ @Override
+ public int count() {
+ return count;
+ }
+
+ protected long normalizedTime(long time) {
+ return (Options.outputCount * time) / (totalCount - skipCount);
+ }
+
+ /**
+ * Opposite to the {@link #normalizedTime(long)}'s equation.
+ * time=unnormalizedTime(normalizedTime(time))
+ */
+ protected long unnormalizedTime(long time) {
+ return (time * (totalCount - skipCount)) / Options.outputCount;
+ }
+
+ /**
+ * Logs the time reporting event.
+ *
+ * TODO: This method is just for debugging purpose, Remove this method
+ * and its usage later.
+ */
+ protected void reportingTime(long time) {
+ if (outputCountPrinter != null) {
+ String msg = String.format(
+ "Reporting-%s.cfg,time=%d,TotalCount=%d\n", cfgPrefix,
+ time, count);
+ outputCountPrinter.write(msg);
+ }
+ }
+ }
+
+ public static final class BlockingTailChannel1
+ extends
+ AbstractBlockingTailChannel {
+
+ private volatile CountDownLatch steadyLatch;
+
+ private volatile CountDownLatch skipLatch;
+
+ private boolean skipLatchUp;
+
+ private boolean steadyLatchUp;
+
+ /**
+ * @param buffer
+ * @param conProvider
+ * @param conInfo
+ * @param bufferTokenName
+ * @param debugLevel
+ * For all above 5 parameters, see
+ * {@link BlockingInputChannel#BlockingInputChannel(Buffer, ConnectionProvider, ConnectionInfo, String, int)}
+ * @param skipCount
+ * : Skips this amount of output before evaluating the
+ * running time. This is added to avoid the noise from init
+ * schedule and the drain data. ( i.e., In order to get real
+ * steady state execution time)
+ * @param steadyCount
+ * : {@link #getFixedOutputTime()} calculates the time taken
+ * to get this amount of outputs ( after skipping skipCount
+ * number of outputs at the beginning).
+ */
+ public BlockingTailChannel1(Buffer buffer,
+ ConnectionProvider conProvider, ConnectionInfo conInfo,
+ String bufferTokenName, int debugLevel, int skipCount,
+ int steadyCount, String appName, String cfgPrefix) {
+ super(buffer, conProvider, conInfo, bufferTokenName, debugLevel,
+ skipCount, steadyCount, appName, cfgPrefix);
+ steadyLatch = new CountDownLatch(1);
+ skipLatch = new CountDownLatch(1);
+ this.skipLatchUp = true;
+ this.steadyLatchUp = true;
+ }
+
+ @Override
+ public void receiveData() {
+ super.receiveData();
+ count++;
+
+ if (skipLatchUp && count > skipCount) {
+ skipLatch.countDown();
+ skipLatchUp = false;
+ }
+
+ if (steadyLatchUp && count > totalCount) {
+ steadyLatch.countDown();
+ steadyLatchUp = false;
+ }
+ }
+
+ /**
+ * Skips skipCount amount of output at the beginning and then calculates
+ * the time taken to get steadyCount amount of outputs. skipCount is
+ * added to avoid the noise from init schedule and the drain data. (
+ * i.e., In order to get real steady state execution time).
+ *
+ * @return time in MILLISECONDS.
+ * @throws InterruptedException
+ */
+ public long getFixedOutputTime() throws InterruptedException {
+ releaseAndInitilize();
+ skipLatch.await();
+ Stopwatch stopwatch = Stopwatch.createStarted();
+ steadyLatch.await();
+ stopwatch.stop();
+ long time = stopwatch.elapsed(TimeUnit.MILLISECONDS);
+ reportingTime(time);
+ return normalizedTime(time);
+ }
+
+ @Override
+ public long getFixedOutputTime(long timeout)
+ throws InterruptedException {
+ if (timeout < 1)
+ return getFixedOutputTime();
+
+ timeout = unnormalizedTime(timeout);
+ releaseAndInitilize();
+ skipLatch.await();
+ Stopwatch stopwatch = Stopwatch.createStarted();
+ while (steadyLatch.getCount() > 0
+ && stopwatch.elapsed(TimeUnit.MILLISECONDS) < timeout) {
+ Thread.sleep(100);
+ }
+
+ stopwatch.stop();
+ long time = stopwatch.elapsed(TimeUnit.MILLISECONDS);
+ reportingTime(time);
+ if (time > timeout)
+ return -1;
+ return normalizedTime(time);
+ }
+
+ /**
+ * Releases all latches, and re-initializes the latches and counters.
+ */
+ protected void releaseAndInitilize() {
+ count = 0;
+ skipLatch.countDown();
+ skipLatch = new CountDownLatch(1);
+ skipLatchUp = true;
+ steadyLatch.countDown();
+ steadyLatch = new CountDownLatch(1);
+ steadyLatchUp = true;
+ }
+
+ public void reset() {
+ steadyLatch.countDown();
+ skipLatch.countDown();
+ count = 0;
+ }
+ }
+
+ public static final class BlockingTailChannel2
+ extends
+ AbstractBlockingTailChannel {
+
+ private volatile CountDownLatch skipLatch;
+
+ private boolean skipLatchUp;
+
+ private final Stopwatch stopWatch;
+
+ /**
+ * @param buffer
+ * @param conProvider
+ * @param conInfo
+ * @param bufferTokenName
+ * @param debugLevel
+ * For all above 5 parameters, see
+ * {@link BlockingInputChannel#BlockingInputChannel(Buffer, ConnectionProvider, ConnectionInfo, String, int)}
+ * @param skipCount
+ * : Skips this amount of output before evaluating the
+ * running time. This is added to avoid the noise from init
+ * schedule and the drain data. ( i.e., In order to get real
+ * steady state execution time)
+ * @param steadyCount
+ * : {@link #getFixedOutputTime()} calculates the time taken
+ * to get this amount of outputs ( after skipping skipCount
+ * number of outputs at the beginning).
+ */
+ public BlockingTailChannel2(Buffer buffer,
+ ConnectionProvider conProvider, ConnectionInfo conInfo,
+ String bufferTokenName, int debugLevel, int skipCount,
+ int steadyCount, String appName, String cfgPrefix) {
+ super(buffer, conProvider, conInfo, bufferTokenName, debugLevel,
+ skipCount, steadyCount, appName, cfgPrefix);
+ stopWatch = Stopwatch.createUnstarted();
+ skipLatch = new CountDownLatch(1);
+ this.skipLatchUp = true;
+ }
+
+ @Override
+ public void receiveData() {
+ super.receiveData();
+ count++;
+
+ if (skipLatchUp && count > skipCount) {
+ skipLatch.countDown();
+ skipLatchUp = false;
+ }
+
+ if (stopWatch.isRunning() && count > totalCount) {
+ stopWatch.stop();
+ }
+ }
+
+ /**
+ * Skips skipCount amount of output at the beginning and then calculates
+ * the time taken to get steadyCount amount of outputs. skipCount is
+ * added to avoid the noise from init schedule and the drain data. (
+ * i.e., In order to get real steady state execution time).
+ *
+ * @return time in MILLISECONDS.
+ * @throws InterruptedException
+ */
+ public long getFixedOutputTime() throws InterruptedException {
+ releaseAndInitilize();
+ skipLatch.await();
+ stopWatch.start();
+ while (stopWatch.isRunning())
+ Thread.sleep(250);
+ long time = stopWatch.elapsed(TimeUnit.MILLISECONDS);
+ reportingTime(time);
+ return normalizedTime(time);
+ }
+
+ @Override
+ public long getFixedOutputTime(long timeout)
+ throws InterruptedException {
+ if (timeout < 1)
+ return getFixedOutputTime();
+
+ timeout = unnormalizedTime(timeout);
+ releaseAndInitilize();
+ skipLatch.await();
+ stopWatch.start();
+ while (stopWatch.isRunning()
+ && stopWatch.elapsed(TimeUnit.MILLISECONDS) < timeout) {
+ Thread.sleep(250);
+ }
+
+ long time = stopWatch.elapsed(TimeUnit.MILLISECONDS);
+ reportingTime(time);
+ if (time > timeout)
+ return -1;
+ else
+ return normalizedTime(time);
+ }
+
+ /**
+ * Releases all latches, and re-initializes the latches and counters.
+ */
+ protected void releaseAndInitilize() {
+ count = 0;
+ skipLatch.countDown();
+ skipLatch = new CountDownLatch(1);
+ skipLatchUp = true;
+ stopWatch.reset();
+ }
+
+ public void reset() {
+ stopWatch.reset();
+ skipLatch.countDown();
+ count = 0;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/edu/mit/streamjit/impl/distributed/TimeLoggers.java b/src/edu/mit/streamjit/impl/distributed/TimeLoggers.java
new file mode 100644
index 00000000..593a91e4
--- /dev/null
+++ b/src/edu/mit/streamjit/impl/distributed/TimeLoggers.java
@@ -0,0 +1,297 @@
+package edu.mit.streamjit.impl.distributed;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.util.concurrent.TimeUnit;
+
+import com.google.common.base.Stopwatch;
+
+import edu.mit.streamjit.impl.common.TimeLogger;
+import edu.mit.streamjit.impl.distributed.common.Utils;
+
+/**
+ * Collection of various {@link TimeLogger} implementations.
+ *
+ * @author Sumanan sumanan@mit.edu
+ * @since Nov 24, 2014
+ *
+ */
+public class TimeLoggers {
+
+ /**
+ * Creates three files named compileTime.txt, runTime.txt and drainTime.txt
+ * inside app.name directory, and logs the time information.
+ *
+ * @author sumanan
+ * @since Nov 25, 2014
+ */
+ public static class FileTimeLogger extends TimeLoggerImpl {
+
+ public FileTimeLogger(String appName) {
+ super(Utils.fileWriter(appName, "compileTime.txt"), Utils
+ .fileWriter(appName, "runTime.txt"), Utils.fileWriter(
+ appName, "drainTime.txt"), Utils.fileWriter(appName,
+ "searchTime.txt"));
+ }
+ }
+
+ /**
+ * Logs nothing.
+ */
+ public static class NoTimeLogger implements TimeLogger {
+
+ @Override
+ public void compilationFinished(boolean isCompiled, String msg) {
+ }
+
+ @Override
+ public void compilationStarted() {
+
+ }
+
+ @Override
+ public void drainingFinished(String msg) {
+ }
+
+ @Override
+ public void drainingStarted() {
+ }
+
+ @Override
+ public void logCompileTime(long time) {
+ }
+
+ @Override
+ public void logCompileTime(String msg) {
+ }
+
+ @Override
+ public void logDrainDataCollectionTime(long time) {
+ }
+
+ @Override
+ public void logDrainTime(long time) {
+ }
+
+ @Override
+ public void logDrainTime(String msg) {
+ }
+
+ @Override
+ public void logRunTime(long time) {
+ }
+
+ @Override
+ public void logRunTime(String msg) {
+ }
+
+ @Override
+ public void newConfiguration(String cfgPrefix) {
+ }
+
+ @Override
+ public void drainDataCollectionStarted() {
+ }
+
+ @Override
+ public void drainDataCollectionFinished(String msg) {
+ }
+
+ @Override
+ public void logSearchTime(long time) {
+ }
+ }
+
+ /**
+ * Prints the values to the StdOut.
+ *
+ */
+ public static class PrintTimeLogger extends TimeLoggerImpl {
+
+ public PrintTimeLogger() {
+ super(System.out, System.out, System.out, System.out);
+ }
+ }
+
+ private static class TimeLoggerImpl implements TimeLogger {
+
+ private final OutputStreamWriter compileTimeWriter;
+
+ private final OutputStreamWriter drainTimeWriter;
+
+ private final OutputStreamWriter runTimeWriter;
+
+ private final OutputStreamWriter searchTimeWriter;
+
+ private int reconfigNo = 0;
+
+ private Stopwatch compileTimeSW = null;
+
+ private Stopwatch drainTimeSW = null;
+
+ private Stopwatch drainDataCollectionTimeSW = null;
+
+ private Stopwatch tuningRoundSW = null;
+
+ TimeLoggerImpl(OutputStream compileOS, OutputStream runOs,
+ OutputStream drainOs, OutputStream searchOs) {
+ this(getOSWriter(compileOS), getOSWriter(runOs),
+ getOSWriter(drainOs), getOSWriter(searchOs));
+ }
+
+ TimeLoggerImpl(OutputStreamWriter compileW, OutputStreamWriter runW,
+ OutputStreamWriter drainW, OutputStreamWriter searchW) {
+ compileTimeWriter = compileW;
+ runTimeWriter = runW;
+ drainTimeWriter = drainW;
+ searchTimeWriter = searchW;
+ }
+
+ @Override
+ public void compilationFinished(boolean isCompiled, String msg) {
+ if (compileTimeSW != null) {
+ compileTimeSW.stop();
+ long time = compileTimeSW.elapsed(TimeUnit.MILLISECONDS);
+ logCompileTime(time);
+ }
+ }
+
+ @Override
+ public void compilationStarted() {
+ compileTimeSW = Stopwatch.createStarted();
+ }
+
+ @Override
+ public void drainingFinished(String msg) {
+ if (drainTimeSW != null && drainTimeSW.isRunning()) {
+ drainTimeSW.stop();
+ long time = drainTimeSW.elapsed(TimeUnit.MILLISECONDS);
+ logDrainTime(time);
+ }
+ }
+
+ @Override
+ public void drainingStarted() {
+ drainTimeSW = Stopwatch.createStarted();
+ }
+
+ @Override
+ public void drainDataCollectionStarted() {
+ drainDataCollectionTimeSW = Stopwatch.createStarted();
+ }
+
+ @Override
+ public void drainDataCollectionFinished(String msg) {
+ if (drainDataCollectionTimeSW != null) {
+ drainDataCollectionTimeSW.stop();
+ long time = drainDataCollectionTimeSW
+ .elapsed(TimeUnit.MILLISECONDS);
+ logDrainDataCollectionTime(time);
+ }
+ }
+
+ @Override
+ public void logCompileTime(long time) {
+ write(compileTimeWriter,
+ String.format("Total compile time %dms\n", time));
+ }
+
+ @Override
+ public void logCompileTime(String msg) {
+ write(compileTimeWriter, msg);
+ }
+
+ @Override
+ public void logDrainDataCollectionTime(long time) {
+ write(drainTimeWriter,
+ String.format("Drain data collection time is %dms\n", time));
+ }
+
+ @Override
+ public void logDrainTime(long time) {
+ write(drainTimeWriter, String.format("Drain time is %dms\n", time));
+ }
+
+ @Override
+ public void logDrainTime(String msg) {
+ write(drainTimeWriter, msg);
+ }
+
+ @Override
+ public void logRunTime(long time) {
+ write(runTimeWriter,
+ String.format("Execution time is %dms\n", time));
+ }
+
+ @Override
+ public void logRunTime(String msg) {
+ write(runTimeWriter, msg);
+ }
+
+ /**
+ * [24-02-2015] When a new configuration come from the OpenTuner, we
+ * drain previous configuration. So the drainTime file should be updated
+ * with previous configuration prefix.
+ */
+ String prevcfgPrefix = "";
+
+ @Override
+ public void newConfiguration(String cfgPrefix) {
+ reconfigNo++;
+ if (cfgPrefix == null || cfgPrefix.isEmpty())
+ cfgPrefix = new Integer(reconfigNo).toString();
+
+ updateTuningRoundTime();
+
+ String msg = String
+ .format("----------------------------%s----------------------------\n",
+ cfgPrefix);
+ String msg1 = String
+ .format("----------------------------%s----------------------------\n",
+ prevcfgPrefix);
+ write(compileTimeWriter, msg);
+ write(runTimeWriter, msg);
+ write(searchTimeWriter, msg);
+ write(drainTimeWriter, msg1);
+ prevcfgPrefix = cfgPrefix;
+ }
+
+ private void updateTuningRoundTime() {
+ long time = 0;
+ if (tuningRoundSW == null)
+ tuningRoundSW = Stopwatch.createStarted();
+ else {
+ tuningRoundSW.stop();
+ time = tuningRoundSW.elapsed(TimeUnit.SECONDS);
+ tuningRoundSW.reset();
+ tuningRoundSW.start();
+ write(runTimeWriter,
+ String.format("Tuning round time %dS\n", time));
+ }
+ }
+
+ private static OutputStreamWriter getOSWriter(OutputStream os) {
+ if (os == null)
+ return null;
+ return new OutputStreamWriter(os);
+ }
+
+ private void write(OutputStreamWriter osWriter, String msg) {
+ if (osWriter != null) {
+ try {
+ osWriter.write(msg);
+ osWriter.flush();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ @Override
+ public void logSearchTime(long time) {
+ write(searchTimeWriter,
+ String.format("Search time is %dms\n", time));
+ }
+ }
+}
diff --git a/src/edu/mit/streamjit/impl/distributed/Visualizer.java b/src/edu/mit/streamjit/impl/distributed/Visualizer.java
new file mode 100644
index 00000000..a52e5096
--- /dev/null
+++ b/src/edu/mit/streamjit/impl/distributed/Visualizer.java
@@ -0,0 +1,303 @@
+package edu.mit.streamjit.impl.distributed;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import edu.mit.streamjit.api.Filter;
+import edu.mit.streamjit.api.Joiner;
+import edu.mit.streamjit.api.OneToOneElement;
+import edu.mit.streamjit.api.Pipeline;
+import edu.mit.streamjit.api.Splitjoin;
+import edu.mit.streamjit.api.Splitter;
+import edu.mit.streamjit.api.StreamVisitor;
+import edu.mit.streamjit.api.Worker;
+import edu.mit.streamjit.impl.blob.Blob.Token;
+import edu.mit.streamjit.impl.common.Configuration;
+import edu.mit.streamjit.impl.common.Workers;
+import edu.mit.streamjit.impl.distributed.common.Utils;
+import edu.mit.streamjit.util.ConfigurationUtils;
+
+/**
+ * Interface to visualize a stream graph and it's configurations. Use the
+ * constructor to get the stream graph.
+ *
+ * @author Sumanan
+ * @since 29 Dec, 2014
+ */
+public interface Visualizer {
+
+ /**
+ * Call this method with new configuration, whenever the configuration
+ * changes.
+ *
+ * @param cfg
+ */
+ public void newConfiguration(Configuration cfg);
+
+ /**
+ * Partitions Machine Map of the current configuration. Only the
+ * {@link PartitionManager} has the information to generate this map.
+ * Visualizer has no glue to generate this partitionsMachineMap.
+ *
+ * @param partitionsMachineMap
+ */
+ public void newPartitionMachineMap(
+ Map>>> partitionsMachineMap);
+
+ /**
+ * Use this class to have no visualization.
+ *
+ */
+ public static class NoVisualizer implements Visualizer {
+
+ @Override
+ public void newConfiguration(Configuration cfg) {
+ return;
+ }
+
+ @Override
+ public void newPartitionMachineMap(
+ Map>>> partitionsMachineMap) {
+ return;
+ }
+ }
+
+ /**
+ * Generates dot file and then from the dot file generates graph. Before
+ * using this class, ensure that Graphviz is properly installed in the
+ * system.
+ */
+ public static class DotVisualizer implements Visualizer {
+
+ protected final OneToOneElement streamGraph;
+
+ private final String appName;
+
+ /**
+ * namePrefix of the current configuration.
+ */
+ private String namePrefix = "";
+
+ /**
+ * Tells whether the dot tool is installed in the system or not.
+ */
+ private boolean hasDot;
+
+ public DotVisualizer(OneToOneElement streamGraph) {
+ this.streamGraph = streamGraph;
+ this.appName = streamGraph.getClass().getSimpleName();
+ hasDot = true;
+ DOTstreamVisitor dotSV = new DOTstreamVisitor();
+ streamGraph.visit(dotSV);
+ }
+
+ /**
+ * Visits through the Stream graph and generates dot file.
+ *
+ * @author sumanan
+ * @since 29 Dec, 2014
+ */
+ private class DOTstreamVisitor extends StreamVisitor {
+
+ private final FileWriter writer;
+
+ DOTstreamVisitor() {
+ writer = Utils.fileWriter(appName, "streamgraph.dot");
+ }
+
+ private void initilizeDot() {
+ try {
+ writer.write(String.format("digraph %s {\n", appName));
+ writer.write("\trankdir=TD;\n");
+ writer.write("\tnodesep=0.5;\n");
+ writer.write("\tranksep=equally;\n");
+ // writer.write("\tnode [shape = circle];\n");
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ private void closeDot() {
+ try {
+ writer.write("}");
+ writer.flush();
+ writer.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ @Override
+ public void beginVisit() {
+ initilizeDot();
+ }
+
+ @Override
+ public void visitFilter(Filter filter) {
+ updateDot(filter);
+ }
+
+ @Override
+ public boolean enterPipeline(Pipeline pipeline) {
+ return true;
+ }
+
+ @Override
+ public void exitPipeline(Pipeline pipeline) {
+
+ }
+
+ @Override
+ public boolean enterSplitjoin(Splitjoin splitjoin) {
+ return true;
+ }
+
+ @Override
+ public void visitSplitter(Splitter splitter) {
+ updateDot(splitter);
+ }
+
+ @Override
+ public boolean enterSplitjoinBranch(OneToOneElement element) {
+ return true;
+ }
+
+ @Override
+ public void exitSplitjoinBranch(OneToOneElement element) {
+ }
+
+ @Override
+ public void visitJoiner(Joiner joiner) {
+ updateDot(joiner);
+ }
+
+ @Override
+ public void exitSplitjoin(Splitjoin splitjoin) {
+ }
+
+ @Override
+ public void endVisit() {
+ closeDot();
+ runDot("streamgraph");
+ }
+
+ private void updateDot(Worker w) {
+ for (Worker suc : Workers.getSuccessors(w)) {
+ String first = w.getClass().getSimpleName();
+ String second = suc.getClass().getSimpleName();
+ int id = Workers.getIdentifier(w);
+ int sucID = Workers.getIdentifier(suc);
+ try {
+ writer.write(String.format("\t%d -> %d;\n", id, sucID));
+ // writer.write(String.format("\t%s -> %s;\n", first,
+ // second));
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+
+ @Override
+ public void newConfiguration(Configuration cfg) {
+ namePrefix = ConfigurationUtils.getConfigPrefix(cfg);
+ }
+
+ private void runDot(String file) {
+ String outFileFormat = "svg";
+ String fileName = String.format("./%s%s%s.dot", appName,
+ File.separator, file);
+ String outFileName = String.format("./%s%s%s%s%s_%s.%s", appName,
+ File.separator, ConfigurationUtils.configDir,
+ File.separator, namePrefix, file, outFileFormat);
+ ProcessBuilder pb = new ProcessBuilder("dot", "-T" + outFileFormat,
+ fileName, "-o", outFileName);
+ try {
+ Process p = pb.start();
+ // TODO: [20-2-2015]. I am commenting the following line for
+ // some performance improvement. Look for bugs.
+ // p.waitFor();
+ } catch (IOException e) {
+ System.err
+ .println("DotVisualizer: dot(Graphviz) tool is not properly installed in the system");
+ hasDot = false;
+ // e.printStackTrace();
+ }
+ }
+
+ @Override
+ public void newPartitionMachineMap(
+ Map>>> partitionsMachineMap) {
+ if (!hasDot)
+ return;
+ FileWriter writer;
+ try {
+ writer = blobGraphWriter();
+ for (int machine : partitionsMachineMap.keySet()) {
+ for (Set> blobworkers : partitionsMachineMap
+ .get(machine)) {
+ Token blobID = Utils.getblobID(blobworkers);
+ writer.write(String
+ .format("\tsubgraph \"cluster_%s\" { color="
+ + "royalblue1; label = \"Blob-%s:Machine-%d\";",
+ blobID, blobID, machine));
+ Set workerIDs = getWorkerIds(blobworkers);
+ for (Integer id : workerIDs)
+ writer.write(String.format(" %d;", id));
+ writer.write("}\n");
+ }
+ }
+ writer.write("}\n");
+ writer.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ runDot("blobgraph");
+ }
+ private Set getWorkerIds(Set> blobworkers) {
+ Set workerIds = new HashSet<>();
+ for (Worker w : blobworkers) {
+ workerIds.add(Workers.getIdentifier(w));
+ }
+ return workerIds;
+ }
+
+ /**
+ * Copies all lines except the final closing bracket from
+ * streamgraph.dot to blobgraph.dot.
+ *
+ * @return
+ * @throws IOException
+ */
+ private FileWriter blobGraphWriter() throws IOException {
+ File streamGraph = new File(String.format("./%s%sstreamgraph.dot",
+ appName, File.separator));
+ File blobGraph = new File(String.format("./%s%sblobgraph.dot",
+ appName, File.separator));
+ BufferedReader reader = new BufferedReader(new FileReader(
+ streamGraph));
+ FileWriter writer = new FileWriter(blobGraph, false);
+ String line;
+ int unclosedParenthesis = 0;
+ while ((line = reader.readLine()) != null) {
+ if (line.contains("{"))
+ unclosedParenthesis++;
+ if (line.contains("}"))
+ unclosedParenthesis--;
+ if (unclosedParenthesis > 0) {
+ writer.write(line);
+ writer.write("\n");
+ }
+ }
+ reader.close();
+ return writer;
+ }
+ }
+}
diff --git a/src/edu/mit/streamjit/impl/distributed/WorkerMachine.java b/src/edu/mit/streamjit/impl/distributed/WorkerMachine.java
index 3d97b6cb..bcdc3d1d 100644
--- a/src/edu/mit/streamjit/impl/distributed/WorkerMachine.java
+++ b/src/edu/mit/streamjit/impl/distributed/WorkerMachine.java
@@ -28,17 +28,15 @@
import java.util.Map;
import java.util.Set;
-import com.google.common.collect.ImmutableSet;
+import static com.google.common.base.Preconditions.*;
-import edu.mit.streamjit.api.StreamCompilationFailedException;
import edu.mit.streamjit.api.Worker;
import edu.mit.streamjit.impl.common.Configuration;
-import edu.mit.streamjit.impl.common.Workers;
-import edu.mit.streamjit.impl.common.AbstractDrainer.BlobGraph;
import edu.mit.streamjit.impl.common.Configuration.IntParameter;
import edu.mit.streamjit.impl.common.Configuration.Parameter;
import edu.mit.streamjit.impl.common.Configuration.SwitchParameter;
-import edu.mit.streamjit.impl.distributed.ConfigurationManager.AbstractConfigurationManager;
+import edu.mit.streamjit.impl.common.Workers;
+import edu.mit.streamjit.impl.distributed.PartitionManager.AbstractPartitionManager;
/**
* This class implements one type of search space. Adds "worker to machine"
@@ -58,15 +56,20 @@
* @since Jan 16, 2014
*
*/
-public final class WorkerMachine extends AbstractConfigurationManager {
+public final class WorkerMachine extends AbstractPartitionManager {
+
+ private final Set> workerset;
- WorkerMachine(StreamJitApp app) {
+ public WorkerMachine(StreamJitApp app) {
super(app);
+ this.workerset = Workers.getAllWorkersInGraph(app.source);
}
@Override
public Configuration getDefaultConfiguration(Set> workers,
int noOfMachines) {
+ checkArgument(noOfMachines > 0, String.format(
+ "noOfMachines = %d, It must be > 0", noOfMachines));
Configuration.Builder builder = Configuration.builder();
List machinelist = new ArrayList<>(noOfMachines);
for (int i = 1; i <= noOfMachines; i++)
@@ -90,49 +93,8 @@ public Configuration getDefaultConfiguration(Set> workers,
return builder.build();
}
- /**
- * Builds partitionsMachineMap and {@link BlobGraph} from the new
- * Configuration, and verifies for any cycles among blobs. If it is a valid
- * configuration, (i.e., no cycles among the blobs), then {@link #app}
- * object's member variables {@link StreamJitApp#blobConfiguration},
- * {@link StreamJitApp#blobGraph} and
- * {@link StreamJitApp#partitionsMachineMap} will be assigned according to
- * reflect the new configuration, no changes otherwise.
- *
- * @param config
- * New configuration form Opentuer.
- * @return true iff no cycles among blobs
- */
- @Override
- public boolean newConfiguration(Configuration config) {
-
- Map>>> partitionsMachineMap = getMachineWorkerMap(
- config, app.source);
- try {
- app.varifyConfiguration(partitionsMachineMap);
- } catch (StreamCompilationFailedException ex) {
- return false;
- }
- app.blobConfiguration = config;
- return true;
- }
-
- /**
- * Reads the configuration and returns a map of nodeID to list of set of
- * workers (list of blob workers) which are assigned to the node. Value of
- * the returned map is list of worker set where each worker set is an
- * individual blob.
- *
- * @param config
- * @param workerset
- * @return map of nodeID to list of set of workers which are assigned to the
- * node.
- */
- private Map>>> getMachineWorkerMap(
- Configuration config, Worker source) {
-
- ImmutableSet