public DistributedProgressTracker(InternalComputation internalComputation) { var processes = internalComputation.Controller.Configuration.Processes; var processid = internalComputation.Controller.Configuration.ProcessID; var context = new TimeContext <Empty>(internalComputation.ContextManager.MakeRawContextForScope <Empty>("progress context")); // construct aggregator stage with unconnected output var aggregatorPlacement = new Placement.SingleVertexPerProcess(processes, 0); var aggregator = new Stage <ProgressUpdateAggregator, Empty>(aggregatorPlacement, context, Stage.OperatorType.Default, (i, v) => new ProgressUpdateAggregator(i, v), "Aggregator"); var stream = aggregator.NewOutput(vertex => vertex.Output); aggregator.Materialize(); this.aggregator = aggregator.GetVertex(processid); // construct consumer stage with unconnected input var consumerPlacement = new Placement.SingleVertexPerProcess(processes, 0); var consumer = new Stage <ProgressUpdateConsumer, Empty>(consumerPlacement, context, Stage.OperatorType.Default, (i, v) => new ProgressUpdateConsumer(i, v, this.aggregator), "Consumer"); var recvPort = consumer.NewUnconnectedInput(vertex => vertex.Input, null); consumer.Materialize(); this.consumer = consumer.GetVertex(processid); // connect aggregators to consumers with special progress channel this.progressChannel = new ProgressChannel(aggregatorPlacement.Count, this.consumer, stream.StageOutput, recvPort, internalComputation.Controller, internalComputation.AllocateNewGraphIdentifier()); stream.StageOutput.AttachBundleToSender(this.progressChannel); Logging.Progress("Distributed progress tracker enabled"); }
internal StreamingInputStage(DataSource <R> source, Placement placement, InternalComputation internalComputation, string inputName) { this.inputName = inputName; this.stage = Foundry.NewStage(new TimeContext <Epoch>(internalComputation.ContextManager.RootContext), (i, v) => new StreamingInputVertex <R>(i, v), this.inputName); this.output = stage.NewOutput(vertex => vertex.output); this.stage.Materialize(); this.localVertices = placement.Where(x => x.ProcessId == internalComputation.Controller.Configuration.ProcessID) .Select(x => this.stage.GetVertex(x.VertexId) as StreamingInputVertex <R>) .ToArray(); source.RegisterInputs(this.localVertices); this.completedCalled = false; this.hasActivatedProgressTracker = false; // results in pointstamp comparisons which assert w/o this. this.InternalComputation.Reachability.UpdateReachabilityPartialOrder(internalComputation); this.InternalComputation.Reachability.DoNotImpersonate(stage.StageId); var initialVersion = new Runtime.Progress.Pointstamp(stage.StageId, new int[] { 0 }); internalComputation.ProgressTracker.BroadcastProgressUpdate(initialVersion, placement.Count); }
internal ComputationState State(InternalComputation internalComputation) { if (this.computationStates.Count <= internalComputation.Index || this.computationStates[internalComputation.Index].InternalComputation == null) { this.RegisterGraph(internalComputation); } return(this.computationStates[internalComputation.Index]); }
public ComputationState(InternalComputation manager, Scheduler scheduler) { this.InternalComputation = manager; this.PostOffice = new PostOffice(scheduler); this.WorkItems = new List <WorkItem>(); this.index = scheduler.Index; this.Vertices = new List <Dataflow.Vertex>(); this.producer = null; }
internal void Register(Dataflow.Vertex vertex, InternalComputation manager) { for (int i = 0; i < this.computationStates.Count; i++) { if (this.computationStates[i].InternalComputation == manager) { this.computationStates[i].Vertices.Add(vertex); } } }
internal Stage(Placement placement, InternalComputation internalComputation, OperatorType operatorType, string name) { this.internalComputation = internalComputation; this.targets = new List <Edge>(); this.StageId = this.InternalComputation.Register(this); this.collectionType = operatorType; this.Placement = placement; this.name = name; MyName = string.Format("{0}[{1}]", name, this.StageId); }
internal void RegenerateGraph(InternalComputation manager) { var maxIdentifier = 0; if (manager.Stages.Count() > 0) { maxIdentifier = Math.Max(manager.Stages.Max(x => x.Key), maxIdentifier); } if (manager.Edges.Count() > 0) { maxIdentifier = Math.Max(manager.Edges.Max(x => x.Key), maxIdentifier); } this.Graph = new GraphNode[maxIdentifier + 1]; #if true for (int i = 0; i < this.Graph.Length; i++) { this.Graph[i] = new GraphNode(i, new int[] { }); } foreach (var stage in manager.Stages) { this.Graph[stage.Key] = new GraphNode(stage.Value); } foreach (var edge in manager.Edges) { this.Graph[edge.Key] = new GraphNode(edge.Value); } #else for (int i = 0; i < this.Graph.Length; i++) { if (manager.Stages.ContainsKey(i)) { this.Graph[i] = new GraphNode(manager.Stages[i]); } else if (manager.Edges.ContainsKey(i)) { this.Graph[i] = new GraphNode(manager.Edges[i]); } else // else it is processing a progress edge, because they are allocated differently { this.Graph[i] = new GraphNode(i, new int[] { }); } } #endif }
public CentralizedProgressTracker(InternalComputation internalComputation) { var centralizerProcessId = internalComputation.Controller.Configuration.CentralizerProcessId; var centralizerThreadId = internalComputation.Controller.Configuration.CentralizerThreadId; var processes = internalComputation.Controller.Configuration.Processes; var processid = internalComputation.Controller.Configuration.ProcessID; Logging.Progress("Centralized progress tracker enabled, running on process {0} thread {1}", centralizerProcessId, centralizerThreadId); var context = new TimeContext <Empty>(internalComputation.ContextManager.MakeRawContextForScope <Empty>("progress context")); // construct aggregator stage and unconnected output var aggregatorPlacement = new Placement.SingleVertexPerProcess(processes, 0); var aggregatorStage = new Stage <ProgressUpdateAggregator, Empty>(aggregatorPlacement, context, Stage.OperatorType.Default, (i, v) => new ProgressUpdateAggregator(i, v), "Aggregator"); var stream = aggregatorStage.NewOutput(vertex => vertex.Output); aggregatorStage.Materialize(); this.aggregator = aggregatorStage.GetVertex(processid); // construct centralizer stage and unconnected input and output var centralizerPlacement = new Placement.SingleVertex(centralizerProcessId, centralizerThreadId); var centralizer = new Stage <ProgressUpdateCentralizer, Empty>(centralizerPlacement, context, Stage.OperatorType.Default, (i, v) => new ProgressUpdateCentralizer(i, v, null), "Centralizer"); var centralizerRecvPort = centralizer.NewUnconnectedInput <Update>(vertex => vertex.Input, null); var centralizerSendPort = centralizer.NewOutput(vertex => vertex.Output, null); centralizer.Materialize(); this.centralizer = (processid == centralizerProcessId) ? centralizer.GetVertex(0) : null; // construct consumer stage and unconnected input var consumerPlacement = new Placement.SingleVertexPerProcess(processes, 0); var consumer = new Stage <ProgressUpdateConsumer, Empty>(consumerPlacement, context, Stage.OperatorType.Default, (i, v) => new Runtime.Progress.ProgressUpdateConsumer(i, v, this.aggregator), "Consumer"); var consumerRecvPort = consumer.NewUnconnectedInput(vertex => vertex.Input, null); consumer.Materialize(); this.consumer = consumer.GetVertex(processid); // connect centralizer to consumers with special progress channel var progressChannel = new ProgressChannel(centralizer.Placement.Count, this.consumer, centralizerSendPort.StageOutput, consumerRecvPort, internalComputation.Controller, internalComputation.AllocateNewGraphIdentifier()); centralizerSendPort.StageOutput.AttachBundleToSender(progressChannel); // connect aggregators to centralizer with special centralized progress channel var centralizerChannel = new CentralizedProgressChannel(centralizer, stream.StageOutput, centralizerRecvPort, internalComputation.Controller, internalComputation.AllocateNewGraphIdentifier()); stream.StageOutput.AttachBundleToSender(centralizerChannel); Logging.Progress("Centralized progress tracker initialization completed"); }
public RemoteMailbox(int channelID, int processID, int vertexID, InternalComputation manager) { this.channelID = channelID; this.processID = processID; this.vertexID = vertexID; this.graphID = manager.Index; this.networkChannel = manager.Controller.NetworkChannel; var controller = manager.Controller; this.encodersFromLocalVertices = new AutoSerializedMessageEncoder <S, T> [controller.Workers.Count]; for (int i = 0; i < controller.Workers.Count; ++i) { this.encodersFromLocalVertices[i] = new AutoSerializedMessageEncoder <S, T>(this.vertexID, this.graphID << 16 | this.channelID, this.networkChannel.GetBufferPool(this.processID, i), this.networkChannel.SendPageSize, manager.SerializationFormat, SerializedMessageType.Data, () => this.networkChannel.GetSequenceNumber(this.processID)); this.encodersFromLocalVertices[i].CompletedMessage += (o, a) => { this.networkChannel.SendBufferSegment(a.Hdr, this.processID, a.Segment); }; } }
internal void RegisterGraph(InternalComputation internalComputation) { var success = false; do { var oldList = this.computationStates; var newList = this.computationStates.ToList(); while (newList.Count < internalComputation.Index + 1) { newList.Add(new ComputationState()); } newList[internalComputation.Index] = new ComputationState(internalComputation, this); success = oldList == Interlocked.CompareExchange(ref this.computationStates, newList, oldList); }while (!success); }
// populates this.ComparisonDepth, indexed by collection and channel identifiers. public void UpdateReachabilityPartialOrder(InternalComputation internalComputation) { RegenerateGraph(internalComputation); var reachableDepths = new List <List <int> >(this.Graph.Length); var magicNumber = 37; //Console.Error.WriteLine("Updating reachability with {0} objects", Reachability.Graph.Length); for (int i = 0; i < this.Graph.Length; i++) { var reachable = new List <int>(this.Graph.Length); var versionList = new Pointstamp[] { new Pointstamp(i, Enumerable.Repeat(magicNumber, this.Graph[i].Depth).ToArray()) }; var reachabilityResults = this.DetermineReachabilityList(versionList); for (int j = 0; j < reachabilityResults.Length; j++) { var depth = 0; var increment = false; // for each element of the reachable set if (reachabilityResults[j] != null) { for (int k = 0; k < reachabilityResults[j].Count; k++) { for (int l = 0; l < reachabilityResults[j][k].Timestamp.Length && reachabilityResults[j][k].Timestamp[l] >= magicNumber; l++) { if (l + 1 > depth || l + 1 == depth && increment) { depth = l + 1; increment = (reachabilityResults[j][k].Timestamp[l] > magicNumber); } } } } reachable.Add(increment ? -depth : depth); } reachableDepths.Add(reachable); } this.ComparisonDepth = reachableDepths; #region Set up impersonation // consider each stage / edge this.Impersonations = new int[this.Graph.Length][]; for (int i = 0; i < this.Graph.Length; i++) { // not applicable to exchange edges. if (!this.Graph[i].Exchanges && !this.NoImpersonation.Contains(i)) { var reached = new HashSet <int>(); var limits = new HashSet <int>(); var queue = new List <int>(); //reached.Add(i); queue.Add(i); for (int j = 0; j < queue.Count; j++) { var candidate = queue[j]; // check if queue[j] is interested in masquerading var available = true; for (int k = 0; k < this.Graph[candidate].Neighbors.Length; k++) { var target = this.Graph[candidate].Neighbors[k]; if (this.Graph[target].Exchanges) { available = false; } } if (!reached.Contains(candidate)) { reached.Add(candidate); if (available) { for (int k = 0; k < this.Graph[candidate].Neighbors.Length; k++) { queue.Add(this.Graph[candidate].Neighbors[k]); } } else { limits.Add(candidate); } } } // if we found someone who wants to masquerade if (!limits.Contains(i) && limits.Count > 0) { Impersonations[i] = limits.ToArray(); } else { Impersonations[i] = null; } } } #endregion }
internal static Stream <S, Epoch> MakeStage(DataSource <S> source, InternalComputation internalComputation, Placement placement, string inputName) { var stage = new StreamingInputStage <S>(source, placement, internalComputation, inputName); return(stage); }
internal TimeContextManager(InternalComputation g) { this.internalComputation = g; this.rootContext = null; this.reporting = null; }
internal ProgressUpdateProducer(InternalComputation manager, ProgressUpdateAggregator aggregator) { this.LocalPCS = new PointstampCountSet(manager.Reachability); this.Aggregator = aggregator; NaiadTracing.Trace.LockInfo(this, "Producer lock"); }
internal ProgressUpdateProducer(InternalComputation manager, ProgressUpdateAggregator aggregator) { this.LocalPCS = new PointstampCountSet(manager.Reachability); this.Aggregator = aggregator; }