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); }