private void localImprovedTarjanGeldenhuysValmariReport_DotNet4(LocalPair succ, Stack <LocalPair> callStack, Dictionary <string, List <string> > outgoingTransitionTable)
{
//set flag to stop other thread
lock (reportLocker)
{
if (isStop)
{
return;
}
Dictionary <string, LocalPair> acceptingCycle = new Dictionary <string, LocalPair>(1024);
string to = succ.GetCompressedState();
//get states in the cycle
LocalPair tmp = callStack.Pop();
string tmpID = tmp.GetCompressedState();
while (!tmpID.Equals(to))
{
acceptingCycle.Add(tmpID, tmp);
tmp = callStack.Pop();
tmpID = tmp.GetCompressedState();
}
acceptingCycle.Add(tmpID, tmp);
//return the result for global multi-core
finalLocalTaskStack = callStack;
finalAcceptingCycle = acceptingCycle;
finalOutgoingTransitionTable = outgoingTransitionTable;
isStop = true;
}
}
/// <summary>
/// Get local fair counter example
/// </summary>
/// <param name="newSCC"></param>
/// <param name="localCallStack"></param>
/// <param name="isDeadLock"></param>
public void GetLocalFairCounterExample(Stack <LocalPair> localCallStack, List <ConfigurationBase> cycle, bool isDeadLock)
{
localCallStack.Pop();
int traceLen = localCallStack.Count;
List <ConfigurationBase> trace = new List <ConfigurationBase>(traceLen);
while (localCallStack.Count > 0)
{
LocalPair tmp = localCallStack.Pop();
trace.Insert(0, tmp.configuration);
if (tmp.configuration.Event == Constants.INITIAL_EVENT)
{
break;
}
}
lock (globalCounterExampleLocker)
{
if (isGlobalStop)
{
return;
}
if (!isDeadLock)
{
finalLoopIndex = trace.Count;
}
trace.AddRange(cycle);
finalTrace = trace;
isGlobalStop = true;
}
}
// Report cycle detected at blue DFS
public void SwarmNestedDFSReportBlueCycle(LocalPair step, LocalPair pair, Stack <LocalPair> BlueStack, Dictionary <string, StateColor> colorData, Dictionary <string, List <string> > OutgoingTransitionTable)
{
lock (MultiCoreLock)
{
StopMutliCoreThreads = true;
Dictionary <string, LocalPair> LoopPairs = new Dictionary <string, LocalPair>(1024);
string tmp = step.GetCompressedState();
string m = pair.GetCompressedState();
LocalPair node = BlueStack.Pop();
string nodeID = node.GetCompressedState();
while (!nodeID.Equals(tmp))
{
LoopPairs.Add(nodeID, node);
node = BlueStack.Pop();
nodeID = node.GetCompressedState();
}
LoopPairs.Add(nodeID, node);
MultiCoreLocalTaskStack = BlueStack;
MultiCoreResultedLoop = LoopPairs;
MultiCoreOutgoingTransitionTable = OutgoingTransitionTable;
}
}
// Report accepting cycle in red DFS
private void redReportAcceptinCycle(LocalPair succ, Stack <LocalPair> blueStack, Stack <LocalPair> redStack, Dictionary <string, Color> colorData, Dictionary <string, List <string> > outgoingTransitionTable)
{
Dictionary <string, LocalPair> acceptingCycle = new Dictionary <string, LocalPair>(1024);
string to = succ.GetCompressedState();
// get from redStack
while (redStack.Count > 0)
{
LocalPair tmpRed = redStack.Pop();
string tmpRedID = tmpRed.GetCompressedState();
acceptingCycle.Add(tmpRedID, tmpRed);
}
// pop the top of blueStack
LocalPair topBlueStack = blueStack.Pop();
string topBlueStackID = topBlueStack.GetCompressedState();
if (!topBlueStackID.Equals(to))
{
LocalPair tmpBlue = blueStack.Pop();
string tmpBlueID = tmpBlue.GetCompressedState();
while (!tmpBlueID.Equals(to))
{
acceptingCycle.Add(tmpBlueID, tmpBlue);
tmpBlue = blueStack.Pop();
tmpBlueID = tmpBlue.GetCompressedState();
}
acceptingCycle.Add(tmpBlueID, tmpBlue);
}
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
VerificationOutput.NoOfStates = colorData.Count;
LocalTaskStack = blueStack;
LocalGetCounterExample(acceptingCycle, outgoingTransitionTable);
}
/// <summary>
/// Get local counter example in case of deadlock in blue DFS
/// </summary>
/// <param name="localBlueStack"></param>
public void GetLocalDeadlockCounterExample(Stack <LocalPair> localBlueStack)
{
int traceLen = localBlueStack.Count;
List <ConfigurationBase> trace = new List <ConfigurationBase>(traceLen);
int count = 0;
while (localBlueStack.Count > 0)
{
LocalPair tmp = localBlueStack.Pop();
trace.Insert(0, tmp.configuration);
string tmpID = tmp.GetCompressedState();
count++;
if (tmp.configuration.Event == Constants.INITIAL_EVENT)
{
break;
}
}
//get global counter example and stop
lock (globalCounterExampleLocker)
{
if (isGlobalStop)
{
return;
}
finalTrace = trace;
isGlobalStop = true;
}
}
// report accepting cycle detected in blue DFS
public void localBlueReportAcceptinCycle(LocalPair succ, Stack <LocalPair> blueStack, Dictionary <string, List <string> > outgoingTransitionTable)
{
lock (reportLocker)
{
if (isStop)
{
return;
}
Dictionary <string, LocalPair> acceptingCycle = new Dictionary <string, LocalPair>(1024);
string to = succ.GetCompressedState();
// get accepting cycle
LocalPair tmp = blueStack.Pop();
string tmpID = tmp.GetCompressedState();
while (!tmpID.Equals(to))
{
acceptingCycle.Add(tmpID, tmp);
tmp = blueStack.Pop();
tmpID = tmp.GetCompressedState();
}
acceptingCycle.Add(tmpID, tmp);
// get final result
finalLocalTaskStack = blueStack;
finalAcceptingCycle = acceptingCycle;
finalOutgoingTransitionTable = outgoingTransitionTable;
isStop = true;
}
}
/// <summary>
/// Get counter example in case of loop in blue DFS
/// </summary>
/// <param name="s"></param>
/// <param name="blueStack"></param>
/// <param name="dfsColor"></param>
public void GetLoopCounterExample(string s, Stack <LocalPair> blueStack, Dictionary <string, Color> dfsColor)
{
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
VerificationOutput.NoOfStates = dfsColor.Count;
int traceLen = blueStack.Count;
List <ConfigurationBase> trace = new List <ConfigurationBase>(traceLen);
int count = 0;
int reverseIndex = -1;
while (blueStack.Count > 0)
{
LocalPair tmp = blueStack.Pop();
trace.Insert(0, tmp.configuration);
string tmpID = tmp.GetCompressedState();
if (s.Equals(tmpID))
{
reverseIndex = count;
}
count++;
if (tmp.configuration.Event == Constants.INITIAL_EVENT)
{
break;
}
}
VerificationOutput.CounterExampleTrace = trace;
VerificationOutput.LoopIndex = count - 1 - reverseIndex;
}
private void localReportAcceptingCycle(LocalPair succ, Stack <LocalPair> callStack, StringDictionary <int[]> dfsData, Dictionary <string, List <string> > outgoingTransitionTable)
{
//set flag to stop other processes
lock (MultiCoreLock)
{
StopMutliCoreThreads = true;
Dictionary <string, LocalPair> localAcceptingCycle = new Dictionary <string, LocalPair>(1024);
string to = succ.GetCompressedState();
//get states in the cycle
LocalPair tmp = callStack.Pop();
string tmpID = tmp.GetCompressedState();
while (!tmpID.Equals(to))
{
localAcceptingCycle.Add(tmpID, tmp);
tmp = callStack.Pop();
tmpID = tmp.GetCompressedState();
}
localAcceptingCycle.Add(tmpID, tmp);
//return the result for global multi-core
MultiCoreLocalTaskStack = callStack;
MultiCoreResultedLoop = localAcceptingCycle;
MultiCoreOutgoingTransitionTable = outgoingTransitionTable;
}
}
/// <summary>
/// Get fair counter example
/// </summary>
/// <param name="callStack"></param>
/// <param name="cycle"></param>
/// <param name="dfsNumber"></param>
/// <param name="isDeadLock"></param>
public void GetFairCounterExample(Stack <LocalPair> callStack, List <ConfigurationBase> cycle, Dictionary <string, int[]> dfsNumber, bool isDeadLock)
{
callStack.Pop();
int traceLen = callStack.Count;
List <ConfigurationBase> trace = new List <ConfigurationBase>(traceLen);
while (callStack.Count > 0)
{
LocalPair tmp = callStack.Pop();
trace.Insert(0, tmp.configuration);
if (tmp.configuration.Event == Constants.INITIAL_EVENT)
{
break;
}
}
if (!isDeadLock)
{
VerificationOutput.LoopIndex = trace.Count;
}
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
VerificationOutput.NoOfStates = dfsNumber.Count;
trace.AddRange(cycle);
VerificationOutput.CounterExampleTrace = trace;
}
private Dictionary <string, LocalPair> IsEventStrongFair(Dictionary <string, LocalPair> StronglyConnectedComponents, Dictionary <string, List <string> > OutgoingTransitionTable)
{
List <string> EngagedEvents = new List <string>();
EngagedEvents.Add(Constants.TAU);
foreach (KeyValuePair <string, LocalPair> value in StronglyConnectedComponents)
{
ConfigurationBase componetStep = value.Value.configuration;
if (!EngagedEvents.Contains(componetStep.Event) && (StronglyConnectedComponents.Count > 1 || !componetStep.IsDeadLock)) //&& componetStep.Event != Constants.TERMINATION
{
EngagedEvents.Add(componetStep.Event);
}
}
List <string> badStates = new List <string>();
foreach (KeyValuePair <string, LocalPair> value in StronglyConnectedComponents)
{
string componet = value.Key;
LocalPair pair = value.Value;
foreach (string evt in pair.Enabled)
{
if (!EngagedEvents.Contains(evt))
{
badStates.Add(componet);
}
}
}
if (badStates.Count > 0)
{
foreach (string var in badStates)
{
StronglyConnectedComponents.Remove(var);
}
if (StronglyConnectedComponents.Count > 0)
{
Dictionary <string, LocalPair> value = TarjanModelChecking2(StronglyConnectedComponents, OutgoingTransitionTable);
if (value != null)
{
return(value);
}
}
return(null);
}
else
{
//This SCC is fair.
return(StronglyConnectedComponents);
//return true;
}
}
// Report cycle detected at red DFS
public void SwarmNestedDFSReportRedCycle(LocalPair s, LocalPair step, LocalPair pair, Stack <LocalPair> BlueStack, Stack <LocalPair> RedStack, Dictionary <string, StateColor> colorData, Dictionary <string, List <string> > OutgoingTransitionTable)
{
lock (MultiCoreLock)
{
StopMutliCoreThreads = true;
Dictionary <string, LocalPair> LoopPairs = new Dictionary <string, LocalPair>(1024);
string tmp = step.GetCompressedState();
string v = pair.GetCompressedState();
string sID = s.GetCompressedState();
LocalPair node;
string nodeID;
// If s is start of the loop
if (sID.Equals(tmp))
{
do
{
node = RedStack.Pop();
nodeID = node.GetCompressedState();
LoopPairs.Add(nodeID, node);
} while (RedStack.Count > 0);
}
// If the start of the loop is the parent of s
else
{
do
{
node = RedStack.Pop();
nodeID = node.GetCompressedState();
LoopPairs.Add(nodeID, node);
} while (RedStack.Count > 0);
node = BlueStack.Pop();
nodeID = node.GetCompressedState();
while (!nodeID.Equals(tmp))
{
LoopPairs.Add(nodeID, node);
node = BlueStack.Pop();
nodeID = node.GetCompressedState();
}
LoopPairs.Add(nodeID, node);
}
MultiCoreLocalTaskStack = BlueStack;
MultiCoreResultedLoop = LoopPairs;
MultiCoreOutgoingTransitionTable = OutgoingTransitionTable;
}
}
// Report cycle detected at red DFS
public void ReportRedCycle(LocalPair s, LocalPair step, LocalPair pair, Stack <LocalPair> BlueStack, Stack <LocalPair> RedStack, StringDictionary <StateColor> colorData, Dictionary <string, List <string> > OutgoingTransitionTable)
{
Dictionary <string, LocalPair> LoopPairs = new Dictionary <string, LocalPair>(1024);
string tmp = step.GetCompressedState();
string v = pair.GetCompressedState();
string sID = s.GetCompressedState();
LocalPair node;
string nodeID;
// If s is start of the loop
if (sID.Equals(tmp))
{
do
{
node = RedStack.Pop();
nodeID = node.GetCompressedState();
LoopPairs.Add(nodeID, node);
} while (RedStack.Count > 0);
}
// If the start of the loop is the parent of s
else
{
do
{
node = RedStack.Pop();
nodeID = node.GetCompressedState();
LoopPairs.Add(nodeID, node);
} while (RedStack.Count > 0);
node = BlueStack.Pop();
nodeID = node.GetCompressedState();
while (!nodeID.Equals(tmp))
{
LoopPairs.Add(nodeID, node);
node = BlueStack.Pop();
nodeID = node.GetCompressedState();
}
LoopPairs.Add(nodeID, node);
}
LocalTaskStack = BlueStack;
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
VerificationOutput.NoOfStates = colorData.Count;
LocalGetCounterExample(LoopPairs, OutgoingTransitionTable);
}
private Dictionary <string, LocalPair> IsProcesstWeakFair(Dictionary <string, LocalPair> StronglyConnectedComponents)
{
List <string> AlwaysEnabledProcesses = new List <string>();
HashSet <string> EngagedProcesses = new HashSet <string>();
foreach (KeyValuePair <string, LocalPair> value in StronglyConnectedComponents)
{
//string componet = value.Key;
LocalPair componetStep = value.Value;
if (AlwaysEnabledProcesses.Count > 0)
{
AlwaysEnabledProcesses = Ultility.Ultility.Intersect(AlwaysEnabledProcesses, componetStep.Enabled);
}
else
{
AlwaysEnabledProcesses.AddRange(componetStep.Enabled);
}
//The above gets the processes which are always enabled during the SCC.
//The below gets the processes which made some progress during the SCC.
if (componetStep.configuration.ParticipatingProcesses != null)
{
string[] indexes = componetStep.configuration.ParticipatingProcesses;
foreach (string s in indexes)
{
if (!EngagedProcesses.Contains(s))
{
EngagedProcesses.Add(s);
}
}
}
//The above gets the processes which made some progress during the SCC.
}
//discard the SCC if there exists a process which is always enabled but never engaged.
foreach (string s in AlwaysEnabledProcesses)
{
if (!EngagedProcesses.Contains(s))
{
return(null);
}
}
return(StronglyConnectedComponents);
//return true;
}
/// <summary>
/// Get global counter example in red DFS and stop
/// </summary>
/// <param name="s"></param>
/// <param name="localBlueStack"></param>
/// <param name="localRedStack"></param>
public void GetLocalLoopCounterExample(string s, Stack <LocalPair> localBlueStack, Stack <LocalPair> localRedStack)
{
int traceLen = localRedStack.Count + localBlueStack.Count - 1;
List <ConfigurationBase> trace = new List <ConfigurationBase>(traceLen);
int count = 0;
int reverseIndex = -1;
//get trace from red stack
while (localRedStack.Count > 1)
{
LocalPair tmpRed = localRedStack.Pop();
trace.Insert(0, tmpRed.configuration);
count++;
}
//get trace from blue stack
while (localBlueStack.Count > 0)
{
LocalPair tmpBlue = localBlueStack.Pop();
trace.Insert(0, tmpBlue.configuration);
string tmpBlueID = tmpBlue.GetCompressedState();
if (s.Equals(tmpBlueID))
{
reverseIndex = count;
}
count++;
if (tmpBlue.configuration.Event == Constants.INITIAL_EVENT)
{
break;
}
}
//get global counter example and stop
lock (globalCounterExampleLocker)
{
if (isGlobalStop)
{
return;
}
finalTrace = trace;
finalLoopIndex = count - 1 - reverseIndex;
isGlobalStop = true;
}
}
// Report cycle detected at red DFS
public void localRedReportAcceptinCycle(LocalPair succ, Stack <LocalPair> blueStack, Stack <LocalPair> redStack, Dictionary <string, List <string> > outgoingTransitionTable)
{
lock (reportLocker)
{
if (isStop)
{
return;
}
Dictionary <string, LocalPair> acceptingCycle = new Dictionary <string, LocalPair>(1024);
string to = succ.GetCompressedState();
// get from redStack
while (redStack.Count > 0)
{
LocalPair tmpRed = redStack.Pop();
string tmpRedID = tmpRed.GetCompressedState();
acceptingCycle.Add(tmpRedID, tmpRed);
}
// pop the top of blueStack
LocalPair topBlueStack = blueStack.Pop();
string topBlueStackID = topBlueStack.GetCompressedState();
if (!topBlueStackID.Equals(to))
{
LocalPair tmpBlue = blueStack.Pop();
string tmpBlueID = tmpBlue.GetCompressedState();
while (!tmpBlueID.Equals(to))
{
acceptingCycle.Add(tmpBlueID, tmpBlue);
tmpBlue = blueStack.Pop();
tmpBlueID = tmpBlue.GetCompressedState();
}
acceptingCycle.Add(tmpBlueID, tmpBlue);
}
// get final result
finalLocalTaskStack = blueStack;
finalAcceptingCycle = acceptingCycle;
finalOutgoingTransitionTable = outgoingTransitionTable;
isStop = true;
}
}
private Dictionary <string, LocalPair> IsEventWeakFair(Dictionary <string, LocalPair> StronglyConnectedComponents)
{
List <string> AlwaysEnabled = null; //for weak-fair annotation.
HashSet <string> EngagedEvents = new HashSet <string>();
EngagedEvents.Add(Constants.TAU);
foreach (KeyValuePair <string, LocalPair> value in StronglyConnectedComponents)
{
//string componet = value.Key;
LocalPair componetStep = value.Value;
if (!EngagedEvents.Contains(componetStep.configuration.Event) && (StronglyConnectedComponents.Count > 1 || !componetStep.configuration.IsDeadLock)) //componetStep.Event != Constants.TERMINATION &&
{
EngagedEvents.Add(componetStep.configuration.Event);
}
if (AlwaysEnabled == null)
{
AlwaysEnabled = new List <string>();
AlwaysEnabled.AddRange(componetStep.Enabled);
}
else if (AlwaysEnabled.Count > 0)
{
AlwaysEnabled = Ultility.Ultility.Intersect(AlwaysEnabled, componetStep.Enabled);
}
}
//discard the SCC if there exists an event which is always enabled but never engaged.
for (int j = 0; j < AlwaysEnabled.Count; j++)
{
string s = AlwaysEnabled[j];
if (!EngagedEvents.Contains(s))
{
return(null);
}
}
return(StronglyConnectedComponents);
//FairSCC = StronglyConnectedComponents;
//return true;
}
// Report accepting cycle in blue DFS
private void blueReportAcceptinCycle(LocalPair succ, Stack <LocalPair> blueStack, Dictionary <string, Color> colorData, Dictionary <string, List <string> > outgoingTransitionTable)
{
Dictionary <string, LocalPair> acceptingCycle = new Dictionary <string, LocalPair>(1024);
string to = succ.GetCompressedState();
// get accepting cycle
LocalPair tmp = blueStack.Pop();
string tmpID = tmp.GetCompressedState();
while (!tmpID.Equals(to))
{
acceptingCycle.Add(tmpID, tmp);
tmp = blueStack.Pop();
tmpID = tmp.GetCompressedState();
}
acceptingCycle.Add(tmpID, tmp);
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
VerificationOutput.NoOfStates = colorData.Count;
LocalTaskStack = blueStack;
LocalGetCounterExample(acceptingCycle, outgoingTransitionTable);
}
/// <summary>
/// Get counter example in case of deadlock
/// </summary>
/// <param name="callStack"></param>
/// <param name="dfsData"></param>
public void GetDeadlockCounterExample(Stack <LocalPair> callStack, Dictionary <string, int[]> dfsData)
{
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
VerificationOutput.NoOfStates = dfsData.Count;
int traceLen = callStack.Count;
List <ConfigurationBase> trace = new List <ConfigurationBase>(traceLen);
int count = 0;
while (callStack.Count > 0)
{
LocalPair tmp = callStack.Pop();
trace.Insert(0, tmp.configuration);
string tmpID = tmp.GetCompressedState();
count++;
if (tmp.configuration.Event == Constants.INITIAL_EVENT)
{
break;
}
}
VerificationOutput.CounterExampleTrace = trace;
}
// Report cycle detected at blue DFS
public void ReportBlueCycle(LocalPair step, LocalPair pair, Stack <LocalPair> BlueStack, StringDictionary <StateColor> colorData, Dictionary <string, List <string> > OutgoingTransitionTable)
{
Dictionary <string, LocalPair> LoopPairs = new Dictionary <string, LocalPair>(1024);
string tmp = step.GetCompressedState();
string v = pair.GetCompressedState();
LocalPair node = BlueStack.Pop();
string nodeID = node.GetCompressedState();
while (!nodeID.Equals(tmp))
{
LoopPairs.Add(nodeID, node);
node = BlueStack.Pop();
nodeID = node.GetCompressedState();
}
LoopPairs.Add(nodeID, node);
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
VerificationOutput.NoOfStates = colorData.Count;
LocalTaskStack = BlueStack;
LocalGetCounterExample(LoopPairs, OutgoingTransitionTable);
}
private void reportAcceptingCycle(LocalPair succ, Stack <LocalPair> callStack, Dictionary <string, int[]> dfsData, Dictionary <string, List <string> > outgoingTransitionTable)
{
Dictionary <string, LocalPair> acceptingCycle = new Dictionary <string, LocalPair>(1024);
// string from = pair.GetCompressedState();
string to = succ.GetCompressedState();
// get states in the cycle
LocalPair tmp = callStack.Pop();
string tmpID = tmp.GetCompressedState();
while (!tmpID.Equals(to))
{
acceptingCycle.Add(tmpID, tmp);
tmp = callStack.Pop();
tmpID = tmp.GetCompressedState();
}
acceptingCycle.Add(tmpID, tmp);
// get the path to accepting cycle
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
VerificationOutput.NoOfStates = dfsData.Count;
LocalTaskStack = callStack;
LocalGetCounterExample(acceptingCycle, outgoingTransitionTable);
}
private Dictionary <string, LocalPair> IsGlobalFair(Dictionary <string, LocalPair> StronglyConnectedComponents, Dictionary <string, List <string> > OutgoingTransitionTable)
{
//for (int i = 0; i < StronglyConnectedComponents.Count; i++)
foreach (KeyValuePair <string, LocalPair> value in StronglyConnectedComponents)
{
string componet = value.Key;
LocalPair pair = value.Value;
List <string> nextStates = OutgoingTransitionTable[componet];
foreach (string nextID in pair.Enabled)
{
bool found = false;
foreach (string state in nextStates)
{
if (StronglyConnectedComponents.ContainsKey(state))
{
if (StronglyConnectedComponents[state].configuration.GetIDWithEvent() == nextID)
{
found = true;
break;
}
}
}
if (!found)
{
return(null);
}
}
}
return(StronglyConnectedComponents);
//return true;
}
/// <summary>
/// Red DFS
/// </summary>
/// <param name="acceptingState"></param>
/// <param name="blueStack"></param>
/// <param name="dfsColor"></param>
/// <returns></returns>
public bool RedDFS(LocalPair acceptingState, Stack<LocalPair> blueStack, Dictionary<string, Color> dfsColor, Dictionary<string, List<LocalPair>> expendedNodes, Random rand)
{
Stack<LocalPair> redStack = new Stack<LocalPair>(5000);
//push accepting state to red stack
redStack.Push(acceptingState);
//start loop
while (redStack.Count > 0)
{
//cancel if take long time
if (CancelRequested)
{
VerificationOutput.NoOfStates = dfsColor.Count;
return false;
}
//get top of red stack
LocalPair pair = redStack.Peek();
string v = pair.GetCompressedState();
//get successors
List<LocalPair> successors = expendedNodes[v];
//check if there is cyan successor
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
Color wColor = dfsColor[w];
if (wColor.isCyan())
{
//REPORT COUNTEREXAMPLE
GetLoopCounterExample(w, blueStack, redStack, dfsColor);
return true;
}
}
//find a blue successor
List<int> unvisitedIndexs = new List<int>(successors.Count);//not visited
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
Color wColor = dfsColor[w];
if (wColor.isBlue())
{
unvisitedIndexs.Add(i);
}
}
//choose randome successor
if (unvisitedIndexs.Count > 0)
{
int r = rand.Next(unvisitedIndexs.Count);
LocalPair succ = successors[unvisitedIndexs[r]];
string w = succ.GetCompressedState();
Color wColor = dfsColor[w];
wColor.setPink();
redStack.Push(succ);
}
else
{
redStack.Pop();
}
}
return false;
}
/// <summary>
/// Local Tarjan in each thread to find SCC
/// </summary>
/// <param name="o"></param>
public void LocalImprovedFairTarjan(object o)
{
//order of this thread
int order = (int)o;
Random rand = new Random(order);
//on-the-fly data
Stack <LocalPair> localCallStack = new Stack <LocalPair>(5000);
Stack <LocalPair> localCurrentStack = new Stack <LocalPair>(1024);
Stack <LocalPair> localGoalStack = new Stack <LocalPair>(256);
Dictionary <string, int[]> localDFSNumber = new Dictionary <string, int[]>(5000);
int localNumber = 0;
Dictionary <string, List <LocalPair> > localExpendedNodes = new Dictionary <string, List <LocalPair> >(5000);
//initial states
List <LocalPair> initialStates = LocalPair.GetInitialPairsLocal(BA, InitialStep);
//check valid result
if (initialStates.Count == 0 || !BA.HasAcceptState)
{
return;
}
//push local initial states to local call stack
int[] localPerm = Permutation(initialStates.Count, rand);
for (int i = 0; i < initialStates.Count; i++)
{
LocalPair tmp = initialStates[localPerm[i]];
localCallStack.Push(tmp);
}
//start loop
while (localCallStack.Count > 0)
{
//cancel if take long time
if (CancelRequested || isGlobalStop)
{
return;
}
//get top of call stack
LocalPair pair = localCallStack.Peek();
ConfigurationBase LTSState = pair.configuration;
string BAState = pair.state;
string v = pair.GetCompressedState();
//get successors
List <LocalPair> successors = null;
if (localExpendedNodes.ContainsKey(v))
{
successors = localExpendedNodes[v];
}
else
{
IEnumerable <ConfigurationBase> nextLTSStates = LTSState.MakeOneMove();
pair.SetEnabled(nextLTSStates, FairnessType);
successors = LocalPair.NextLocal(BA, nextLTSStates, BAState);
localExpendedNodes.Add(v, successors);
}
//if v is not number yet
if (!localDFSNumber.ContainsKey(v))
{
//number v
int[] vData = new int[] { localNumber, localNumber };
localDFSNumber.Add(v, vData);
localNumber = localNumber + 1;
//push to currentStack
localCurrentStack.Push(pair);
//check whether v is accepting
if (pair.state.EndsWith(Constants.ACCEPT_STATE))
{
localGoalStack.Push(pair);
}
//update lowlink for already numbered successors
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
if (localDFSNumber.ContainsKey(w))
{
int[] wData = localDFSNumber[w];
//if w is in current stack
if (wData[0] >= 0)
{
vData[1] = Math.Min(vData[1], wData[0]);
//check for report accepting cycle
if (localGoalStack.Count > 0 && vData[1] <= localDFSNumber[localGoalStack.Peek().GetCompressedState()][0])
{
//------------------------------------
//get SCC
Dictionary <string, LocalPair> newSCC = new Dictionary <string, LocalPair>();
Dictionary <string, List <string> > newOutgoingTransitionTable = new Dictionary <string, List <string> >();
LocalPair[] callArray = localCallStack.ToArray();
for (int j = 0; j < callArray.Length; j++)
{
LocalPair state = callArray[i];
string stateID = state.GetCompressedState();
newSCC.Add(stateID, state);
List <string> outgoing = new List <string>(8);
List <LocalPair> nextStates = localExpendedNodes[stateID];
foreach (LocalPair next in nextStates)
{
string nextID = next.GetCompressedState();
outgoing.Add(nextID);
}
newOutgoingTransitionTable.Add(stateID, outgoing);
if (stateID.Equals(w))
{
break;
}
}
Dictionary <string, LocalPair> fairSCC = IsFair(newSCC, newOutgoingTransitionTable);
if (fairSCC != null)
{
//REPORT COUNTEREXAMPLE
GetLocalLoopCounterExample(w, localCallStack);
return;
}
return;
}
}
}
}
}
//------------------------------------------------------------------------
//filter successors
List <int> unvisitedIndexs = new List <int>(successors.Count);//not numbered and not global found
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
//if w is not cyan and not global red
if (!localDFSNumber.ContainsKey(w) && !globalFoundSCCs.ContainsKey(w))
{
unvisitedIndexs.Add(i);
}
}
//------------------------------------------------------------------------
//get random unvisited successors
if (unvisitedIndexs.Count > 0)
{
bool isFresh = false;
List <int> unFreshIndexs = new List <int>();
while (unvisitedIndexs.Count > 0)
{
int r = rand.Next(unvisitedIndexs.Count);
LocalPair succ = successors[unvisitedIndexs[r]];
string w = succ.GetCompressedState();
//if w is fresh successor
if (!allVisitedStates.ContainsKey(w))
{
localCallStack.Push(succ);
allVisitedStates.GetOrAdd(w, 0);
allVisitedStates[w]++;
isFresh = true;
break;
}
else
{
unFreshIndexs.Add(unvisitedIndexs[r]);
unvisitedIndexs.RemoveAt(r);
}
}
if (!isFresh)
{
int r = rand.Next(unFreshIndexs.Count);
LocalPair succ = successors[unFreshIndexs[r]];
string w = succ.GetCompressedState();
localCallStack.Push(succ);
allVisitedStates.GetOrAdd(w, 0);
allVisitedStates[w]++;
}
}
else
{
//update global
globalFoundSCCs.GetOrAdd(v, true);
int[] vData = localDFSNumber[v];
//if v is root
if (vData[0] == vData[1])
{
// check selfLoop
bool selfLoop = false;
foreach (LocalPair succ in successors)
{
string w = succ.GetCompressedState();
if (v.Equals(w))
{
selfLoop = true;
break;
}
}
//remove states from current stack and goal stack
//updata global
bool isBuchiFair = false;
Dictionary <string, LocalPair> newSCC = new Dictionary <string, LocalPair>(1024);
List <ConfigurationBase> cycle = new List <ConfigurationBase>(1024);
LocalPair tmp = null;
string tmpID = null;
do
{
//get states in SCC
tmp = localCurrentStack.Pop();
if (!isBuchiFair && tmp.state.EndsWith(Constants.ACCEPT_STATE))
{
isBuchiFair = true;
}
tmpID = tmp.GetCompressedState();
newSCC.Add(tmpID, tmp);
cycle.Insert(0, tmp.configuration);
//local
localDFSNumber[tmpID][0] = SCC_FOUND;
} while (tmp != pair);
//local check fairness
if (isBuchiFair && (selfLoop || newSCC.Count > 1 || LTSState.IsDeadLock))
{
//------------------------------------
//get outgoing transition table
Dictionary <string, List <string> > outgoingTransitionTable = new Dictionary <string, List <string> >(newSCC.Count);
foreach (KeyValuePair <string, LocalPair> kv in newSCC)
{
string s = kv.Key;
List <LocalPair> nextStates = localExpendedNodes[s];
List <string> outgoing = new List <string>(nextStates.Count);
foreach (LocalPair next in nextStates)
{
string n = next.GetCompressedState();
outgoing.Add(n);
}
outgoingTransitionTable.Add(s, outgoing);
}
//------------------------------------
Dictionary <string, LocalPair> fairSCC = IsFair(newSCC, outgoingTransitionTable);
if (fairSCC != null)
{
//REPORT COUNTEREXAMPLE
GetLocalFairCounterExample(localCallStack, cycle, LTSState.IsDeadLock);
return;
}
}
//pop call stack
localCallStack.Pop();
}
else
{
//pop call stack and update lowlink of top
LocalPair pop = localCallStack.Pop();
LocalPair top = localCallStack.Peek();
string popID = pop.GetCompressedState();
string topID = top.GetCompressedState();
int[] popData = localDFSNumber[popID];
int[] topData = localDFSNumber[topID];
topData[1] = Math.Min(topData[1], popData[1]);
}
}
}
}
/// <summary>
/// Improved Nested DFS
/// A Note on On-The-Fly Verification Algorithms - TACAS 2005
/// Blue DFS
/// </summary>
public void BlueDFS()
{
VerificationOutput.CounterExampleTrace = null;
//on-the-fly data
Stack <LocalPair> blueStack = new Stack <LocalPair>(5000);
Dictionary <string, Color> dfsColor = new Dictionary <string, Color>(5000);
Dictionary <string, List <LocalPair> > expendedNodes = new Dictionary <string, List <LocalPair> >(5000);
//initial states
List <LocalPair> initialStates = LocalPair.GetInitialPairsLocal(BA, InitialStep);
//check valid result
if (initialStates.Count == 0 || !BA.HasAcceptState)
{
VerificationOutput.VerificationResult = VerificationResultType.VALID;
return;
}
//push initial states to call stack
foreach (LocalPair tmp in initialStates)
{
blueStack.Push(tmp);
}
//start loop
while (blueStack.Count > 0)
{
//cancel if take long time
if (CancelRequested)
{
VerificationOutput.NoOfStates = dfsColor.Count;
return;
}
//get top of call stack
LocalPair pair = blueStack.Peek();
ConfigurationBase LTSState = pair.configuration;
string BAState = pair.state;
string v = pair.GetCompressedState();
//get successors
List <LocalPair> successors = null;
if (expendedNodes.ContainsKey(v))
{
successors = expendedNodes[v];
}
else
{
IEnumerable <ConfigurationBase> nextLTSStates = LTSState.MakeOneMove();
pair.SetEnabled(nextLTSStates, FairnessType);
successors = LocalPair.NextLocal(BA, nextLTSStates, BAState);
expendedNodes.Add(v, successors);
}
//if v is white
if (!dfsColor.ContainsKey(v))
{
//set v cyan
Color vColor = new Color();
vColor.setCyan();
dfsColor.Add(v, vColor);
//early cycle detection
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
//if w is cyan and (v or w is accepting)
if (dfsColor.ContainsKey(w))
{
Color wColor = dfsColor[w];
if (wColor.isCyan() && (succ.state.EndsWith(Constants.ACCEPT_STATE) || pair.state.EndsWith(Constants.ACCEPT_STATE)))
{
//REPORT COUNTEREXAMPLE
GetLoopCounterExample(w, blueStack, dfsColor);
return;
}
}
}
}
//check if there is an unnumbered successor
bool isBlueCompleted = true;
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
//if w is white
if (!dfsColor.ContainsKey(w))
{
blueStack.Push(succ);
isBlueCompleted = false;
break;
}
}
//if there is no unnumbered successor
if (isBlueCompleted)
{
Color vColor = dfsColor[v];
//if v is accepting
if (pair.state.EndsWith(Constants.ACCEPT_STATE))
{
//if v is deadlock
if (LTSState.IsDeadLock)
{
//REPORT COUNTEREXAMPLE
GetDeadlockCounterExample(blueStack, dfsColor);
return;
}
else
{
bool stop = RedDFS(pair, blueStack, dfsColor, expendedNodes);
if (stop)
{
return;
}
}
//set v pink
vColor.setPink();
}
else
{
vColor.setBlue();
}
//pop blue stack
blueStack.Pop();
}
}
//no counter example
VerificationOutput.VerificationResult = VerificationResultType.VALID;
VerificationOutput.NoOfStates = dfsColor.Count;
return;
}
/// <summary>
/// Red DFS
/// </summary>
/// <param name="acceptingState"></param>
/// <param name="blueStack"></param>
/// <param name="dfsColor"></param>
/// <returns></returns>
public bool RedDFS(LocalPair acceptingState, Stack <LocalPair> blueStack, Dictionary <string, Color> dfsColor, Dictionary <string, List <LocalPair> > expendedNodes)
{
Stack <LocalPair> redStack = new Stack <LocalPair>(5000);
//push accepting state to red stack
redStack.Push(acceptingState);
//start loop
while (redStack.Count > 0)
{
//cancel if take long time
if (CancelRequested)
{
VerificationOutput.NoOfStates = dfsColor.Count;
return(false);
}
//get top of red stack
LocalPair pair = redStack.Peek();
string v = pair.GetCompressedState();
//get successors
List <LocalPair> successors = expendedNodes[v];
//check if there is cyan successor
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
Color wColor = dfsColor[w];
if (wColor.isCyan())
{
//REPORT COUNTEREXAMPLE
GetLoopCounterExample(w, blueStack, redStack, dfsColor);
return(true);
}
}
//find a blue successor
bool isRedCompleted = true;
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
Color wColor = dfsColor[w];
if (wColor.isBlue())
{
wColor.setPink();
redStack.Push(succ);
isRedCompleted = false;
break;
}
}
//all successor are pink
if (isRedCompleted)
{
redStack.Pop();
}
}
return(false);
}
private void localReportAcceptingCycle(LocalPair succ, Stack<LocalPair> callStack, StringDictionary<int[]> dfsData, Dictionary<string, List<string>> outgoingTransitionTable)
{
//set flag to stop other processes
lock (MultiCoreLock)
{
StopMutliCoreThreads = true;
Dictionary<string, LocalPair> localAcceptingCycle = new Dictionary<string, LocalPair>(1024);
string to = succ.GetCompressedState();
//get states in the cycle
LocalPair tmp = callStack.Pop();
string tmpID = tmp.GetCompressedState();
while (!tmpID.Equals(to))
{
localAcceptingCycle.Add(tmpID, tmp);
tmp = callStack.Pop();
tmpID = tmp.GetCompressedState();
}
localAcceptingCycle.Add(tmpID, tmp);
//return the result for global multi-core
MultiCoreLocalTaskStack = callStack;
MultiCoreResultedLoop = localAcceptingCycle;
MultiCoreOutgoingTransitionTable = outgoingTransitionTable;
}
}
/// <summary>
/// Local red DFS in each thread
/// </summary>
/// <param name="rSet"></param>
/// <param name="acceptingState"></param>
/// <param name="localBlueStack"></param>
/// <param name="localCyanData"></param>
/// <param name="rand"></param>
/// <returns></returns>
public bool LocalRed2(Dictionary<LocalPair, bool> rSet, LocalPair acceptingState, Stack<LocalPair> localBlueStack, Dictionary<string, bool> localCyanData, Random rand, Dictionary<string, List<LocalPair>> localExpendedNodes)
{
Stack<LocalPair> localRedStack = new Stack<LocalPair>(5000);
Dictionary<string, bool> inRSet = new Dictionary<string, bool>(1024);
//push accepting state to red stack
localRedStack.Push(acceptingState);
//start loop
while (localRedStack.Count > 0)
{
//cancel if take long time
if (CancelRequested || isGlobalStop)
{
return false;
}
//get top of red stack
LocalPair pair = localRedStack.Peek();
ConfigurationBase LTSState = pair.configuration;
string BAState = pair.state;
string v = pair.GetCompressedState();
//get successors
//v may not in expendedNodes
List<LocalPair> successors = null;
if (localExpendedNodes.ContainsKey(v))
{
successors = localExpendedNodes[v];
}
else
{
IEnumerable<ConfigurationBase> nextLTSStates = LTSState.MakeOneMove();
pair.SetEnabled(nextLTSStates, FairnessType);
successors = LocalPair.NextLocal(BA, nextLTSStates, BAState);
localExpendedNodes.Add(v, successors);
}
//if v not in R set
if (!inRSet.ContainsKey(v))
{
//add v to R
rSet.Add(pair, true);
inRSet.Add(v, true);
//check if there is cyan successor
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
if (localCyanData.ContainsKey(w) && localCyanData[w])
{
//REPORT COUNTER EXAMPLE
GetLocalLoopCounterExample(w, localBlueStack, localRedStack);
return true;
}
}
}
//------------------------------------------------------------------------
//filter successors
List<int> unvisitedIndexs = new List<int>(successors.Count);//not in and not global red
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
//if w is white and not global red
if (!inRSet.ContainsKey(w) && !globalBlueRedStates[w])
{
unvisitedIndexs.Add(i);
}
}
//------------------------------------------------------------------------
//get random unvisited successors
if (unvisitedIndexs.Count > 0)
{
int r = rand.Next(unvisitedIndexs.Count);
LocalPair succ = successors[unvisitedIndexs[r]];
localRedStack.Push(succ);
}
else
{
localRedStack.Pop();
}
}
//cannot report counter example
return false;
}
/// <summary>
/// Local red DFS in each thread
/// </summary>
/// <param name="acceptingState"></param>
/// <param name="localBlueStack"></param>
/// <param name="localDFSColor"></param>
/// <param name="rand"></param>
/// <returns></returns>
public bool LocalRedSwarm(LocalPair acceptingState, Stack <LocalPair> localBlueStack, Dictionary <string, Color> localDFSColor, Random rand, Dictionary <string, List <LocalPair> > localExpendedNodes)
{
Stack <LocalPair> localRedStack = new Stack <LocalPair>(5000);
//push accepting state to red stack
localRedStack.Push(acceptingState);
//start loop
while (localRedStack.Count > 0)
{
//cancel if take long time
if (CancelRequested || isGlobalStop)
{
return(false);
}
//get top of red stack
LocalPair pair = localRedStack.Peek();
string v = pair.GetCompressedState();
//get successors
List <LocalPair> successors = localExpendedNodes[v];
//check if there is cyan successor
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
Color wColor = localDFSColor[w];
if (wColor.isCyan())
{
//REPORT COUNTEREXAMPLE
GetLocalLoopCounterExample(w, localBlueStack, localRedStack);
return(true);
}
}
//find a blue successor
List <int> unvisitedIndexs = new List <int>(successors.Count);//not visited
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
Color wColor = localDFSColor[w];
if (wColor.isBlue())
{
unvisitedIndexs.Add(i);
}
}
//choose randome successor
if (unvisitedIndexs.Count > 0)
{
int r = rand.Next(unvisitedIndexs.Count);
LocalPair succ = successors[unvisitedIndexs[r]];
string w = succ.GetCompressedState();
Color wColor = localDFSColor[w];
wColor.setPink();
localRedStack.Push(succ);
}
else
{
localRedStack.Pop();
}
}
//cannot report counter example
return(false);
}
// Report cycle detected at blue DFS
public void SwarmNestedDFSReportBlueCycle(LocalPair step, LocalPair pair, Stack<LocalPair> BlueStack, Dictionary<string, StateColor> colorData, Dictionary<string, List<string>> OutgoingTransitionTable)
{
lock (MultiCoreLock)
{
StopMutliCoreThreads = true;
Dictionary<string, LocalPair> LoopPairs = new Dictionary<string, LocalPair>(1024);
string tmp = step.GetCompressedState();
string m = pair.GetCompressedState();
LocalPair node = BlueStack.Pop();
string nodeID = node.GetCompressedState();
while (!nodeID.Equals(tmp))
{
LoopPairs.Add(nodeID, node);
node = BlueStack.Pop();
nodeID = node.GetCompressedState();
}
LoopPairs.Add(nodeID, node);
MultiCoreLocalTaskStack = BlueStack;
MultiCoreResultedLoop = LoopPairs;
MultiCoreOutgoingTransitionTable = OutgoingTransitionTable;
}
}
/// <summary>
/// The local function of each process running Improved MultiCore Tarjan algorithm
/// </summary>
/// <returns></returns>
public void localImprovedTarjanGeldenhuysValmari()
{
//local data for on-the-fly and Tarjan algorithm
Dictionary <string, List <string> > outgoingTransitionTable = new Dictionary <string, List <string> >(Ultility.Ultility.MC_INITIAL_SIZE);
StringDictionary <int[]> dfsData = new StringDictionary <int[]>(5000);
Dictionary <string, List <LocalPair> > expendedNodes = new Dictionary <string, List <LocalPair> >(1024);
Stack <LocalPair> callStack = new Stack <LocalPair>(5000);
Stack <LocalPair> currentStack = new Stack <LocalPair>(1024);
int counter = 0;
string goal = null;
int[] goalData = new int[2] {
-2, 0
};
//--------------------------
//create initial states
List <LocalPair> initialStates = LocalPair.GetInitialPairsLocal(BA, InitialStep);
if (initialStates.Count == 0 || !BA.HasAcceptState)
{
VerificationOutput.VerificationResult = VerificationResultType.VALID;
return;
}
//create random variable for each process
Random rand = null;
lock (MultiCoreLock)
{
rand = new Random(MultiCoreSeed);
MultiCoreSeed++;
}
//put all initial states to callStack in different order & init data
int[] initPermutation = generatePermutation(initialStates.Count, rand);
for (int i = 0; i < initPermutation.Length; i++)
{
//get data from initialStates
LocalPair tmp = initialStates[initPermutation[i]];
callStack.Push(tmp);
string tmpID = tmp.GetCompressedState();
dfsData.Add(tmpID, new int[] { VISITED_NOPREORDER, 0 });
outgoingTransitionTable.Add(tmpID, new List <string>(8));
}
//start loop
while (callStack.Count > 0)
{
//cancel if too long action
if (CancelRequested || StopMutliCoreThreads)
{
return;
}
//get the top of callStack
LocalPair pair = callStack.Peek();
ConfigurationBase LTSState = pair.configuration;
string BAState = pair.state;
string v = pair.GetCompressedState();
//get local data of the top
List <string> outgoing = outgoingTransitionTable[v];
int[] vData = dfsData.GetContainsKey(v);
//if not expended then expend to next states from v
if (!expendedNodes.ContainsKey(v))
{
//create next states of v
ConfigurationBase[] nextLTSStates = LTSState.MakeOneMove();
pair.SetEnabled(nextLTSStates, FairnessType);
List <LocalPair> nextStates = LocalPair.NextLocal(BA, nextLTSStates, BAState);
expendedNodes.Add(v, nextStates);
//update outgoing of v and set initial data for successors
//no need to use inverse for statement and use nextStates
foreach (LocalPair next in nextStates)
{
string w = next.GetCompressedState();
outgoing.Add(w);
if (!dfsData.ContainsKey(w))
{
dfsData.Add(w, new int[] { VISITED_NOPREORDER, 0 });
outgoingTransitionTable.Add(w, new List <string>(8));
}
}
}
//get successors of v
List <LocalPair> successors = expendedNodes[v];
//process if v is not numbered yet
if (vData[0] == VISITED_NOPREORDER)
{
vData[0] = counter;
vData[1] = counter;
counter = counter + 1;
//push to currentStack
currentStack.Push(pair);
//check whether v is accepting
if (pair.state.EndsWith(Constants.ACCEPT_STATE))
{
goal = v;
goalData = vData;
}
//update lowlink according to successors in currentStack
//remove already visited successors
//no need random because consider all successors
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
int[] wData = dfsData.GetContainsKey(w);
if (wData[0] >= 0 && !foundSCCTarjanGeldenhuysValmari.ContainsKey(w))
{
//update & remove from expendedNodes(v)
vData[1] = Math.Min(vData[1], wData[0]);
successors.RemoveAt(i);
//check for report accepting cycle
if (vData[1] <= goalData[0])
{
//REPORT COUNTEREXAMPLE
localReportAcceptingCycle(succ, callStack, dfsData, outgoingTransitionTable);
return;
}
}
}
}
//check if there is any successor not numbered & not visited by other threads
//choose random
bool completed = true;
LocalPair firstUnnumbered = null;
for (int i = successors.Count - 1; i >= 0; i--)
{
int randIndex = rand.Next(successors.Count);
LocalPair succ = successors[randIndex];
string w = succ.GetCompressedState();
int[] wData = dfsData.GetContainsKey(w);
//only check states not in foundSCCTarjanGeldenhuysValmari
if (wData[0] == VISITED_NOPREORDER && !foundSCCTarjanGeldenhuysValmari.ContainsKey(w))
{
completed = false;
firstUnnumbered = succ;
successors.RemoveAt(randIndex);
break;
}
else
{
successors.RemoveAt(randIndex);
}
}
// if there at least one unnumbered successor
if (!completed)
{
callStack.Push(firstUnnumbered);
}
else //all successors are numbered
{
//check for loop at an accepting & deadlock state
if (LTSState.IsDeadLock && pair.state.EndsWith(Constants.ACCEPT_STATE))
{
//report AcceptingCycle
localReportAcceptingCycle(pair, callStack, dfsData, outgoingTransitionTable);
return;
}
if (vData[0] == vData[1])
{
//find the root -> mark as local and global for all processes
LocalPair tmp = null;
string tmpID = null;
//pop currentStack and update SCC_FOUND and add to global memory until v
do
{
//local
tmp = currentStack.Pop();
tmpID = tmp.GetCompressedState();
int[] tmpData = dfsData.GetContainsKey(tmpID);
tmpData[0] = SCC_FOUND;
//global
foundSCCTarjanGeldenhuysValmari.GetOrAdd(tmpID, true);
} while (!tmpID.Equals(v));
//pop callStack
callStack.Pop();
}
else
{
//pop callStack & update the parent
LocalPair pop = callStack.Pop();
LocalPair top = callStack.Peek();
string popID = pop.GetCompressedState();
string topID = top.GetCompressedState();
int[] popData = dfsData.GetContainsKey(popID);
int[] topData = dfsData.GetContainsKey(topID);
topData[1] = Math.Min(topData[1], popData[1]);
}
}
}
}
/// <summary>
/// Tarjan algorithm with farness checking
/// </summary>
public void FairTarjan()
{
VerificationOutput.CounterExampleTrace = null;
//on-the-fly data
Stack <LocalPair> callStack = new Stack <LocalPair>(5000);
Stack <LocalPair> currentStack = new Stack <LocalPair>(5000);
Stack <LocalPair> goalStack = new Stack <LocalPair>(1024);
Dictionary <string, int[]> dfsNumber = new Dictionary <string, int[]>(5000);
Dictionary <string, List <LocalPair> > expendedNodes = new Dictionary <string, List <LocalPair> >(5000);
int number = 0;
Random rand = new Random();
//initial states
List <LocalPair> initialStates = LocalPair.GetInitialPairsLocal(BA, InitialStep);
//check valid result
if (initialStates.Count == 0 || !BA.HasAcceptState)
{
VerificationOutput.VerificationResult = VerificationResultType.VALID;
return;
}
//push initial states to call stack
foreach (LocalPair tmp in initialStates)
{
callStack.Push(tmp);
}
//start loop
while (callStack.Count > 0)
{
//cancel if take long time
if (CancelRequested)
{
VerificationOutput.NoOfStates = dfsNumber.Count;
return;
}
//get top of call stack
LocalPair pair = callStack.Peek();
ConfigurationBase LTSState = pair.configuration;
string BAState = pair.state;
string v = pair.GetCompressedState();
//get successors
List <LocalPair> successors = null;
if (expendedNodes.ContainsKey(v))
{
successors = expendedNodes[v];
}
else
{
IEnumerable <ConfigurationBase> nextLTSStates = LTSState.MakeOneMove();
pair.SetEnabled(nextLTSStates, FairnessType);
successors = LocalPair.NextLocal(BA, nextLTSStates, BAState);
expendedNodes.Add(v, successors);
}
//if v is not number yet
if (!dfsNumber.ContainsKey(v))
{
//number v
int[] vData = new int[] { number, number };
dfsNumber.Add(v, vData);
number = number + 1;
//push to currentStack
currentStack.Push(pair);
//update lowlink for already numbered successors
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
//if w is already numbered
if (dfsNumber.ContainsKey(w))
{
int[] wData = dfsNumber[w];
//if w is in current stack
if (wData[0] >= 0)
{
vData[1] = Math.Min(vData[1], wData[0]);
}
}
}
}
//------------------------------------------------------------------------
//check if there is an unnumbered successor
List <int> unvisitedIndexs = new List <int>(successors.Count);//not visited
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
//if w is not already numbered
if (!dfsNumber.ContainsKey(w))
{
unvisitedIndexs.Add(i);
}
}
//------------------------------------------------------------------------
//get random unvisited successors
if (unvisitedIndexs.Count > 0)
{
int r = rand.Next(unvisitedIndexs.Count);
LocalPair succ = successors[unvisitedIndexs[r]];
callStack.Push(succ);
}
else
{
int[] vData = dfsNumber[v];
//if v is root
if (vData[0] == vData[1])
{
// check selfLoop
bool selfLoop = false;
foreach (LocalPair succ in successors)
{
string w = succ.GetCompressedState();
if (v.Equals(w))
{
selfLoop = true;
break;
}
}
//remove states from current stack and goal stack
Dictionary <string, LocalPair> newSCC = new Dictionary <string, LocalPair>(1024);
List <ConfigurationBase> cycle = new List <ConfigurationBase>(1024);
bool isBuchiFair = false;
LocalPair tmp = null;
string tmpID = null;
do
{
//current stack
tmp = currentStack.Pop();
if (!isBuchiFair && tmp.state.EndsWith(Constants.ACCEPT_STATE))
{
isBuchiFair = true;
}
tmpID = tmp.GetCompressedState();
newSCC.Add(tmpID, tmp);
cycle.Insert(0, tmp.configuration);
//mark visited
dfsNumber[tmpID][0] = SCC_FOUND;
} while (tmp != pair);
//check fairness
if (isBuchiFair && (selfLoop || newSCC.Count > 1 || LTSState.IsDeadLock))
{
//get outgoing transition table
Dictionary <string, List <string> > outgoingTransitionTable = new Dictionary <string, List <string> >(newSCC.Count);
foreach (KeyValuePair <string, LocalPair> kv in newSCC)
{
string s = kv.Key;
List <LocalPair> nextStates = expendedNodes[s];
List <string> outgoing = new List <string>(nextStates.Count);
foreach (LocalPair next in nextStates)
{
string n = next.GetCompressedState();
outgoing.Add(n);
}
outgoingTransitionTable.Add(s, outgoing);
}
Dictionary <string, LocalPair> fairSCC = IsFair(newSCC, outgoingTransitionTable);
if (fairSCC != null)
{
//REPORT COUNTEREXAMPLE
GetFairCounterExample(callStack, cycle, dfsNumber, LTSState.IsDeadLock);
return;
}
}
//pop call stack
callStack.Pop();
}
else
{
//pop call stack and update lowlink of top
LocalPair pop = callStack.Pop();
LocalPair top = callStack.Peek();
string popID = pop.GetCompressedState();
string topID = top.GetCompressedState();
int[] popData = dfsNumber[popID];
int[] topData = dfsNumber[topID];
topData[1] = Math.Min(topData[1], popData[1]);
}
}
}
//no counter example
VerificationOutput.VerificationResult = VerificationResultType.VALID;
VerificationOutput.NoOfStates = dfsNumber.Count;
return;
}
// Blue DFS
public void localBlueDFSNestedDFSSharedRed(object o)
{
// get order
int order = (int)o;
// local data for on-the-fly Nested DFS
Dictionary <string, List <string> > outgoingTransitionTable = new Dictionary <string, List <string> >(Ultility.Ultility.MC_INITIAL_SIZE);
Stack <LocalPair> blueStack = new Stack <LocalPair>(5000);
Dictionary <string, Color> colorData = new Dictionary <string, Color>(5000);
Dictionary <string, List <LocalPair> > expendedNodes = new Dictionary <string, List <LocalPair> >(1024);
// create initial states
List <LocalPair> initialStates = LocalPair.GetInitialPairsLocal(BA, InitialStep);
if (initialStates.Count == 0 || !BA.HasAcceptState)
{
return;
}
// create random variable for each thread
Random rand = new Random(order);
// push initial states to blueStack in random order & initialize data
int[] permutation = generatePermutation(initialStates.Count, rand);
for (int i = 0; i < initialStates.Count; i++)
{
LocalPair tmp = initialStates[permutation[i]];
blueStack.Push(tmp);
string ID = tmp.GetCompressedState();
colorData.Add(ID, new Color());
outgoingTransitionTable.Add(ID, new List <string>(8));
}
// start loop
while (blueStack.Count > 0)
{
// cancel if too long action or couterexample reported
if (CancelRequested || isStop)
{
return;
}
// get the top of blueStack
LocalPair pair = blueStack.Peek();
ConfigurationBase LTSState = pair.configuration;
string BAState = pair.state;
string v = pair.GetCompressedState();
// local data of the top
List <string> outgoing = outgoingTransitionTable[v];
Color vColor = colorData[v];
// if v is not expended then expend successors of v
if (!expendedNodes.ContainsKey(v))
{
// create next states from v & add to expendedNodes
IEnumerable <ConfigurationBase> nextLTSStates = LTSState.MakeOneMove();
pair.SetEnabled(nextLTSStates, FairnessType);
List <LocalPair> nextStates = LocalPair.NextLocal(BA, nextLTSStates, BAState);
expendedNodes.Add(v, nextStates);
// add to visitedTimes in this thread
//visitedTimes.GetOrAdd(v, 0);
//visitedTimes[v]++;
// update outgoing of v and set initial data for successors
// no need to use inverse for statement and use nextStates
foreach (LocalPair next in nextStates)
{
string w = next.GetCompressedState();
outgoing.Add(w);
if (!colorData.ContainsKey(w))
{
colorData.Add(w, new Color());
outgoingTransitionTable.Add(w, new List <string>(8));
}
}
}
// get successor of v
List <LocalPair> successors = expendedNodes[v];
// visit v & early accepting cycle detection
if (vColor.isWhite())
{
vColor.setCyan();
// early cycle detection
// use reverse order to remove visited states
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
Color wColor = colorData[w];
// if successor is not white then remove from expendedNodes
if (wColor.isCyan())
{
if (succ.state.EndsWith(Constants.ACCEPT_STATE) || pair.state.EndsWith(Constants.ACCEPT_STATE))
{
localBlueReportAcceptinCycle(succ, blueStack, outgoingTransitionTable);
return;
}
else
{
successors.RemoveAt(i);
}
}
}
}
// traverse all sucessors in a random order
bool blueDone = true;
for (int i = successors.Count - 1; i >= 0; i--)
{
int randIndex = rand.Next(successors.Count);
LocalPair succ = successors[randIndex];
string w = succ.GetCompressedState();
// only visite white & not red globally successors
if (colorData[w].isWhite() && !sharedRedStates.ContainsKey(w))
{
blueStack.Push(succ);
successors.RemoveAt(randIndex);
blueDone = false;
break;
}
else // remove already visited states in expendedNodes
{
successors.RemoveAt(randIndex);
}
}
// if all successors are visited by blue DFS
if (blueDone)
{
// check loop at an accepting & deadlock state
if (pair.state.EndsWith(Constants.ACCEPT_STATE) && LTSState.IsDeadLock)
{
lock (reportLocker)
{
isStop = true;
Dictionary <string, LocalPair> acceptingCycle = new Dictionary <string, LocalPair>();
acceptingCycle.Add(v, pair);
blueStack.Pop();
finalLocalTaskStack = blueStack;
finalAcceptingCycle = acceptingCycle;
finalOutgoingTransitionTable = outgoingTransitionTable;
return;
}
}
// check whether all successors of v are already red
// also right for deadlock state
bool isAllRed = true;
foreach (string w in outgoing)
{
if (!sharedRedStates.ContainsKey(w))
{
isAllRed = false;
break;
}
}
// if all sucessors are red then v also red
if (isAllRed)
{
sharedRedStates.GetOrAdd(v, true);
}
// if v is accepting states
else if (pair.state.EndsWith(Constants.ACCEPT_STATE))
{
// increase count red of v by 1
sharedAcceptingCountRedDFS.GetOrAdd(v, 0);
sharedAcceptingCountRedDFS[v]++;
// initialize red DFS at v
bool stop = localRedDFSNestedDFSSharedRed(pair, blueStack, colorData, outgoingTransitionTable, rand);
if (stop)
{
return;
}
}
// set v to blue
colorData[v].setBlue();
//pop v out of blueStack
blueStack.Pop();
}
}
VerificationOutput.VerificationResult = VerificationResultType.VALID;
return;
}
// Perform the redDFS
public bool SwarmNestedDFSDepthFirstSearchRed(LocalPair s, Stack<LocalPair> BlueStack, Dictionary<string, List<string>> OutgoingTransitionTable, Dictionary<string, StateColor> colorData)
{
//store the expended event step of a node to avoid multiple invocation of the make one move.
Dictionary<string, List<LocalPair>> ExpendedNode = new Dictionary<string, List<LocalPair>>(256);
Stack<LocalPair> RedStack = new Stack<LocalPair>(5000);
RedStack.Push(s);
do
{
if (CancelRequested || StopMutliCoreThreads)
{
return false;
}
LocalPair pair = RedStack.Peek();
string v = pair.GetCompressedState();
ConfigurationBase evt = pair.configuration;
string BAState = pair.state;
List<string> outgoing = OutgoingTransitionTable[v];
bool redDone = true;
if (!ExpendedNode.ContainsKey(v))
{
//ConfigurationBase[] list = evt.MakeOneMove().ToArray();
IEnumerable<ConfigurationBase> list = evt.MakeOneMove();
pair.SetEnabled(list, FairnessType);
List<LocalPair> product = LocalPair.NextLocal(BA, list, BAState);
ExpendedNode.Add(v, product);
}
List<LocalPair> neighbourList = ExpendedNode[v];
//transverse all neighbour nodes
for (int k = neighbourList.Count - 1; k >= 0; k--)
{
LocalPair step = neighbourList[k];
string tmp = step.GetCompressedState();
StateColor neighbourColor = colorData[tmp];
// if the neighbour node is blue
if (neighbourColor.IsBlue())
{
//only add the first unvisited node
//for the second or more unvisited steps, ignore at the monent
if (redDone)
{
neighbourColor.SetRed();
RedStack.Push(step);
redDone = true;
neighbourList.RemoveAt(k);
}
}
// if the neighbour is cyan
// report cycle
else if (neighbourColor.IsCyan())
{
SwarmNestedDFSReportRedCycle(s, step, pair, BlueStack, RedStack, colorData, OutgoingTransitionTable);
return true;
}
else
{
neighbourList.RemoveAt(k);
}
}
if (redDone)
{
RedStack.Pop();
}
} while (RedStack.Count > 0);
return false;
}
// local function of each thread
public void localQueueTarjanFairnessChecking(object o)
{
// get order
int order = (int)o;
// local data for on-the-fly and Tarjan algorithm
Dictionary <string, List <string> > outgoingTransitionTable = new Dictionary <string, List <string> >(Ultility.Ultility.MC_INITIAL_SIZE);
Stack <LocalPair> callStack = new Stack <LocalPair>(5000);
Stack <LocalPair> currentStack = new Stack <LocalPair>(1024);
Dictionary <string, int[]> dfsData = new Dictionary <string, int[]>(5000);
Dictionary <string, List <LocalPair> > expendedNodes = new Dictionary <string, List <LocalPair> >(1024);
int counter = 0;
//--------------------------
// create initial states
List <LocalPair> initialStates = LocalPair.GetInitialPairsLocal(BA, InitialStep);
if (initialStates.Count == 0 || !BA.HasAcceptState)
{
return;
}
// create random variable for each process
Random rand = new Random(order);
// push all initial states to callStack in different order & init data
int[] initPermutation = generatePermutation(initialStates.Count, rand);
for (int i = 0; i < initPermutation.Length; i++)
{
//get data from initialStates
LocalPair tmp = initialStates[initPermutation[i]];
callStack.Push(tmp);
string tmpID = tmp.GetCompressedState();
dfsData.Add(tmpID, new int[] { VISITED_NOPREORDER, 0 });
outgoingTransitionTable.Add(tmpID, new List <string>(8));
}
// start loop
while (callStack.Count > 0)
{
// cancel if too long action or any counterexample is reported
if (CancelRequested || isStop)
{
return;
}
// get the top of callStack
LocalPair pair = callStack.Peek();
ConfigurationBase LTSState = pair.configuration;
string BAState = pair.state;
string v = pair.GetCompressedState();
// get local data of the top
List <string> outgoing = outgoingTransitionTable[v];
int[] vData = dfsData[v];
// if not expended then expend to next states from v
if (!expendedNodes.ContainsKey(v))
{
// create next states of v
IEnumerable <ConfigurationBase> nextLTSStates = LTSState.MakeOneMove();
pair.SetEnabled(nextLTSStates, FairnessType);
List <LocalPair> nextStates = LocalPair.NextLocal(BA, nextLTSStates, BAState);
expendedNodes.Add(v, nextStates);
// add to visitedTimes in this thread
//visitedTimes.GetOrAdd(v, 0);
//visitedTimes[v]++;
// update outgoing of v and set initial data for successors
// no need to use inverse for statement and use nextStates
foreach (LocalPair next in nextStates)
{
string w = next.GetCompressedState();
outgoing.Add(w);
if (!dfsData.ContainsKey(w))
{
dfsData.Add(w, new int[] { VISITED_NOPREORDER, 0 });
outgoingTransitionTable.Add(w, new List <string>(8));
}
}
}
// get successors of v
List <LocalPair> successors = expendedNodes[v];
// process if v is not numbered yet
if (vData[0] == VISITED_NOPREORDER)
{
vData[0] = counter;
vData[1] = counter;
counter = counter + 1;
// push to currentStack
currentStack.Push(pair);
// update lowlink according to successors in currentStack
// remove already visited successors
// no need to use random
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
int[] wData = dfsData[w];
if (wData[0] >= 0)
{
// update & remove from expendedNodes(v)
vData[1] = Math.Min(vData[1], wData[0]);
successors.RemoveAt(i);
}
}
}
// check if there is any successor not numbered & not visited by other threads
// choose random
bool completed = true;
for (int i = successors.Count - 1; i >= 0; i--)
{
int randIndex = rand.Next(successors.Count);
LocalPair succ = successors[randIndex];
string w = succ.GetCompressedState();
int[] wData = dfsData[w];
// check states not locally visited & not in global shared found SCC
if (wData[0] == VISITED_NOPREORDER && !sharedSCCStates.ContainsKey(w))
{
callStack.Push(succ);
successors.RemoveAt(randIndex);
completed = false;
break;
}
else
{
successors.RemoveAt(randIndex);
}
}
// if all successors are visited
if (completed)
{
// check root
if (vData[0] == vData[1])
{
Dictionary <string, LocalPair> newSCC = new Dictionary <string, LocalPair>(1024);
// check selfLoop
bool selfLoop = false;
foreach (string w in outgoing)
{
if (v.Equals(w))
{
selfLoop = true;
break;
}
}
// get all states in a SCC & check Buchi fair
bool isBuchiFair = false;
LocalPair tmp = null;
string tmpID = null;
// get from current until v
do
{
tmp = currentStack.Pop();
isBuchiFair = isBuchiFair || tmp.state.EndsWith(Constants.ACCEPT_STATE);
tmpID = tmp.GetCompressedState();
int[] tmpData = dfsData[tmpID];
tmpData[0] = SCC_FOUND;
newSCC.Add(tmpID, tmp);
// update global
sharedSCCStates.GetOrAdd(tmpID, true);
} while (!tmpID.Equals(v));
if (isBuchiFair && (selfLoop || newSCC.Count > 1 || LTSState.IsDeadLock))
{
// queue new SCC to check fairness
localQueueSCC(order, newSCC, callStack, outgoingTransitionTable);
}
//pop callStack
callStack.Pop();
}
else
{
//pop callStack & update the parent
LocalPair pop = callStack.Pop();
LocalPair top = callStack.Peek();
string popID = pop.GetCompressedState();
string topID = top.GetCompressedState();
int[] popData = dfsData[popID];
int[] topData = dfsData[topID];
topData[1] = Math.Min(topData[1], popData[1]);
}
}
}
isStop = true;
}
// Report cycle detected at red DFS
public void SwarmNestedDFSReportRedCycle(LocalPair s, LocalPair step, LocalPair pair, Stack<LocalPair> BlueStack, Stack<LocalPair> RedStack, Dictionary<string, StateColor> colorData, Dictionary<string, List<string>> OutgoingTransitionTable)
{
lock (MultiCoreLock)
{
StopMutliCoreThreads = true;
Dictionary<string, LocalPair> LoopPairs = new Dictionary<string, LocalPair>(1024);
string tmp = step.GetCompressedState();
string v = pair.GetCompressedState();
string sID = s.GetCompressedState();
LocalPair node;
string nodeID;
// If s is start of the loop
if (sID.Equals(tmp))
{
do
{
node = RedStack.Pop();
nodeID = node.GetCompressedState();
LoopPairs.Add(nodeID, node);
} while (RedStack.Count > 0);
}
// If the start of the loop is the parent of s
else
{
do
{
node = RedStack.Pop();
nodeID = node.GetCompressedState();
LoopPairs.Add(nodeID, node);
} while (RedStack.Count > 0);
node = BlueStack.Pop();
nodeID = node.GetCompressedState();
while (!nodeID.Equals(tmp))
{
LoopPairs.Add(nodeID, node);
node = BlueStack.Pop();
nodeID = node.GetCompressedState();
}
LoopPairs.Add(nodeID, node);
}
MultiCoreLocalTaskStack = BlueStack;
MultiCoreResultedLoop = LoopPairs;
MultiCoreOutgoingTransitionTable = OutgoingTransitionTable;
}
}
/// <summary>
/// Local red DFS in each thread
/// </summary>
/// <param name="acceptingState"></param>
/// <param name="localBlueStack"></param>
/// <param name="localDFSColor"></param>
/// <param name="rand"></param>
/// <returns></returns>
public bool LocalRed1(LocalPair acceptingState, Stack<LocalPair> localBlueStack, Dictionary<string, Color> localDFSColor, Random rand, Dictionary<string, List<LocalPair>> localExpendedNodes)
{
Stack<LocalPair> localRedStack = new Stack<LocalPair>(5000);
//push accepting state to red stack
localRedStack.Push(acceptingState);
//start loop
while (localRedStack.Count > 0)
{
//cancel if take long time
if (CancelRequested || isGlobalStop)
{
return false;
}
//get top of red stack
LocalPair pair = localRedStack.Peek();
string v = pair.GetCompressedState();
Color vColor = localDFSColor[v];
//get successors
List<LocalPair> successors = localExpendedNodes[v];
if (!vColor.isPink())
{
//set v pink
vColor.setPink();
//check if there is cyan successor
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
if (localDFSColor.ContainsKey(w) && localDFSColor[w].isCyan())
{
//REPORT COUNTER EXAMPLE
GetLocalLoopCounterExample(w, localBlueStack, localRedStack);
return true;
}
}
}
//------------------------------------------------------------------------
//filter successors
List<int> unvisitedIndexs = new List<int>(successors.Count);//not pink and not global red
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
//if w is white and not global red
if (!localDFSColor[w].isPink() && !globalRedStates.ContainsKey(w))
{
unvisitedIndexs.Add(i);
}
}
//------------------------------------------------------------------------
//get random unvisited successors
if (unvisitedIndexs.Count > 0)
{
int r = rand.Next(unvisitedIndexs.Count);
LocalPair succ = successors[unvisitedIndexs[r]];
localRedStack.Push(succ);
}
else
{
//v is accepting
if (pair.state.EndsWith(Constants.ACCEPT_STATE))
{
//decrease count at v by 1
globalAcceptingCounter[v]--;
//wait for count at v equal 0
while (globalAcceptingCounter[v] != 0) ;
}
//set v global red
globalRedStates.GetOrAdd(v, true);
// pop red stack
localRedStack.Pop();
}
}
//cannot report counter example
return false;
}
/// <summary>
/// Local blue DFS in each thread
/// </summary>
/// <param name="o"></param>
public void LocalBlueSwarm(object o)
{
//order of this thread
int order = (int)o;
Random rand = new Random(order);
//on-the-fly data
Stack <LocalPair> localBlueStack = new Stack <LocalPair>(5000);
Dictionary <string, Color> localDFSColor = new Dictionary <string, Color>(5000);
Dictionary <string, List <LocalPair> > localExpendedNodes = new Dictionary <string, List <LocalPair> >(5000);
//initial states
List <LocalPair> initialStates = LocalPair.GetInitialPairsLocal(BA, InitialStep);
//check valid result
if (initialStates.Count == 0 || !BA.HasAcceptState)
{
return;
}
//push local initial states to local blue stack
int[] localPerm = Permutation(initialStates.Count, rand);
for (int i = 0; i < initialStates.Count; i++)
{
LocalPair tmp = initialStates[localPerm[i]];
localBlueStack.Push(tmp);
}
//start loop
while (localBlueStack.Count > 0)
{
//cancel if take long time
if (CancelRequested || isGlobalStop)
{
return;
}
//get top of blue stack
LocalPair pair = localBlueStack.Peek();
ConfigurationBase LTSState = pair.configuration;
string BAState = pair.state;
string v = pair.GetCompressedState();
//get successors
List <LocalPair> successors = null;
if (localExpendedNodes.ContainsKey(v))
{
successors = localExpendedNodes[v];
}
else
{
IEnumerable <ConfigurationBase> nextLTSStates = LTSState.MakeOneMove();
pair.SetEnabled(nextLTSStates, FairnessType);
successors = LocalPair.NextLocal(BA, nextLTSStates, BAState);
localExpendedNodes.Add(v, successors);
}
//if v is white
if (!localDFSColor.ContainsKey(v))
{
//set v cyan
Color vColor = new Color();
vColor.setCyan();
localDFSColor.Add(v, vColor);
//early cycle detection
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
//if w is cyan and (v or w is accepting)
if (localDFSColor.ContainsKey(w))
{
Color wColor = localDFSColor[w];
if (wColor.isCyan() && (succ.state.EndsWith(Constants.ACCEPT_STATE) || pair.state.EndsWith(Constants.ACCEPT_STATE)))
{
//REPORT COUNTEREXAMPLE
GetLocalLoopCounterExample(w, localBlueStack);
return;
}
}
}
}
//------------------------------------------------------------------------
//filter successors
List <int> unvisitedIndexs = new List <int>(successors.Count);
for (int i = successors.Count - 1; i >= 0; i--)
{
LocalPair succ = successors[i];
string w = succ.GetCompressedState();
//if w is white and not global red
if (!localDFSColor.ContainsKey(w))
{
unvisitedIndexs.Add(i);
}
}
//------------------------------------------------------------------------
//get random unvisited successors
if (unvisitedIndexs.Count > 0)
{
bool isFresh = false;
List <int> unFreshIndexs = new List <int>();
while (unvisitedIndexs.Count > 0)
{
int r = rand.Next(unvisitedIndexs.Count);
LocalPair succ = successors[unvisitedIndexs[r]];
string w = succ.GetCompressedState();
//if w is fresh successor
if (!allVisitedStates.ContainsKey(w))
{
localBlueStack.Push(succ);
allVisitedStates.GetOrAdd(w, 0);
allVisitedStates[w]++;
isFresh = true;
break;
}
else
{
unFreshIndexs.Add(unvisitedIndexs[r]);
unvisitedIndexs.RemoveAt(r);
}
}
if (!isFresh)
{
int r = rand.Next(unFreshIndexs.Count);
LocalPair succ = successors[unFreshIndexs[r]];
string w = succ.GetCompressedState();
localBlueStack.Push(succ);
allVisitedStates.GetOrAdd(w, 0);
allVisitedStates[w]++;
}
}
else
{
Color vColor = localDFSColor[v];
//if v is accepting
if (pair.state.EndsWith(Constants.ACCEPT_STATE))
{
//if v is deadlock
if (LTSState.IsDeadLock)
{
//REPORT COUNTEREXAMPLE
GetLocalDeadlockCounterExample(localBlueStack);
return;
}
else
{
bool isStop = LocalRedSwarm(pair, localBlueStack, localDFSColor, rand, localExpendedNodes);
if (isStop)
{
return;
}
}
//set v pink
vColor.setPink();
}
else
{
vColor.setBlue();
}
//pop v out of blueStack
localBlueStack.Pop();
}
}
}
private void reportAcceptingCycle(LocalPair succ, Stack<LocalPair> callStack, Dictionary<string, int[]> dfsData, Dictionary<string, List<string>> outgoingTransitionTable)
{
Dictionary<string, LocalPair> acceptingCycle = new Dictionary<string, LocalPair>(1024);
// string from = pair.GetCompressedState();
string to = succ.GetCompressedState();
// get states in the cycle
LocalPair tmp = callStack.Pop();
string tmpID = tmp.GetCompressedState();
while (!tmpID.Equals(to))
{
acceptingCycle.Add(tmpID, tmp);
tmp = callStack.Pop();
tmpID = tmp.GetCompressedState();
}
acceptingCycle.Add(tmpID, tmp);
// get the path to accepting cycle
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
VerificationOutput.NoOfStates = dfsData.Count;
LocalTaskStack = callStack;
LocalGetCounterExample(acceptingCycle, outgoingTransitionTable);
}
