public static SerializationDelegate CreateFastInPlaceDeserializer(SimpleModelBase model)
{
var permanentFaults = model.Faults.OfType <PermanentFault>().ToArray();
var isActiveField = typeof(PermanentFault).GetField("_isActive", BindingFlags.NonPublic | BindingFlags.Instance);
SerializationDelegate deserialize = state =>
{
// States
model.State = *((int *)state + 0);
// Faults
var faultsSerialized = *(long *)(state + sizeof(int));
for (var i = 0; i < permanentFaults.Length; ++i)
{
var fault = permanentFaults[i];
if ((faultsSerialized & (1L << i)) != 0)
{
isActiveField.SetValue(fault, true);
}
else
{
isActiveField.SetValue(fault, false);
}
}
};
return(deserialize);
}
public static SafetyAnalysisResults <SimpleExecutableModel> AnalyzeHazard(SimpleModelBase model, Formula hazard, int maxCardinality = Int32.MaxValue,
SafetyAnalysisBackend backend = SafetyAnalysisBackend.FaultOptimizedOnTheFly)
{
var modelCreator = SimpleExecutableModel.CreateExecutedModelCreator(model, hazard);
return(AnalyzeHazard(modelCreator, hazard, maxCardinality, backend));
}
public static SerializationDelegate CreateFastInPlaceSerializer(SimpleModelBase model)
{
var permanentFaults = model.Faults.OfType <PermanentFault>().ToArray();
var isActiveField = typeof(PermanentFault).GetField("_isActive", BindingFlags.NonPublic | BindingFlags.Instance);
SerializationDelegate serialize = state =>
{
// States
*((int *)state) = model.State;
// Faults
var faultsSerialized = 0L;
for (var i = 0; i < permanentFaults.Length; ++i)
{
var fault = permanentFaults[i];
var isActive = (bool)isActiveField.GetValue(fault);
if (isActive)
{
faultsSerialized |= 1L << i;
}
}
*(long *)(state + sizeof(int)) = faultsSerialized;
};
return(serialize);
}
public static byte[] SerializeToByteArray(SimpleModelBase model, Formula[] formulas)
{
Requires.NotNull(model, nameof(model));
using (var buffer = new MemoryStream())
using (var writer = new BinaryWriter(buffer, Encoding.UTF8, leaveOpen: true))
{
// write C# type of model
var exactTypeOfModel = model.GetType();
var exactTypeOfModelName = exactTypeOfModel.AssemblyQualifiedName;
Requires.NotNull(exactTypeOfModelName, $"{exactTypeOfModelName} != null");
writer.Write(exactTypeOfModelName);
// write state
writer.Write(model.State);
// write formulas
writer.Write((uint)formulas.Length);
foreach (var formula in formulas)
{
WriteFormula(writer, formula);
}
// return result as array
return(buffer.ToArray());
}
}
public override bool Evaluate(SimpleModelBase model)
{
if (model.LocalInts[Index] >= From && model.LocalInts[Index] <= To)
{
return(true);
}
return(false);
}
public override bool Evaluate(SimpleModelBase model)
{
if (model.State >= From && model.State <= To)
{
return(true);
}
return(false);
}
public override bool Evaluate(SimpleModelBase model)
{
return(model.LocalBools[Index]);
}
public abstract bool Evaluate(SimpleModelBase model);
public SimpleMarkovDecisionProcessFromExecutableModelGenerator(SimpleModelBase model) : base(SimpleExecutableModel.CreateExecutedModelFromFormulasCreator(model))
{
}
public SimpleMarkovChainFromExecutableModelGenerator(SimpleModelBase model) : base(SimpleExecutableModel.CreateExecutedModelFromFormulasCreator(model))
{
}
public static CoupledExecutableModelCreator <SimpleExecutableModel> CreateExecutedModelCreator(SimpleModelBase inputModel, params Formula[] formulasToCheckInBaseModel)
{
Requires.NotNull(inputModel, nameof(inputModel));
Requires.NotNull(formulasToCheckInBaseModel, nameof(formulasToCheckInBaseModel));
Func <int, SimpleExecutableModel> creatorFunc = (reservedBytes) =>
{
// Each model checking thread gets its own SimpleExecutableModel.
// Thus, we serialize the C# model and load this file again.
// The serialization can also be used for saving counter examples
var serializedModelWithFormulas = SimpleModelSerializer.SerializeToByteArray(inputModel, formulasToCheckInBaseModel);
var simpleExecutableModel = new SimpleExecutableModel(serializedModelWithFormulas);
return(simpleExecutableModel);
};
var faults = inputModel.Faults;
return(new CoupledExecutableModelCreator <SimpleExecutableModel>(creatorFunc, inputModel, formulasToCheckInBaseModel, faults));
}
public SafetyAnalysisResults <SimpleExecutableModel> ComputeMinimalCriticalSets(SimpleModelBase model, Formula hazard, int maxCardinality = Int32.MaxValue)
{
var modelCreator = SimpleExecutableModel.CreateExecutedModelCreator(model, hazard);
return(ComputeMinimalCriticalSets(modelCreator, hazard, maxCardinality));
}
public AnalysisResult <SimpleExecutableModel> CheckInvariant(SimpleModelBase model, Formula invariant)
{
var modelCreator = SimpleExecutableModel.CreateExecutedModelCreator(model, invariant);
return(CheckInvariant(modelCreator, formulaIndex: 0));
}
public static ExecutableModelCreator <SimpleExecutableModel> CreateExecutedModelFromFormulasCreator(SimpleModelBase model)
{
Requires.NotNull(model, nameof(model));
Func <Formula[], CoupledExecutableModelCreator <SimpleExecutableModel> > creator = formulasToCheckInBaseModel =>
{
Requires.NotNull(formulasToCheckInBaseModel, nameof(formulasToCheckInBaseModel));
return(CreateExecutedModelCreator(model, formulasToCheckInBaseModel));
};
return(new ExecutableModelCreator <SimpleExecutableModel>(creator, model));
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="model">The model that should be simulated.</param>
/// <param name="formulas">The formulas that can be evaluated on the model.</param>
public SimpleSimulator(SimpleModelBase model, params Formula[] formulas)
: base(SimpleExecutableModel.CreateExecutedModelCreator(model, formulas).Create(0))
{
}
public SimpleQualitativeChecker(SimpleModelBase model, params Formula[] formulas)
: base(SimpleExecutableModel.CreateExecutedModelCreator(model, formulas))
{
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="model">The model that should be simulated.</param>
/// <param name="formulas">The formulas that can be evaluated on the model.</param>
public SimpleProbabilisticSimulator(SimpleModelBase model, params Formula[] formulas)
: base(SimpleExecutableModel.CreateExecutedModelFromFormulasCreator(model), formulas, Configuration)
{
}
public static CoupledExecutableModelCreator <SimpleExecutableModel> CreateExecutedModelCreator(SimpleModelBase inputModel, params Formula[] formulasToCheckInBaseModel)
{
Requires.NotNull(inputModel, nameof(inputModel));
Requires.NotNull(formulasToCheckInBaseModel, nameof(formulasToCheckInBaseModel));
Func <int, SimpleExecutableModel> creatorFunc = (reservedBytes) =>
{
// Each model checking thread gets its own SimpleExecutableModel.
// Thus, we serialize the C# model and load this file again.
// The serialization can also be used for saving counter examples
var serializedModelWithFormulas = SimpleModelSerializer.SerializeToByteArray(inputModel, formulasToCheckInBaseModel);
var simpleExecutableModel = new SimpleExecutableModel(serializedModelWithFormulas);
return(simpleExecutableModel);
};
Action <TextWriter> writeOptimizedStateVectorLayout = (textWriter) =>
{
textWriter.WriteLine("bytes[0-4] state: int");
textWriter.WriteLine("bytes[5-12] permanent faults: long");
};
var faults = inputModel.Faults;
return(new CoupledExecutableModelCreator <SimpleExecutableModel>(creatorFunc, writeOptimizedStateVectorLayout, inputModel, formulasToCheckInBaseModel, faults));
}