private bool CanTransitionsBeMerged(LtmcTransition *a, LtmcTransition *b)
{
var aToStuttering = TransitionFlags.IsToStutteringState(a->Flags);
var bToStuttering = TransitionFlags.IsToStutteringState(b->Flags);
if (aToStuttering != bToStuttering)
{
// Target states do not match
return(false);
}
if (!aToStuttering)
{
// both target states are not the stuttering state. So check if the states match
if (!MemoryBuffer.AreEqual(a->TargetStatePointer, b->TargetStatePointer, RelevantStateVectorSize))
{
return(false);
}
}
if (a->Flags != b->Flags)
{
return(false);
}
if (a->Formulas != b->Formulas)
{
return(false);
}
return(true);
}
private uint HashTransition(LtmcTransition *transition)
{
// hashing see FNV hash at http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx
if (!TransitionFlags.IsValid(transition->Flags))
{
return(0);
}
unchecked
{
uint hash = 0;
if (!TransitionFlags.IsToStutteringState(transition->Flags))
{
hash = MemoryBuffer.Hash(transition->TargetStatePointer, RelevantStateVectorSize, 0);
}
hash = hash * 397 ^ (uint)transition->Formulas.GetHashCode();
return(hash);
}
}
/// <summary>
/// Handles the <paramref name="transitions" />, adding newly discovered states so that they are not visited again.
/// </summary>
private void HandleTransitions(TransitionCollection transitions, int sourceState, bool isInitial)
{
try
{
var transitionCount = 0;
var stateCount = 0;
foreach (var modifier in _transitionModifiers)
{
modifier.ModifyTransitions(_context, this, transitions, _context.States[sourceState], sourceState, isInitial);
}
_stateStack.PushFrame();
foreach (var transition in transitions)
{
int targetState;
bool isNewState;
if (TransitionFlags.IsToStutteringState(((CandidateTransition *)transition)->Flags))
{
isNewState = false;
targetState = _context.StutteringStateIndex;
}
else
{
isNewState = _context.States.AddState(((CandidateTransition *)transition)->TargetStatePointer, out targetState);
}
// Replace the CandidateTransition.TargetState pointer with the unique indexes of the transition's source and target states
transition->TargetStateIndex = targetState;
transition->SourceStateIndex = sourceState;
transition->Flags = TransitionFlags.SetIsStateTransformedToIndexFlag(transition->Flags);
if (isNewState)
{
++stateCount;
_stateStack.PushState(targetState);
foreach (var action in _stateActions)
{
action.ProcessState(_context, this, _context.States[targetState], targetState, isInitial);
}
}
foreach (var action in _transitionActions)
{
action.ProcessTransition(_context, this, transition, isInitial);
}
++transitionCount;
}
Interlocked.Add(ref _context.StateCount, stateCount);
Interlocked.Add(ref _context.TransitionCount, transitionCount);
Interlocked.Add(ref _context.ComputedTransitionCount, transitions.TotalCount);
foreach (var action in _batchedTransitionActions)
{
action.ProcessTransitions(_context, this, sourceState, transitions, transitionCount, isInitial);
}
}
catch (Exception e)
{
_context.LoadBalancer.Terminate();
_context.Exception = e;
if (!(e is OutOfMemoryException))
{
CreateCounterExample(endsWithException: true, addAdditionalState: false);
}
}
}
