public Computable(Output con)
{
this.Node = null;
this.Con = con;
this.IsBorderIO = con.Node is Module || con.Node is Wire;
this.OldValue = new BinaryVarValue();
}
internal static void VerifyInferTypes(string moduleName, string extension, bool isVerilogVCD, string modulePath)
{
CircuitGraph graph = VerifyMakeGraph(moduleName, extension, modulePath);
using VCD vcd = LoadVCD(moduleName, modulePath);
foreach (var variables in vcd.Variables)
{
foreach (var variable in variables)
{
ScalarIO varCon = graph.GetConnection(variable, isVerilogVCD);
if (varCon == null)
{
continue;
}
ref BinaryVarValue actual = ref varCon.GetValue();
if (!varCon.Value.IsInitialized())
{
continue;
}
if (variable.Size != actual.Bits.Length)
{
Console.WriteLine($"Ref: {variable.Reference}, Expected: {variable.Size}, Actual: {actual.Bits.Length}");
}
Assert.AreEqual(variable.Size, actual.Bits.Length);
}
}
public Computable(FIRRTLNode node)
{
this.Node = node;
this.Con = null;
this.IsBorderIO = false;
this.OldValue = new BinaryVarValue();
}
public ValueType(GroundType type)
{
this.IsSigned = type is SIntType;
this.HasInitialized = true;
this.Value = new BinaryVarValue(type.Width, false);
Value.SetAllUnknown();
this.ValueString = null;
}
public override void Compute()
{
//Copy input values to outputs
for (int i = 0; i < VecInputs.Length; i++)
{
if (VecInputs[i].IsConnectedToAnything())
{
ref BinaryVarValue binValue = ref VecInputs[i].UpdateValueFromSourceFast();
VecOutputs[i].Value.UpdateValue(ref binValue);
}
public override void Compute()
{
if (FirstCompute)
{
FirstCompute = false;
BinaryVarValue binValue = new BinaryVarValue(Value.Width, true);
binValue.SetBitsAndExtend(Value.Value, false);
Result.Value.UpdateValue(ref binValue);
}
}
public void InferType()
{
if (Node != null)
{
Node.InferType();
}
else
{
Con.InferType();
Con.SetDefaultvalue();
OldValue = new BinaryVarValue(Con.GetValue().Bits.Length, false);
OldValue.SetAllUnknown();
foreach (var input in Con.GetConnectedInputs())
{
input.InferType();
input.SetDefaultvalue();
}
}
}
public bool SameValue(ref BinaryVarValue other)
{
ReadOnlySpan <BitState> rBits = Bits;
ReadOnlySpan <BitState> rBitsOther = other.Bits;
if (rBits.Length != rBitsOther.Length)
{
return(false);
}
//xor of two equivalent values gives 0 and anything else
//gives not 0. If check can be replaced with this check by checking
//that all xors give 0 in return. That's how this check work. In
//addition to that, poor simd is used to xor 8 BitStates at once.
ulong xored = 0;
int index = 0;
if (rBits.Length >= sizeof(ulong))
{
ReadOnlySpan <ulong> uBits = MemoryMarshal.Cast <BitState, ulong>(rBits);
ReadOnlySpan <ulong> uBitsOther = MemoryMarshal.Cast <BitState, ulong>(rBitsOther);
for (; index < uBits.Length; index++)
{
xored |= uBits[index] ^ uBitsOther[index];
}
const int sizeDiff = sizeof(BitState) / sizeof(ulong);
index *= sizeDiff;
}
for (; index < rBits.Length; index++)
{
xored |= (ulong)rBits[index] ^ (ulong)rBitsOther[index];
}
return(xored == 0);
}
public bool SameValue(ref BinaryVarValue other, bool isSigned)
{
if (Bits.Length == other.Bits.Length)
{
return(SameValue(ref other));
}
ReadOnlySpan <BitState> minL = Bits.Length < other.Bits.Length ? Bits : other.Bits;
ReadOnlySpan <BitState> maxL = Bits.Length < other.Bits.Length ? other.Bits : Bits;
if (minL.Length == 0)
{
for (int i = 0; i < maxL.Length; i++)
{
if (maxL[i] != BitState.Zero)
{
return(false);
}
}
return(true);
}
BitState expectedRemainer = isSigned ? minL[^ 1] : BitState.Zero;
internal void AddChange(BinaryVarValue value)
{
var variable = value.Variables[0];
VariableValues[variable.ID] = value;
}
public void UpdateValue(ref BinaryVarValue update)
{
Value.SetBitsAndExtend(ref update, IsSigned);
}
