/// <summary> /// Resets the model to its initial state. /// </summary> public void Reset() { if (_choiceResolver == null) { _choiceResolver = new NondeterministicChoiceResolver(true); RuntimeModel.SetChoiceResolver(_choiceResolver); } var state = stackalloc byte[RuntimeModel.StateVectorSize]; _states.Clear(); _stateIndex = -1; if (_counterExample == null) { RuntimeModel.Reset(); } else { try { _counterExample.Replay(_choiceResolver, 0); } catch (ModelException me) { me.RethrowInnerException(); } } RuntimeModel.Serialize(state); AddState(state); }
public override void SetChoiceResolver(ChoiceResolver choiceResolver) { Model.Choice.Resolver = choiceResolver; foreach (var faultsValue in Model.Faults.Values) { faultsValue.Choice.Resolver = choiceResolver; } }
/// <summary> /// Resets the model to its initial state. /// </summary> /// <param name="traversalModifierStateVectorSize">Extra bytes in state vector for traversal parameters.</param> public sealed override void Reset(int traversalModifierStateVectorSize) { ChoiceResolver.Clear(); RuntimeModel.Reset(); TemporaryStateStorage.Reset(traversalModifierStateVectorSize); SavedActivations = RuntimeModel.NondeterministicFaults.Select(fault => fault.Activation).ToArray(); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="runtimeModelCreator">A factory function that creates the model instance that should be executed.</param> /// <param name="formulas">The formulas that should be evaluated for each state.</param> /// <param name="successorStateCapacity">The maximum number of successor states supported per state.</param> internal ActivationMinimalExecutedModel(Func<RuntimeModel> runtimeModelCreator, Func<bool>[] formulas, long successorStateCapacity) : base(runtimeModelCreator) { formulas = formulas ?? RuntimeModel.Formulas.Select(CompilationVisitor.Compile).ToArray(); _transitions = new ActivationMinimalTransitionSetBuilder(RuntimeModel, successorStateCapacity, formulas); _stateConstraints = RuntimeModel.Model.Components.Cast<Component>().SelectMany(component => component.StateConstraints).ToArray(); ChoiceResolver = new ChoiceResolver(RuntimeModel.Objects.OfType<Choice>()); }
/// <summary> /// Disposes the object, releasing all managed and unmanaged resources. /// </summary> /// <param name="disposing">If true, indicates that the object is disposed; otherwise, the object is finalized.</param> protected override void OnDisposing(bool disposing) { if (!disposing) { return; } ChoiceResolver.SafeDispose(); TemporaryStateStorage.SafeDispose(); RuntimeModel.SafeDispose(); }
/// <summary> /// Gets all transitions towards successor states of <paramref name="state" />. /// </summary> /// <param name="state">The state the successors should be returned for.</param> public override TransitionCollection GetSuccessorTransitions(byte *state) { BeginExecution(); ChoiceResolver.PrepareNextState(); while (ChoiceResolver.PrepareNextPath()) { RuntimeModel.Deserialize(state); ExecuteTransition(); GenerateTransition(); } return(EndExecution()); }
/// <summary> /// Gets all initial transitions of the model. /// </summary> public override TransitionCollection GetInitialTransitions() { BeginExecution(); ChoiceResolver.PrepareNextState(); fixed(byte *state = RuntimeModel.ConstructionState) { while (ChoiceResolver.PrepareNextPath()) { RuntimeModel.Deserialize(state); ExecuteInitialTransition(); GenerateTransition(); } } return(EndExecution()); }
/// <summary> /// Replays the transition of the counter example with the zero-baesd <paramref name="transitionIndex" />. /// </summary> /// <param name="choiceResolver">The choice resolver that should be used to resolve nondeterministic choices.</param> /// <param name="transitionIndex">The zero-based index of the transition that should be replayed.</param> internal unsafe void Replay(ChoiceResolver choiceResolver, int transitionIndex) { if (StepCount == 0) return; choiceResolver.Clear(); choiceResolver.PrepareNextState(); choiceResolver.SetChoices(_replayInfo[transitionIndex]); fixed (byte* state = _states[transitionIndex]) RuntimeModel.Deserialize(state); if (transitionIndex == 0) RuntimeModel.ExecuteInitialStep(); else RuntimeModel.ExecuteStep(); RuntimeModel.NotifyFaultActivations(); }
/// <summary> /// Resets the model to its initial state. /// </summary> public void Reset() { if (_choiceResolver == null) _choiceResolver = new ChoiceResolver(_runtimeModel.Objects.OfType<Choice>()); var state = stackalloc byte[_runtimeModel.StateVectorSize]; _states.Clear(); _stateIndex = -1; if (_counterExample == null) _runtimeModel.Reset(); else _counterExample.Replay(_choiceResolver, 0); _runtimeModel.Serialize(state); AddState(state); }