protected void GenerateStateSpace(params IComponent[] components)
{
_modelCreator = SafetySharpRuntimeModel.CreateExecutedModelCreator(TestModel.InitializeModel(components), new ExecutableStateFormula(() => true));
var configuration = AnalysisConfiguration.Default;
configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
configuration.StackCapacity = 10000;
configuration.CpuCount = 1;
configuration.DefaultTraceOutput = Output.TextWriterAdapter();
configuration.AllowFaultsOnInitialTransitions = AllowFaultsOnInitialTransitions;
var analysisModelCreator = new AnalysisModelCreator(() => new ActivationMinimalExecutedModel <SafetySharpRuntimeModel>(_modelCreator, 0, configuration));
var checker = new InvariantChecker(analysisModelCreator,
configuration,
formulaIndex: 0);
_result = checker.Check();
CounterExample.ShouldBe(null);
Output.Log($"States: {_result.StateCount}");
Output.Log($"Actual Transitions: {_result.TransitionCount}");
Output.Log($"Computed Transitions: {_result.ComputedTransitionCount}");
}
/// <summary>
/// Initializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
var invariant = new UnaryFormula(hazard, UnaryOperator.Not);
var checker = new QualitativeChecker <TExecutableModel>(RuntimeModelCreator)
{
Configuration = configuration
};
checker.Configuration.ProgressReportsOnly = false;
var stateGraph = checker.GenerateStateGraph();
var stateCapacity = Math.Max(1024, (int)(stateGraph.StateCount * 1.5));
var newModelCapacity = new ModelCapacityByModelDensity(stateCapacity, ModelDensityLimit.High);
configuration.ModelCapacity = newModelCapacity;
Func <AnalysisModel> createAnalysisModelFunc = () => new StateGraphModel <TExecutableModel>(stateGraph, configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
_checker = new InvariantChecker(createAnalysisModel, configuration, invariant);
}
/// <summary>
/// Initizializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
Func <AnalysisModel <TExecutableModel> > createAnalysisModelFunc = () =>
new ActivationMinimalExecutedModel <TExecutableModel>(RuntimeModelCreator, _stateHeaderBytes, configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator <TExecutableModel>(createAnalysisModelFunc);
var invariant = new UnaryFormula(hazard, UnaryOperator.Not);
_invariantChecker = new InvariantChecker <TExecutableModel>(createAnalysisModel, OnOutputWritten, configuration, invariant);
}
/// <summary>
/// Initizializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
Func <AnalysisModel> createAnalysisModelFunc = () =>
new ActivationMinimalExecutedModel <TExecutableModel>(RuntimeModelCreator, 0, configuration);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
var invariant = new UnaryFormula(hazard, UnaryOperator.Not);
_invariantChecker = new InvariantChecker(createAnalysisModel, configuration, invariant);
}
/// <summary>
/// Initizializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
var serializer = new RuntimeModelSerializer();
serializer.Serialize(Model, !hazard);
Func<AnalysisModel> createModel = () =>
new ActivationMinimalExecutedModel(CreateModel(hazard), configuration.SuccessorCapacity);
_invariantChecker = new InvariantChecker(createModel, OnOutputWritten, configuration, formulaIndex: 0);
}
/// <summary>
/// Initizializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
var checker = new SSharpChecker { Configuration = configuration };
checker.Configuration.ProgressReportsOnly = false;
checker.OutputWritten += OnOutputWritten;
var stateGraph = checker.GenerateStateGraph(Model, !hazard);
configuration.StateCapacity = Math.Max(1024, (int)(stateGraph.StateCount * 1.5));
_checker = new InvariantChecker(() => new StateGraphModel(stateGraph, configuration.SuccessorCapacity), OnOutputWritten,
configuration, formulaIndex: 0);
}
private int DoWork()
{
using (var checker = new InvariantChecker(this))
{
try
{
// do some stuff
}
catch
{
checker.Suppress = true;
throw;
}
}
}
/// <summary>
/// Checks the invariant encoded into the model created by <paramref name="createModel" />.
/// </summary>
public InvariantAnalysisResult CheckInvariant(int formulaIndex)
{
// We have to track the state vector layout here; this will nondeterministically store some model instance of
// one of the workers; but since all state vectors are the same, we don't care
ExecutedModel <TExecutableModel> model = null;
Func <AnalysisModel> createAnalysisModelFunc = () =>
model = new ActivationMinimalExecutedModel <TExecutableModel>(ModelCreator, 0, Configuration);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
using (var checker = new InvariantChecker(createAnalysisModel, Configuration, formulaIndex))
{
var result = checker.Check();
return(result);
}
}
/// <summary>
/// Checks the invariant encoded into the model created by <paramref name="createModel" />.
/// </summary>
public AnalysisResult <TExecutableModel> CheckInvariant(CoupledExecutableModelCreator <TExecutableModel> createModel, Formula formula)
{
// We have to track the state vector layout here; this will nondeterministically store some model instance of
// one of the workers; but since all state vectors are the same, we don't care
ExecutedModel <TExecutableModel> model = null;
Func <AnalysisModel <TExecutableModel> > createAnalysisModelFunc = () =>
model = new ActivationMinimalExecutedModel <TExecutableModel>(createModel, 0, Configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator <TExecutableModel>(createAnalysisModelFunc);
using (var checker = new InvariantChecker <TExecutableModel>(createAnalysisModel, OutputWritten, Configuration, formula))
{
var result = checker.Check();
return(result);
}
}
/// <summary>
/// Checks whether the <paramref name="invariant" /> holds in all states of the <paramref name="stateGraph" />.
/// </summary>
/// <param name="stateGraph">The state graph that should be checked.</param>
/// <param name="invariant">The invariant that should be checked.</param>
internal InvariantAnalysisResult CheckInvariant(StateGraph <TExecutableModel> stateGraph, Formula invariant)
{
Requires.NotNull(stateGraph, nameof(stateGraph));
Requires.NotNull(invariant, nameof(invariant));
// We have to track the state vector layout here; this will nondeterministically store some model instance of
// one of the workers; but since all state vectors are the same, we don't care
AnalysisModel model = null;
Func <AnalysisModel> createAnalysisModelFunc = () =>
model = new StateGraphModel <TExecutableModel>(stateGraph, Configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
using (var checker = new InvariantChecker(createAnalysisModel, Configuration, invariant))
{
var result = checker.Check();
return(result);
}
}
/// <summary>
/// Checks the invariant encoded into the model created by <paramref name="createModel" />.
/// </summary>
internal AnalysisResult CheckInvariant(Func<AnalysisModel> createModel, int formulaIndex)
{
Requires.That(IntPtr.Size == 8, "Model checking is only supported in 64bit processes.");
var stopwatch = new Stopwatch();
stopwatch.Start();
using (var checker = new InvariantChecker(createModel, OutputWritten, Configuration, formulaIndex))
{
var result = default(AnalysisResult);
var initializationTime = stopwatch.Elapsed;
stopwatch.Restart();
try
{
result = checker.Check();
return result;
}
finally
{
stopwatch.Stop();
if (!Configuration.ProgressReportsOnly)
{
OutputWritten?.Invoke(String.Empty);
OutputWritten?.Invoke("===============================================");
OutputWritten?.Invoke($"Initialization time: {initializationTime}");
OutputWritten?.Invoke($"Model checking time: {stopwatch.Elapsed}");
if (result != null)
{
OutputWritten?.Invoke($"{(long)(result.StateCount / stopwatch.Elapsed.TotalSeconds):n0} states per second");
OutputWritten?.Invoke($"{(long)(result.TransitionCount / stopwatch.Elapsed.TotalSeconds):n0} transitions per second");
}
OutputWritten?.Invoke("===============================================");
OutputWritten?.Invoke(String.Empty);
}
}
}
}
protected void GenerateStateSpace(params IComponent[] components)
{
var serializer = new RuntimeModelSerializer();
serializer.Serialize(TestModel.InitializeModel(components), new StateFormula(() => true));
var configuration = AnalysisConfiguration.Default;
configuration.StateCapacity = 10000;
configuration.StackCapacity = 10000;
configuration.CpuCount = 1;
var checker = new InvariantChecker(serializer.Load, s => Output.Log("{0}", s), configuration);
_result = checker.Check();
CounterExample.ShouldBe(null);
Output.Log($"States: {_result.StateCount}");
Output.Log($"Actual Transitions: {_result.TransitionCount}");
Output.Log($"Computed Transitions: {_result.ComputedTransitionCount}");
}
public PostExtractorChecker(
ContractNodes usedToExtract,
Action<System.CodeDom.Compiler.CompilerError> errorHandler,
bool allowPreconditionsInOverrides, bool fSharp, bool explicitUserValidations,
bool addInterfaceWrappersWhenNeeded, int runtimeCheckingLevel)
{
Contract.Requires(errorHandler != null);
Contract.Requires(usedToExtract != null);
this.m_errorHandler = errorHandler;
this.allowPreconditionsInOverrides = allowPreconditionsInOverrides;
this.explicitUserValidations = explicitUserValidations;
this.addInterfaceWrappersWhenNeeded = addInterfaceWrappersWhenNeeded;
this.runtimeCheckingLevel = runtimeCheckingLevel;
this.purityChecker = new PurityChecker(this.HandleError, fSharp, usedToExtract);
this.preconditionChecker = new PreconditionChecker(this.HandleError, usedToExtract);
this.postconditionChecker = new PostconditionChecker(this.HandleError, fSharp);
this.invariantCallChecker = new CheckForCallsToInvariantMethods(this);
this.methodBodyChecker = new MethodBodyChecker(this.HandleError, usedToExtract);
this.invariantChecker = new InvariantChecker(this.HandleError, usedToExtract);
this.contractNodes = usedToExtract;
this.visibilityChecker = new VisibilityChecker(this.HandleError, usedToExtract);
this.invariantMethods = new TrivialHashtable(0);
}
