public static (List <long>, bool) FindPath_Greedy(
DAGNode s,
DAGNode t,
GraphDirection direction,
Predicate <DAGNode> nodeFilter,
Predicate <DAGEdge> edgeFilter,
Action <DAGNode> nodeAction,
Action <DAGEdge> edgeAction)
{
List <long> path = new();
bool pathFound = false;
SortedSet <long> processedNodes = new();
DAGNode currentNode = (direction == GraphDirection.Forward ? s : t);
if (!nodeFilter(currentNode))
{
pathFound = false;
return(path, pathFound);
}
while (true)
{
processedNodes.Add(currentNode.Id);
bool nextNodeFound = false;
path.Add(currentNode.Id);
nodeAction(currentNode);
if (currentNode == (direction == GraphDirection.Forward ? t : s))
{
pathFound = true;
return(path, pathFound);
}
List <DAGEdge> nextEdges = (direction == GraphDirection.Forward ?
currentNode.OutEdges : currentNode.InEdges);
foreach (DAGEdge e in nextEdges)
{
DAGNode v = (direction == GraphDirection.Forward ? e.ToNode : e.FromNode);
if (edgeFilter(e) && nodeFilter(v))
{
currentNode = v;
edgeAction(e);
nextNodeFound = true;
break;
}
}
if (!nextNodeFound)
{
return(path, pathFound);
}
}
}
public DAGEdge(long id, DAGNode fromNode, DAGNode toNode)
{
this.Id = id;
this.FromNode = fromNode;
this.ToNode = toNode;
}
private static void CopyNodesAndEdges(
DAG graph,
SortedSet <long> nodeIdSubset,
DAG subgraph)
{
subgraph.NodeEnumeration = new SortedDictionary <long, DAGNode>();
foreach (long nodeId in nodeIdSubset)
{
DAGNode subgraphNode = new(nodeId);
subgraph.AddNode(subgraphNode);
}
List <KeyValuePair <KeyValuePair <long, long>, DAGEdge> > nodePairList1 =
graph.NodePairEnumeration.Where(
t => subgraph.NodeEnumeration.ContainsKey(t.Key.Key)).ToList();
List <KeyValuePair <KeyValuePair <long, long>, DAGEdge> > nodePairList2 =
nodePairList1.Where(
t => subgraph.NodeEnumeration.ContainsKey(t.Key.Value)).ToList();
subgraph.NodePairEnumeration =
new SortedDictionary <KeyValuePair <long, long>, DAGEdge>(
new KeyValueComparer());
foreach (KeyValuePair <KeyValuePair <long, long>, DAGEdge> nodePair in nodePairList2)
{
DAGNode uSubgraphNode = subgraph.NodeEnumeration[nodePair.Key.Key];
DAGNode vSubgraphNode = subgraph.NodeEnumeration[nodePair.Key.Value];
DAGEdge subgraphEdge = new(nodePair.Value.Id, uSubgraphNode, vSubgraphNode);
subgraph.AddEdge(subgraphEdge);
}
}
public bool IfThereIsFlowFrom(
DAGNode fromNode,
ComputationStep fromCompStep,
ComputationStep toCompStep)
{
uint inputLength = (uint)MEAPSharedContext.Input.Length;
long L = MEAPSharedContext.MNP.GetLTapeBound(0, inputLength);
long R = MEAPSharedContext.MNP.GetRTapeBound(0, inputLength);
if ((toCompStep.kappaTape < L) || (R < toCompStep.kappaTape))
{
return(false);
}
if (fromCompStep.m == TMDirection.S)
{
if (fromCompStep.sNext != toCompStep.s)
{
return(false);
}
}
SortedSet <PropSymbol> procSymPrev = AppHelper.TakeValueByKey(
propagatedSymbols, fromNode.Id,
() => new SortedSet <PropSymbol>(new PropSymbolComparer()));
IEnumerable <PropSymbol> prevPairs = procSymPrev.Where(
t => (t.Variable == toCompStep.kappaTape));
IEnumerable <PropSymbol> prevMatchPairs =
prevPairs.Where(t => t.Symbol == toCompStep.s);
return(prevMatchPairs.Any());
}
public static bool FindPath_DFS(
DAG dag,
DAGNode s,
GraphDirection direction,
Predicate <DAGNode> nodeFilter,
Predicate <DAGEdge> edgeFilter,
Action <DAGNode, long> nodeAction,
Action <DAGEdge, long> edgeAction,
List <long> path)
{
SortedSet <long> processedNodes = new();
bool pathFound = FindPath_DFS(
s,
dag.t,
processedNodes,
direction,
0,
nodeFilter,
edgeFilter,
nodeAction,
edgeAction,
path);
return(pathFound);
}
public override SortedDictionary <long, Commodity> CreateCommodities()
{
compStepNodePairEnum.ForEach(p =>
{
log.InfoFormat(
"Comp step: {0} {1} {2}",
p.Value.Variable,
p.Value.uNode,
p.Value.vNode);
});
SortedDictionary <long, DAGNode> nodeEnumeration = meapContext.TArbSeqCFG.NodeEnumeration;
long i = 0;
foreach (KeyValuePair <long, CompStepNodePair> compStepNodePairPair in compStepNodePairEnum)
{
long pairId = compStepNodePairPair.Key;
CompStepNodePair compStepNodePair = compStepNodePairPair.Value;
DAGNode sNode = nodeEnumeration[compStepNodePair.uNode];
DAGNode tNode = nodeEnumeration[compStepNodePair.vNode];
log.DebugFormat("Build commodities: {0}", i);
Commodity newCommodity = new("Ki", i, compStepNodePair.Variable, default !);
public static void DFS(
DAGNode s,
GraphDirection direction,
Action <DAGNode, long> nodeAction,
Action <DAGEdge, long> edgeAction)
{
SortedSet <long> processedNodes = new();
DFS(s, processedNodes, direction, 0, nodeAction, edgeAction);
}
public static bool PropagateProperties(
DAG dag,
long fromNodeId,
GraphDirection direction,
Predicate <DAGNode> nodeFilter,
Predicate <DAGEdge> edgeFilter,
Predicate <DAGNode> nodeAction,
Predicate <DAGEdge> edgeAction)
{
QueueWithIdSet <DAGNode> nodeQueue = new();
bool status = false;
SortedSet <long> processedNodes = new();
DAGNode s = dag.NodeEnumeration[fromNodeId];
if (nodeFilter(s))
{
nodeQueue.Enqueue(s);
}
while (nodeQueue.Any())
{
DAGNode u = nodeQueue.Dequeue();
if (processedNodes.Contains(u.Id))
{
continue;
}
processedNodes.Add(u.Id);
bool nodeActionStatus = nodeAction(u);
status = status || nodeActionStatus;
foreach (DAGEdge e in (direction == GraphDirection.Forward ?
u.OutEdges : u.InEdges))
{
DAGNode v = (direction == GraphDirection.Forward ? e.ToNode : e.FromNode);
if (!edgeFilter(e))
{
continue;
}
bool edgeActionStatus = edgeAction(e);
status = status || edgeActionStatus;
if (nodeFilter(v) && (!nodeQueue.Contains(v)))
{
nodeQueue.Enqueue((direction == GraphDirection.Forward ? e.ToNode : e.FromNode));
}
}
}
return(status);
}
public override void FindTConsistPath()
{
tapeSegContext.TapeSegTConsistPath = new List <long>();
tapeSegContext.TapeSegPathFound = false;
if (tapeSegContext.KSetZetaSubset.Count == 1)
{
if (FindPathInCaseSingleZeta())
{
tapeSegContext.TapeSegPathExists = true;
tapeSegContext.TapeSegPathFound = true;
log.Info("Found path in case of single zeta");
return;
}
}
List <long> partialTConsistPath = tapeSegContext.PartialTConsistPath;
while (true)
{
if (!SelectNode(partialTConsistPath, out long initNodeId))
{
log.Info("Path not found (select node)");
return;
}
DAGNode initNode = meapContext.TArbSeqCFG.NodeEnumeration[initNodeId];
processedNodes.Add(initNodeId);
(List <long> tConsistPath, bool KPathFound) = DAG.FindPath_Greedy(
initNode,
meapContext.TArbSeqCFG.t,
GraphDirection.Forward,
u => !tapeSegContext.TArbSeqCFGUnusedNodes.Contains(u.Id),
d => NodeInChain(d.ToNode),
u => processedNodes.Add(u.Id),
(_) => { });
if (KPathFound)
{
tapeSegContext.TapeSegTConsistPath.AddRange(partialTConsistPath);
tapeSegContext.TapeSegTConsistPath.AddRange(tConsistPath);
tapeSegContext.TapeSegPathExists = true;
tapeSegContext.TapeSegPathFound = true;
return;
}
}
}
public TypedDAG <GTCZNodeInfo, StdEdgeInfo> Run(SortedSet <long> commodities)
{
TypedDAG <GTCZNodeInfo, StdEdgeInfo> gtcz = new("GTCZ");
SortedDictionary <long, DAGNode> nodeEnumeration = new();
long edgeId = 0;
foreach (long commodityId in commodities)
{
Commodity commodity = meapContext.Commodities[commodityId];
long sNodeId = commodity.sNodeId;
long tNodeId = commodity.tNodeId;
if (!nodeEnumeration.ContainsKey(sNodeId))
{
DAGNode newNode = new(sNodeId);
gtcz.AddNode(newNode);
if (meapContext.TArbSeqCFG.IsSourceNode(sNodeId))
{
gtcz.SetSourceNode(newNode);
}
nodeEnumeration[sNodeId] = newNode;
}
if (!nodeEnumeration.ContainsKey(tNodeId))
{
DAGNode newNode = new(tNodeId);
gtcz.AddNode(newNode);
if (meapContext.TArbSeqCFG.IsSinkNode(tNodeId))
{
gtcz.SetSinkNode(newNode);
}
nodeEnumeration[tNodeId] = newNode;
}
DAGNode from = nodeEnumeration[sNodeId];
DAGNode to = nodeEnumeration[tNodeId];
if (!gtcz.AreConnected(from.Id, to.Id))
{
DAGEdge newEdge = new(edgeId++, from, to);
gtcz.AddEdge(newEdge);
}
}
return(gtcz);
}
public override void CheckNCGNodesHaveTheSameSymbol(MEAPContext meapContext)
{
log.Info("CheckNCGNodesHaveTheSameSymbolFrom");
foreach (KeyValuePair <long, FwdBkwdNCommsGraphPair> ncgItemPair in
meapContext.muToNestedCommsGraphPair)
{
NCGraphType bkwdNestedCommsGraph = ncgItemPair.Value.BkwdNestedCommsGraph;
foreach (KeyValuePair <long, DAGNode> ncgNodeItemPair in bkwdNestedCommsGraph.NodeEnumeration)
{
long uNCGNodeId = ncgNodeItemPair.Key;
DAGNode uNCGNode = ncgNodeItemPair.Value;
if (!meapContext.Commodities.TryGetValue(uNCGNodeId, out Commodity? uComm))
{
continue;
}
long uNodeId = uComm.tNodeId;
ComputationStep uCompStep = meapContext.TArbSeqCFG.IdToNodeInfoMap[uNodeId].CompStep;
bool firstEdge = true;
int sTo = OneTapeTuringMachine.blankSymbol;
foreach (DAGEdge e in uNCGNode.InEdges)
{
long vNCGNodeId = e.FromNode.Id;
Commodity vComm = meapContext.Commodities[vNCGNodeId];
long vNodeId = vComm.tNodeId;
ComputationStep vCompStep = meapContext.TArbSeqCFG.IdToNodeInfoMap[vNodeId].CompStep;
if (vNodeId == meapContext.TArbSeqCFG.GetSinkNodeId())
{
continue;
}
if (firstEdge)
{
sTo = vCompStep.s;
firstEdge = false;
}
else
{
Ensure.That(vCompStep.s).Is(sTo);
}
}
}
}
}
public static bool BFS(
DAG dag,
SortedSet <long> initNodes,
Predicate <DAGNode> filter,
Predicate <DAGNode> action)
{
SortedSet <long> processedNodes = new();
QueueWithIdSet <DAGNode> nodeQueue = new();
bool status = false;
initNodes.ForEach(u =>
{
DAGNode uNode = dag.NodeEnumeration[u];
if (!nodeQueue.Contains(uNode))
{
nodeQueue.Enqueue(uNode);
}
processedNodes.Add(u);
});
while (nodeQueue.Any())
{
DAGNode v = nodeQueue.Dequeue();
if (!filter(v))
{
continue;
}
if (InFlowComputed(initNodes, filter, processedNodes, v))
{
processedNodes.Add(v.Id);
bool actionStatus = action(v);
status = status || actionStatus;
foreach (DAGEdge e in v.OutEdges)
{
if (!nodeQueue.Contains(e.ToNode))
{
nodeQueue.Enqueue(e.ToNode);
}
}
}
}
return(status);
}
public void Run()
{
SortedDictionary <long, SortedSet <long> > nodeVLevels =
meapContext.MEAPSharedContext.NodeLevelInfo.NodeVLevels;
bkwdKStepSequence = CPLTMInfo.BkwdCommsKStepSequence(kStep).ToArray();
long bkwdKStepLastIndex = bkwdKStepSequence.LastIndex();
for (long i = (bkwdKStepLastIndex - 1); i >= 0; i--)
{
foreach (long uId in nodeVLevels[bkwdKStepSequence[i]])
{
if (!meapContext.TArbSeqCFG.HasNode(uId))
{
continue;
}
DAGNode uNode = meapContext.TArbSeqCFG.GetNode(uId);
foreach (DAGEdge e in uNode.InEdges)
{
DAGNode vNode = e.FromNode;
long vId = vNode.Id;
Connect2CommsByCFGEdge(e.Id, uId, vId);
}
}
}
foreach (long uId in nodeVLevels[bkwdKStepSequence[bkwdKStepLastIndex]])
{
if (!meapContext.TArbSeqCFG.HasNode(uId))
{
continue;
}
DAGNode uNode = meapContext.TArbSeqCFG.GetNode(uId);
foreach (DAGEdge e in uNode.InEdges)
{
DAGNode vNode = e.FromNode;
long vId = vNode.Id;
ConnectCommAndCFGNodeByCFGEdge(e.Id, uId, vId);
}
}
}
public bool RemoveOrphanCommodities(
long zeta,
SortedSet <long> zetaCommodities,
TypedDAG <GTCZNodeInfo, StdEdgeInfo> gtcz,
SortedSet <long> excludedComms)
{
List <long> commsToRemove = new();
foreach (long commodityId in zetaCommodities)
{
Commodity commodity = meapContext.Commodities[commodityId];
long sNodeId = commodity.Gi.GetSourceNodeId();
long tNodeId = commodity.Gi.GetSinkNodeId();
DAGNode gtcz_u = gtcz.NodeEnumeration[sNodeId];
DAGNode gtcz_v = gtcz.NodeEnumeration[tNodeId];
if ((!meapContext.TArbSeqCFG.IsSourceNode(sNodeId)) && (!gtcz_u.InEdges.Any()))
{
commsToRemove.Add(commodity.Id);
gtcz.RemoveNodePair(sNodeId, tNodeId);
continue;
}
if ((!meapContext.TArbSeqCFG.IsSinkNode(tNodeId)) && (!gtcz_v.OutEdges.Any()))
{
commsToRemove.Add(commodity.Id);
gtcz.RemoveNodePair(sNodeId, tNodeId);
continue;
}
}
log.DebugFormat("Removed orphan commodities {0}:", zeta);
commsToRemove.ForEach(c =>
{
nodesCoverageKeeper.RemoveCommodity(c, excludedComms);
log.DebugFormat("commodity {0}", c);
});
return(commsToRemove.Any());
}
private static bool InFlowComputed(
SortedSet <long> initNodes,
Predicate <DAGNode> filter,
SortedSet <long> processedNodes,
DAGNode w)
{
if (!w.InEdges.Any())
{
return(true);
}
if (initNodes.Contains(w.Id))
{
return(true);
}
return(w.InEdges.All(e => (!filter(e.FromNode) ||
processedNodes.Contains(e.FromNode.Id))));
}
public override SortedDictionary <long, Commodity> CreateCommodities()
{
log.DebugFormat(
"Build commodities: {0}",
meapContext.TConsistPairSet.Count);
long i = 0;
IReadOnlyDictionary <long, DAGNode> nodeEnumeration = meapContext.TArbSeqCFG.NodeEnumeration;
foreach (KeyValuePair <long, CompStepNodePair> compStepNodePairPair in compStepNodePairEnum)
{
CompStepNodePair compStepNodePair = compStepNodePairPair.Value;
DAGNode sNode = nodeEnumeration[compStepNodePair.uNode];
DAGNode tNode = nodeEnumeration[compStepNodePair.vNode];
log.DebugFormat("Build commodites: {0}", i);
Commodity newCommodity = new("Ki", i, compStepNodePair.Variable, default !);
public override void FindTConsistPath()
{
log.Debug("Finding tconsist path ...");
TraceKZetaSet();
TraceLPSolution();
tapeSegContext.TapeSegTConsistPath = new List <long>();
tapeSegContext.TapeSegPathFound = false;
List <long> partialTConsistPath = tapeSegContext.PartialTConsistPath;
long headNodeId = partialTConsistPath.Last();
(tConsistPath, integralKPathFound) = DAG.FindPath_Greedy(
meapContext.TArbSeqCFG.NodeEnumeration[headNodeId],
meapContext.TArbSeqCFG.t,
GraphDirection.Forward,
IsIntegralFlowNode,
(_) => true,
(_) => { },
(_) => { });
partialTConsistPath.AddRange(tConsistPath.Skip(1));
if (integralKPathFound)
{
tapeSegContext.TapeSegTConsistPath = new List <long>(partialTConsistPath);
tapeSegContext.TapeSegPathFound = true;
}
else
{
log.DebugFormat("Integral KPath not found");
long tailNodeId = partialTConsistPath.Last();
DAGNode tailNode = meapContext.TArbSeqCFG.NodeEnumeration[tailNodeId];
tapeSegContext.TConsistPathNodes = tailNode.OutEdges.Where(
e => IsPositiveFlowNode(e.ToNode)).Select(e => e.ToNode.Id).ToList();
tapeSegContext.TapeSegPathFound = false;
}
}
public override void CheckTASGNodesHaveTheSameSymbol(MEAPContext meapContext)
{
log.Info("CheckTASGNodesHaveTheSameSymbolFrom");
foreach (KeyValuePair <long, DAGNode> itemPair in meapContext.TArbSeqCFG.NodeEnumeration)
{
long uNodeId = itemPair.Key;
if (uNodeId == meapContext.TArbSeqCFG.GetSourceNodeId())
{
continue;
}
DAGNode uNode = itemPair.Value;
ComputationStep uCompStep = meapContext.TArbSeqCFG.IdToNodeInfoMap[uNodeId].CompStep;
bool firstEdge = true;
int sTo = OneTapeTuringMachine.blankSymbol;
foreach (DAGEdge e in uNode.OutEdges)
{
long vNodeId = e.ToNode.Id;
ComputationStep vCompStep = meapContext.TArbSeqCFG.IdToNodeInfoMap[vNodeId].CompStep;
if (vNodeId == meapContext.TArbSeqCFG.GetSinkNodeId())
{
continue;
}
if (firstEdge)
{
sTo = vCompStep.s;
firstEdge = false;
}
else
{
Ensure.That(vCompStep.s).Is(sTo);
}
}
}
}
public bool IfThereIsFlowFrom(
DAGNode fromNode,
ComputationStep fromCompStep,
ComputationStep toCompStep)
{
if ((fromCompStep.m == TMDirection.S) &&
(fromCompStep.sNext != toCompStep.s))
{
return(false);
}
SortedSet <PropSymbol> procSymPrev = AppHelper.TakeValueByKey(
propagatedSymbols, fromNode.Id,
() => new SortedSet <PropSymbol>(new PropSymbolComparer()));
IEnumerable <PropSymbol> prevPairs = procSymPrev.Where(
t => (t.Variable == toCompStep.kappaTape));
IEnumerable <PropSymbol> prevMatchPairs =
prevPairs.Where(t => t.Symbol == toCompStep.s);
return(prevMatchPairs.Any());
}
private static void DFS(
DAGNode u,
SortedSet <long> processedNodes,
GraphDirection direction,
long level,
Action <DAGNode, long> nodeAction,
Action <DAGEdge, long> edgeAction)
{
if (processedNodes.Contains(u.Id))
{
return;
}
nodeAction(u, level);
processedNodes.Add(u.Id);
foreach (DAGEdge e in (direction == GraphDirection.Forward ? u.OutEdges : u.InEdges))
{
DFS((direction == GraphDirection.Forward ? e.ToNode : e.FromNode),
processedNodes, direction, level + 1, nodeAction, edgeAction);
edgeAction(e, level);
}
}
public void PropagateSymbol(
DAGNode fromNode,
DAGNode toNode,
ComputationStep toCompStep)
{
SortedSet <PropSymbol> procSymPrev = AppHelper.TakeValueByKey(
propagatedSymbols, fromNode.Id,
() => new SortedSet <PropSymbol>(new PropSymbolComparer()));
SortedSet <PropSymbol> nodeProcSym = AppHelper.TakeValueByKey(
propagatedSymbols, toNode.Id,
() => new SortedSet <PropSymbol>(new PropSymbolComparer()));
foreach (PropSymbol p in procSymPrev.Where(
t => t.Variable != toCompStep.kappaTape))
{
nodeProcSym.Add(p);
}
nodeProcSym.Add(new PropSymbol(
toCompStep.kappaTape,
toCompStep.sNext));
}
public void Run()
{
TypedDAG <TASGNodeInfo, StdEdgeInfo> cfg = meapContext.TArbSeqCFG;
SortedDictionary <long, TASGNodeInfo> idToInfoMap = meapContext.TArbSeqCFG.IdToNodeInfoMap;
long kStepA = kSteps.Item1;
long kStepB = kSteps.Item2;
long kStepC = kSteps.Item3;
foreach (long nodeId in nodeVLevels[kStepB])
{
currDUPairs.Add(new KeyValuePair <long, long>(nodeId, nodeId));
}
for (long i = kStepB; i >= (kStepA + 1); i--)
{
foreach (KeyValuePair <long, long> duPair in currDUPairs)
{
long uNodeId = duPair.Key;
long vNodeId = duPair.Value;
DAGNode uNode = cfg.GetNode(uNodeId);
DAGNode vNode = cfg.GetNode(vNodeId);
foreach (DAGEdge uEdge in uNode.InEdges)
{
foreach (DAGEdge vEdge in vNode.OutEdges)
{
long defNodeId = uEdge.FromNode.Id;
long useNodeId = vEdge.ToNode.Id;
ComputationStep defCompStep = idToInfoMap[defNodeId].CompStep;
ComputationStep useCompStep = idToInfoMap[useNodeId].CompStep;
if ((defCompStep.kappaTape == useCompStep.kappaTape) &&
(defCompStep.sNext == useCompStep.s))
{
nextDUPairs.Add(new KeyValuePair <long, long>(defNodeId, useNodeId));
}
}
}
}
currDUPairs.Clear();
nextDUPairs.ForEach(t => currDUPairs.Add(t));
foreach (KeyValuePair <long, long> duPair in currDUPairs)
{
long defNodeId = duPair.Key;
long useNodeId = duPair.Value;
ComputationStep defCompStep = idToInfoMap[defNodeId].CompStep;
meapContext.TConsistPairSet.Add(
new CompStepNodePair(
variable: defCompStep.kappaTape,
uNode: duPair.Key,
vNode: duPair.Value
));
meapContext.TConsistPairCount++;
}
}
}
private static bool FindPath_DFS(
DAGNode u,
DAGNode t,
SortedSet <long> processedNodes,
GraphDirection direction,
long level,
Predicate <DAGNode> nodeFilter,
Predicate <DAGEdge> edgeFilter,
Action <DAGNode, long> nodeAction,
Action <DAGEdge, long> edgeAction,
List <long> path)
{
if (!nodeFilter(u))
{
return(false);
}
if (processedNodes.Contains(u.Id))
{
return(false);
}
nodeAction(u, level);
path.Add(u.Id);
processedNodes.Add(u.Id);
if (u.Id == t.Id)
{
return(true);
}
foreach (DAGEdge e in (direction == GraphDirection.Forward ? u.OutEdges : u.InEdges))
{
if (!edgeFilter(e))
{
continue;
}
bool pathFound = FindPath_DFS(
(direction == GraphDirection.Forward ? e.ToNode : e.FromNode),
t,
processedNodes,
direction,
level + 1,
nodeFilter,
edgeFilter,
nodeAction,
edgeAction,
path);
edgeAction(e, level);
if (pathFound)
{
return(true);
}
}
path.RemoveAt(path.Count - 1);
return(false);
}
