private Program ApplyInvariants(Houdini.HoudiniOutcome outcome)
{
Program program = getFreshProgram(false, false);
CommandLineOptions.Clo.PrintUnstructured = 2;
Houdini.Houdini.ApplyAssignment(program, outcome);
if (((GPUVerifyCruncherCommandLineOptions)CommandLineOptions.Clo).ReplaceLoopInvariantAssertions)
{
foreach (Block block in program.Blocks())
{
List <Cmd> newCmds = new List <Cmd>();
foreach (Cmd cmd in block.Cmds)
{
AssertCmd assertion = cmd as AssertCmd;
if (assertion != null &&
QKeyValue.FindBoolAttribute(assertion.Attributes, "originated_from_invariant"))
{
AssumeCmd assumption = new AssumeCmd(assertion.tok, assertion.Expr, assertion.Attributes);
newCmds.Add(assumption);
}
else
{
newCmds.Add(cmd);
}
}
block.Cmds = newCmds;
}
}
return(program);
}
public void Start(Program program, ref Houdini.HoudiniOutcome outcome)
{
if (this.Solver.Equals(CVC4))
{
if (CommandLineOptions.Clo.Cho[this.ID].ProverOptions.Contains("LOGIC=QF_ALL_SUPPORTED") &&
CheckForQuantifiers.Found(program))
{
CommandLineOptions.Clo.Cho[this.ID].ProverOptions.Remove("LOGIC=QF_ALL_SUPPORTED");
CommandLineOptions.Clo.Cho[this.ID].ProverOptions.Add("LOGIC=ALL_SUPPORTED");
}
}
Print.VerboseMessage("[CRUNCHER] Engine " + this.GetType().Name + " started");
ModifyProgramBeforeCrunch(program);
Houdini.HoudiniSession.HoudiniStatistics houdiniStats = new Houdini.HoudiniSession.HoudiniStatistics();
if (CommandLineOptions.Clo.StagedHoudini != null)
{
// This is an initial attempt at hooking GPUVerify up with Staged Houdini.
// More work is required to make this compatible with other cruncher options,
// and we start with a couple of crude hacks to work around the fact that
// Staged Houdini is not integrated with ConcurrentHoudini.
CommandLineOptions.Clo.ConcurrentHoudini = false; // HACK - requires proper integration
CommandLineOptions.Clo.ProverCCLimit = this.ErrorLimit; // HACK - requires proper integration
Debug.Assert(outcome == null);
Debug.Assert(this is VanillaHoudini);
Houdini.StagedHoudini houdini = new Houdini.StagedHoudini(program, houdiniStats, ExecutionEngine.ProgramFromFile);
outcome = houdini.PerformStagedHoudiniInference();
}
else
{
string filename = "houdiniCexTrace_" + this.ID + ".bpl";
houdini = new Houdini.ConcurrentHoudini(this.ID, program, houdiniStats, filename);
if (outcome != null)
{
outcome = houdini.PerformHoudiniInference(initialAssignment: outcome.assignment);
}
else
{
outcome = houdini.PerformHoudiniInference();
}
}
Print.VerboseMessage("[CRUNCHER] Engine " + this.GetType().Name + " finished");
if (((GPUVerifyCruncherCommandLineOptions)CommandLineOptions.Clo).DebugConcurrentHoudini)
{
OutputResults(outcome, houdiniStats);
}
}
private void OutputResults(Houdini.HoudiniOutcome outcome, Houdini.HoudiniSession.HoudiniStatistics houdiniStats)
{
int numTrueAssigns = outcome.assignment.Where(x => x.Value).Count();
Console.WriteLine("Number of true assignments = " + numTrueAssigns);
Console.WriteLine("Number of false assignments = " + (outcome.assignment.Count - numTrueAssigns));
Console.WriteLine("Prover time = " + houdiniStats.proverTime.ToString("F2"));
Console.WriteLine("Unsat core prover time = " + houdiniStats.unsatCoreProverTime.ToString("F2"));
Console.WriteLine("Number of prover queries = " + houdiniStats.numProverQueries);
Console.WriteLine("Number of unsat core prover queries = " + houdiniStats.numUnsatCoreProverQueries);
Console.WriteLine("Number of unsat core prunings = " + houdiniStats.numUnsatCorePrunings);
}
private Houdini.HoudiniOutcome ScheduleEnginesInSequence(Pipeline pipeline)
{
Houdini.HoudiniOutcome outcome = null;
foreach (Engine engine in pipeline.GetEngines())
{
if (engine is SMTEngine)
{
SMTEngine smtEngine = (SMTEngine)engine;
smtEngine.Start(getFreshProgram(true, true), ref outcome);
}
else
{
DynamicAnalysis dynamicEngine = (DynamicAnalysis)engine;
Program program = getFreshProgram(true, false);
dynamicEngine.Start(program);
}
}
return(outcome);
}
private Houdini.HoudiniOutcome ScheduleEnginesInParallel(Pipeline pipeline)
{
Houdini.HoudiniOutcome outcome = null;
CancellationTokenSource tokenSource = new CancellationTokenSource();
List <Task> underApproximatingTasks = new List <Task>();
List <Task> overApproximatingTasks = new List <Task>();
// Schedule the under-approximating engines first
foreach (Engine engine in pipeline.GetEngines())
{
if (!(engine is VanillaHoudini))
{
if (engine is DynamicAnalysis)
{
DynamicAnalysis dynamicEngine = (DynamicAnalysis)engine;
underApproximatingTasks.Add(Task.Factory.StartNew(
() =>
{
dynamicEngine.Start(getFreshProgram(true, false));
},
tokenSource.Token));
}
else
{
SMTEngine smtEngine = (SMTEngine)engine;
underApproximatingTasks.Add(Task.Factory.StartNew(
() =>
{
smtEngine.Start(getFreshProgram(true, true), ref outcome);
},
tokenSource.Token));
}
}
}
if (pipeline.runHoudini)
{
// We set a barrier on the under-approximating engines if a Houdini delay
// is specified or no sliding is selected
if (pipeline.GetHoudiniEngine().Delay > 0)
{
Print.VerboseMessage("Waiting at barrier until Houdini delay has elapsed or all under-approximating engines have finished");
Task.WaitAll(underApproximatingTasks.ToArray(), pipeline.GetHoudiniEngine().Delay * 1000);
}
else if (pipeline.GetHoudiniEngine().SlidingSeconds > 0)
{
Print.VerboseMessage("Waiting at barrier until all under-approximating engines have finished");
Task.WaitAll(underApproximatingTasks.ToArray());
}
// Schedule the vanilla Houdini engine
overApproximatingTasks.Add(Task.Factory.StartNew(
() =>
{
pipeline.GetHoudiniEngine().Start(getFreshProgram(true, true), ref outcome);
},
tokenSource.Token));
// Schedule Houdinis every x seconds until the number of new Houdini instances exceeds the limit
if (pipeline.GetHoudiniEngine().SlidingSeconds > 0)
{
int numOfRefuted = Houdini.ConcurrentHoudini.RefutedSharedAnnotations.Count;
int newHoudinis = 0;
bool runningHoudinis;
do
{
// Wait before launching new Houdini instances
Thread.Sleep(pipeline.GetHoudiniEngine().SlidingSeconds * 1000);
// Only launch a fresh Houdini if the candidate invariant set has changed
if (Houdini.ConcurrentHoudini.RefutedSharedAnnotations.Count > numOfRefuted)
{
numOfRefuted = Houdini.ConcurrentHoudini.RefutedSharedAnnotations.Count;
VanillaHoudini newHoudiniEngine = new VanillaHoudini(pipeline.GetNextSMTEngineID(),
pipeline.GetHoudiniEngine().Solver,
pipeline.GetHoudiniEngine().ErrorLimit);
pipeline.AddEngine(newHoudiniEngine);
Print.VerboseMessage("Scheduling another Houdini instance");
overApproximatingTasks.Add(Task.Factory.StartNew(
() =>
{
newHoudiniEngine.Start(getFreshProgram(true, true), ref outcome);
tokenSource.Cancel(false);
},
tokenSource.Token));
++newHoudinis;
}
// Are any Houdinis still running?
runningHoudinis = false;
foreach (Task task in overApproximatingTasks)
{
if (task.Status.Equals(TaskStatus.Running))
{
runningHoudinis = true;
}
}
} while (newHoudinis < pipeline.GetHoudiniEngine().SlidingLimit&& runningHoudinis);
}
try
{
Task.WaitAny(overApproximatingTasks.ToArray(), tokenSource.Token);
tokenSource.Cancel(false);
}
catch (OperationCanceledException e)
{
Console.WriteLine("Unexpected exception: " + e);
throw;
}
}
else
{
Task.WaitAll(underApproximatingTasks.ToArray());
}
return(outcome);
}
