private List <DiagnosisResult> checkLivelockBetweenResult(List <DiagnosisResult> diagnosisList)
{
List <DiagnosisResult> lList = new List <DiagnosisResult>();
List <DiagnosisResult> result = new List <DiagnosisResult>();
lList.AddRange(diagnosisList);
for (var i = 0; i < diagnosisList.Count; i++)
{
for (var j = 0; j < lList.Count; j++)
{
string scenario1 = diagnosisList[i].Scenario;
string scenario2 = lList[j].Scenario;
//System.Diagnostics.Debug.WriteLine(scenario1.Substring(scenario1.IndexOf(".") + 1, 3) +" == "+ scenario2.Substring(scenario2.IndexOf(".")+1, 3));
if (i != j &&
diagnosisList[i].Symptom.Equals("normal") &&
lList[j].Symptom.Equals("normal") &&
!scenario1.Equals(scenario2) &&
scenario1.Substring(scenario1.IndexOf(".") + 1, 3).Equals(scenario2.Substring(scenario2.IndexOf(".") + 1, 3)) &&
scenario1.Substring(scenario1.LastIndexOf(".") + 1, 3).Equals(scenario2.Substring(scenario2.LastIndexOf(".") + 1, 3)))
{
DiagnosisResult rs = new DiagnosisResult();
rs.Symptom = "livelock";
rs.LoopIndex = -1;
rs.Scenario = scenario1 + " invoke" + scenario2.Substring(scenario1.IndexOf("."));
rs.MemoryUsage = diagnosisList[i].MemoryUsage + lList[j].MemoryUsage;
rs.NumberOfStates = diagnosisList[i].NumberOfStates + lList[j].NumberOfStates;
rs.TotalTime = diagnosisList[i].TotalTime + lList[j].TotalTime;
result.Add(rs);
}
}
}
return(result);
}
//engineIndex 0 for Depth First Search, 1 for Breadth First Search
private DiagnosisResult RunAssertion(AssertionBase assertion, int fairnessIndex, int engineIndex)
{
System.Diagnostics.Debug.WriteLine(assertion);
// return CreatedAtRoute("GetProduct", new { id = item.Id }, item);
assertion.UIInitialize(null, fairnessIndex, engineIndex);
assertion.VerificationMode = true;
assertion.InternalStart();
System.Diagnostics.Debug.WriteLine(assertion.GetVerificationStatistics());
DiagnosisResult result = new DiagnosisResult();
result.Assertion = assertion.ToString();
System.Diagnostics.Debug.WriteLine("VALID? " + assertion.VerificationOutput.VerificationResult.Equals(VerificationResultType.VALID));
string scenarioDesc = "";
System.Diagnostics.Debug.WriteLine("loop: " + assertion.VerificationOutput.LoopIndex);
result.MemoryUsage = assertion.VerificationOutput.EstimateMemoryUsage;
result.TotalTime = assertion.VerificationOutput.VerificationTime;
result.NumberOfStates = assertion.VerificationOutput.NoOfStates;
result.LoopIndex = assertion.VerificationOutput.LoopIndex;
if (assertion.VerificationOutput.VerificationResult.Equals(VerificationResultType.VALID))
{
result.IsValid = true;
}
else
{
result.IsValid = false;
}
if (assertion.VerificationOutput.CounterExampleTrace != null)
{
foreach (ConfigurationBase step in assertion.VerificationOutput.CounterExampleTrace)
{
scenarioDesc += " " + step.GetDisplayEvent();
}
result.Scenario = scenarioDesc;
System.Diagnostics.Debug.WriteLine(scenarioDesc);
}
return(result);
}
private List <DiagnosisResult> executeVerification(List <ArchMatrix> matrix)
{
VerifyAsset verifyAsset = GenerateAsset(matrix);
System.Diagnostics.Debug.WriteLine(verifyAsset.CSPCode);
try
{
PAT.CSP.ModuleFacade modulebase = new PAT.CSP.ModuleFacade();
SpecificationBase Spec = modulebase.ParseSpecification(verifyAsset.CSPCode, string.Empty, string.Empty);
System.Diagnostics.Debug.WriteLine("Specification Loaded...");
//print assertion for debugging
List <KeyValuePair <string, AssertionBase> > asrtlists = Spec.AssertionDatabase.ToList();
foreach (KeyValuePair <string, AssertionBase> asrt in asrtlists)
{
System.Diagnostics.Debug.WriteLine("#" + asrt.Key + "#");
}
List <DiagnosisResult> diagnosisList = new List <DiagnosisResult>();
// Verify deadlock loop
bool deadlockFound = false;
for (var i = 0; i < verifyAsset.deadloopCheck.Count; i++)
{
AssertionBase assertion = Spec.AssertionDatabase[verifyAsset.deadloopCheck[i]];
DiagnosisResult result = RunAssertion(assertion, 1, 0);
if (!result.IsValid && result.Scenario != null && result.LoopIndex > -1)
{
deadlockFound = true;
result.Symptom = "deadloop";
diagnosisList.Add(result);
}
}
// Verify livelock, if deadlock is not found
if (!deadlockFound)
{
bool livelockFound = false;
string prevScenario = null;
bool isAllSameScenario = true;
List <DiagnosisResult> normalList = new List <DiagnosisResult>();
for (var i = 0; i < verifyAsset.livelockCheck.Count; i++)
{
AssertionBase assertion = Spec.AssertionDatabase[verifyAsset.livelockCheck[i]];
DiagnosisResult result = RunAssertion(assertion, 0, 0);
if (!result.IsValid && result.Scenario != null && hasDuplilcateInvoke(result.Scenario))
{
if (result.LoopIndex > -1)
{
result.Symptom = "deadloop";
}
else
{
result.Symptom = "livelock";
}
diagnosisList.Add(result);
livelockFound = true;
}
else if (!result.IsValid && result.Scenario != null)
{
result.Symptom = "normal";
normalList.Add(result);
if (prevScenario != null && !prevScenario.Equals(result.Scenario))
{
isAllSameScenario = false;
}
}
prevScenario = result.Scenario;
System.Diagnostics.Debug.WriteLine("prevScenario : " + prevScenario);
}
// in case normal and all same scenario, try to generate more simulation for normal case
if (!livelockFound)
{
diagnosisList.AddRange(normalList);
if (isAllSameScenario)
{
diagnosisList.AddRange(normalList);
string firstId = prevScenario.Substring(prevScenario.IndexOf(".") + 1, 3);
string lastId = prevScenario.Substring(prevScenario.LastIndexOf(".") + 1);
System.Diagnostics.Debug.WriteLine("firstId : " + firstId);
System.Diagnostics.Debug.WriteLine("lastId : " + lastId);
verifyAsset = InsertMoreLivelockCheck(verifyAsset, matrix, firstId, lastId);
Spec = modulebase.ParseSpecification(verifyAsset.CSPCode, string.Empty, string.Empty);
asrtlists = Spec.AssertionDatabase.ToList();
foreach (KeyValuePair <string, AssertionBase> asrt in asrtlists)
{
System.Diagnostics.Debug.WriteLine("#" + asrt.Key + "#");
}
for (var i = 0; i < verifyAsset.livelockCheck.Count; i++)
{
AssertionBase assertion = Spec.AssertionDatabase[verifyAsset.livelockCheck[i]];
DiagnosisResult result = RunAssertion(assertion, 0, 0);
if (!result.IsValid && result.Scenario != null)
{
result.Symptom = "normal";
diagnosisList.Add(result);
}
}
}
}
}
List <DiagnosisResult> rs = checkLivelockBetweenResult(diagnosisList);
if (rs.Count != 0)
{
diagnosisList = rs;
}
return(diagnosisList);
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError(ex.Message);
System.Diagnostics.Trace.TraceError(ex.StackTrace);
}
return(null);
}
public void callBack(DiagnosisResult result)
{
results.Add(result);
}
void gatherResults(DiagnosisResult result)
{
System.Diagnostics.Debug.WriteLine("retrieve result : " + result.Symptom);
asrtResults.Add(result);
}
