public void EnumSizeTest()
{
Assert.AreEqual(1, RTLModuleHelper.SizeOfEnum(typeof(EmptyEnum)));
Assert.AreEqual(1, RTLModuleHelper.SizeOfEnum(typeof(OneStateZero)));
Assert.AreEqual(1, RTLModuleHelper.SizeOfEnum(typeof(OneStateOne)));
Assert.AreEqual(2, RTLModuleHelper.SizeOfEnum(typeof(OneStateTwo)));
Assert.AreEqual(2, RTLModuleHelper.SizeOfEnum(typeof(OneStateThree)));
Assert.AreEqual(3, RTLModuleHelper.SizeOfEnum(typeof(OneStateFour)));
Assert.AreEqual(8, RTLModuleHelper.SizeOfEnum(typeof(BitMask)));
}
void Initialize()
{
Inputs = CreateAndInitializeRelatedObject <TInput>();
InputProps = RTLModuleHelper.SignalProperties(InputsType);
OutputProps = RTLModuleHelper.OutputProperties(GetType());
InternalProps = RTLModuleHelper.InternalProperties(GetType());
ModuleProps = RTLModuleHelper.ModuleProperties(GetType());
ModuleDetails = new List <RTLModuleDetails>();
var fields = ModuleProps.Where(m => RTLModuleHelper.IsField(m));
foreach (var m in fields)
{
var value = m.GetValue(this);
if (value == null)
{
throw new Exception($"Field {m.Name} returns null. Module should have an instance.");
}
var valueType = value.GetType();
if (value is IRTLCombinationalModule module)
{
ModuleDetails.Add(new RTLModuleDetails()
{
Module = module,
Member = m,
Name = m.Name
});
continue;
}
if (valueType.IsArray)
{
var elementType = valueType.GetElementType();
if (typeof(IRTLCombinationalModule).IsAssignableFrom(elementType))
{
ModuleDetails.AddRange(
(value as IEnumerable).OfType <IRTLCombinationalModule>()
.Select((iteration, idx) =>
{
return(new RTLModuleDetails()
{
Module = iteration,
Member = m,
Name = $"{m.Name}{idx}"
});
}));
continue;
}
}
throw new Exception($"Field {m.Name} is not a module. Actual type is {(value?.GetType()?.Name ?? "null")}");
}
}
public void StageSchedule(Func <TInput> inputsFactory)
{
this.inputsFactory = inputsFactory;
if (State == null && NextState == null)
{
var stageInputs = inputsFactory();
var nextStageInputs = inputsFactory();
if (stageMap != null)
{
State = RTLPipelineStageTools.RecurviseResetToDefaults(stageMap(stageInputs));
NextState = RTLPipelineStageTools.RecurviseResetToDefaults(stageMap(nextStageInputs));
}
else if (stageMapWithState != null)
{
var virtualState = RTLModuleHelper.Activate <TOutput>();
rtlModule.OnRelatedObjectCreating(virtualState);
State = RTLPipelineStageTools.RecurviseResetToDefaults(stageMapWithState(stageInputs, virtualState));
var virtualNextState = RTLModuleHelper.Activate <TOutput>();
rtlModule.OnRelatedObjectCreating(virtualNextState);
NextState = RTLPipelineStageTools.RecurviseResetToDefaults(stageMapWithState(nextStageInputs, virtualNextState));
}
else if (stageMapWithStateAndControl != null)
{
var virtualState = RTLModuleHelper.Activate <TOutput>();
rtlModule.OnRelatedObjectCreating(virtualState);
State = RTLPipelineStageTools.RecurviseResetToDefaults(stageMapWithStateAndControl(stageInputs, virtualState, ManagedSignals));
var virtualNextState = RTLModuleHelper.Activate <TOutput>();
rtlModule.OnRelatedObjectCreating(virtualNextState);
NextState = RTLPipelineStageTools.RecurviseResetToDefaults(stageMapWithStateAndControl(nextStageInputs, virtualNextState, ManagedSignals));
}
else
{
throw new Exception($"Pipeline stage is not initialized with scheduling method");
}
RTLPipelineStageTools.CarryOverAutoPropagateValues(stageInputs, State);
rtlModule.OnRelatedObjectCreating(State);
RTLPipelineStageTools.CarryOverAutoPropagateValues(nextStageInputs, NextState);
rtlModule.OnRelatedObjectCreating(NextState);
}
nextStage?.StageSchedule(() => State);
}
public static T RecurviseResetToDefaults <T>(T value)
{
var type = value.GetType();
foreach (var m in RTLReflectionTools.SynthesizableMembers(type))
{
var memberType = m.GetMemberType();
var memberValue = m.GetValue(value);
var backingField = getBackingField(value, m);
if (memberValue is RTLBitArray bitArray)
{
backingField.SetValue(value, new RTLBitArray().Resized(bitArray.Size).TypeChanged(bitArray.DataType));
continue;
}
if (RTLModuleHelper.IsSynthesizableSignalType(memberType))
{
if (RTLReflectionTools.TryGetNullableType(memberType, out var actualType))
{
backingField.SetValue(value, Activator.CreateInstance(actualType));
}
else
{
backingField.SetValue(value, Activator.CreateInstance(memberType));
}
continue;
}
if (RTLModuleHelper.IsSynthesizableObject(memberType))
{
RecurviseResetToDefaults(memberValue);
continue;
}
if (RTLModuleHelper.IsSynthesizableArrayType(memberType))
{
var emptyArray = Array.CreateInstance(memberType.GetElementType(), (memberValue as Array).Length);
backingField.SetValue(value, emptyArray);
continue;
}
}
return(value);
}
protected override void OnSetup()
{
base.OnSetup();
// do not create default state object if it was already assigned in ctor
if (State == null)
{
State = CreateAndInitializeRelatedObject <TState>();
}
NextState = CreateAndInitializeRelatedObject <TState>();
PipelineProps = RTLModuleHelper.PipelineProperties(GetType());
foreach (var head in Pipelines.Select(pl => pl.Diag.Head))
{
head.Setup(this);
}
// store default state for reset logic
DefaultState = CopyState();
}
public virtual void PopulateSnapshot(VCDSignalsSnapshot snapshot, RTLModuleSnapshotConfig config = null)
{
config = config ?? RTLModuleSnapshotConfig.Default;
try
{
if (config.IsIncluded(RTLModuleSnapshotConfigInclude.Inputs))
{
currentSnapshot = snapshot.Scope("Inputs");
foreach (var prop in InputProps)
{
currentMember = prop;
var value = currentMember.GetValue(Inputs);
currentSnapshot.SetVariables(ToVCDVariables(currentMember, value));
}
}
if (config.IsIncluded(RTLModuleSnapshotConfigInclude.Outputs))
{
currentSnapshot = snapshot.Scope("Outputs");
foreach (var prop in OutputProps)
{
currentMember = prop;
var value = currentMember.GetValue(this);
currentSnapshot.SetVariables(ToVCDVariables(currentMember, value));
}
}
if (config.IsIncluded(RTLModuleSnapshotConfigInclude.Internals))
{
currentSnapshot = snapshot.Scope("Internals");
foreach (var prop in InternalProps)
{
currentMember = prop;
var value = currentMember.GetValue(this);
currentSnapshot.SetVariables(ToVCDVariables(currentMember, value));
}
}
if (config.IsIncluded(RTLModuleSnapshotConfigInclude.Modules))
{
currentSnapshot = null;
foreach (var m in ModuleProps.Where(m => RTLModuleHelper.IsField(m)))
{
var value = m.GetValue(this);
currentMember = m;
if (value is IRTLCombinationalModule module)
{
var moduleScope = snapshot.Scope(m.Name);
module.PopulateSnapshot(moduleScope);
continue;
}
// TODO: support for modules array
}
}
}
catch (VCDSnapshotException)
{
throw;
}
catch (Exception ex)
{
ThrowVCDException(ex);
}
}
protected virtual IEnumerable <VCDVariable> ToVCDVariables(string name, object value, bool includeToolkitTypes = false)
{
if (value == null)
{
return(Enumerable.Empty <VCDVariable>());
}
var recursivePrefix = string.IsNullOrEmpty(name) ? "" : $"{name}_";
switch (value)
{
case Enum v:
return(new[]
{
new VCDVariable($"{name}ToString", value.ToString(), VCDSizeOfValue("")),
new VCDVariable($"{name}", value, VCDSizeOfValue(value))
});
case RTLBitArray b:
return(new[]
{
new VCDVariable($"{name}", value, VCDSizeOfValue(value))
});
default:
var valueType = value.GetType();
if (value.GetType().IsClass)
{
var result = new List <VCDVariable>();
var props = RTLReflectionTools.SynthesizableMembers(valueType, includeToolkitTypes);
foreach (var m in props)
{
var memberValue = m.GetValue(value) ?? RTLModuleHelper.Activate(m.GetMemberType());
result.AddRange(ToVCDVariables(m, memberValue, recursivePrefix));
}
return(result);
}
if (valueType.IsConstructedGenericType)
{
var genericType = valueType.GetGenericTypeDefinition();
// TODO: something smarter then this
if (genericType.Name.StartsWith("ValueTuple`"))
{
var result = new List <VCDVariable>();
var props = RTLReflectionTools.SynthesizableMembers(valueType, includeToolkitTypes).Where(m => m.Name.StartsWith("Item"));
foreach (var m in props)
{
var memberValue = m.GetValue(value) ?? RTLModuleHelper.Activate(m.GetMemberType());
result.AddRange(ToVCDVariables(m, memberValue, recursivePrefix));
}
return(result);
}
}
return(new[]
{
new VCDVariable($"{name}", value, VCDSizeOfValue(value))
});
}
}
