/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="inputWidth">bit-width of operand</param>
/// <param name="hiOffset">high slice offset</param>
/// <param name="loOffset">low slice offset</param>
/// <param name="signed">whether operand is signed</param>
public Slicer(int inputWidth, int hiOffset, int loOffset, bool signed)
{
Contract.Requires <ArgumentOutOfRangeException>(hiOffset - loOffset >= -1);
InputWidth = inputWidth;
HiOffset = hiOffset;
LoOffset = loOffset;
IsSigned = signed;
TASite = new SlicerTransactionSite(this);
int msb = signed ? inputWidth - 2 : inputWidth - 1;
int hiPadWidth = Math.Max(hiOffset, msb) - Math.Max(loOffset, msb + 1) + 1;
int loPadWidth = Math.Min(hiOffset, -1) - Math.Min(loOffset, 0) + 1;
_hiSlice = Math.Min(msb, hiOffset);
_loSlice = Math.Max(0, loOffset);
if (_loSlice > _hiSlice)
{
// degenerate case: actually no portion of input word is used
_hiSlice = -1;
_loSlice = 0;
}
_hiPad0 = StdLogicVector._0s(hiPadWidth);
_hiPad1 = StdLogicVector._1s(hiPadWidth);
_loPad = StdLogicVector._0s(loPadWidth);
Debug.Assert(hiPadWidth + loPadWidth + _hiSlice - _loSlice == hiOffset - loOffset);
}
protected async Task <StdLogicVector> MasterRead(StdLogicVector addr)
{
ip2bus_mstrd_req.Next = '1';
ip2bus_mstwr_req.Next = '0';
ip2bus_mst_type.Next = '0';
ip2bus_mst_addr.Next = addr;
ip2bus_mst_be.Next = StdLogicVector._1s(NativeDataWidth / 8);
ip2bus_mst_length.Next = StdLogicVector._0s(LengthWidth);
ip2bus_mst_lock.Next = '0';
ip2bus_mst_reset.Next = '0';
ip2bus_mstrd_dst_rdy_n.Next = '0';
ip2bus_mstrd_dst_dsc_n.Next = '1';
do
{
await Tick;
} while (bus2ip_mst_cmdack.Cur != '1');
ip2bus_mstrd_req.Next = '0';
do
{
await Tick;
} while (bus2ip_mst_cmplt.Cur != '1');
ip2bus_mstrd_dst_rdy_n.Next = '1';
return(bus2ip_mstrd_d.Cur);
}
private StdLogicVector CreateVector()
{
StdLogicVector[] r = new StdLogicVector[4];
r[0] = StdLogicVector._0s(MaxWidth);
r[1] = StdLogicVector._1s(MaxWidth);
r[2] = StdLogicVector.DCs(MaxWidth);
r[3] = StdLogicVector.Xs(MaxWidth);
return(r[0].Concat(r[1].Concat(r[2].Concat(r[3]))));
}
/// <summary>
/// Converts a double value to its binary encoding, given a floating point format.
/// </summary>
/// <param name="value">The value to be encoded</param>
/// <param name="fmt">The floating point format to be assumed</param>
/// <returns>The binary encoding</returns>
public static StdLogicVector ToSLV(this double value, FloatFormat fmt)
{
StdLogicVector sign;
StdLogicVector exponent;
StdLogicVector mantissa;
if (double.IsInfinity(value))
{
sign = double.IsNegativeInfinity(value) ? (StdLogicVector)"1" : (StdLogicVector)"0";
exponent = StdLogicVector._1s(fmt.ExponentWidth);
mantissa = StdLogicVector._0s(fmt.FractionWidth);
}
else if (double.IsNaN(value))
{
sign = (StdLogicVector)"0";
exponent = StdLogicVector._1s(fmt.ExponentWidth);
mantissa = StdLogicVector._1s(fmt.FractionWidth);
}
else
{
sign = value < 0.0 ? (StdLogicVector)"1" : (StdLogicVector)"0";
double absvalue = Math.Abs(value);
int exp = 0;
while (absvalue >= 2.0)
{
absvalue *= 0.5;
exp++;
}
while (absvalue > 0.0 && absvalue < 1.0)
{
absvalue *= 2.0;
exp--;
}
if (absvalue == 0.0)
{
return(StdLogicVector._0s(fmt.TotalWidth));
}
else if (exp <= -fmt.Bias)
{
// denomalized
exponent = StdLogicVector._0s(fmt.ExponentWidth);
absvalue *= (double)(1L << (fmt.FractionWidth + 1));
long mant = (long)absvalue;
mantissa = StdLogicVector.FromLong(mant, fmt.FractionWidth);
}
else
{
absvalue -= 1.0;
absvalue *= (double)(1L << fmt.FractionWidth);
long mant = (long)absvalue;
mantissa = StdLogicVector.FromLong(mant, fmt.FractionWidth);
exponent = StdLogicVector.FromLong(exp + fmt.Bias, fmt.ExponentWidth);
}
}
return(sign.Concat(exponent.Concat(mantissa)));
}
/// <summary>
/// Converts a binary encoding, given as an StdLogicVector with respect to a floating point format to its
/// double representation.
/// </summary>
/// <param name="slv">The binary encoding</param>
/// <param name="fmt">The floating point format to be assumed</param>
/// <returns>The double representation</returns>
public static double ToFloat(this StdLogicVector slv, FloatFormat fmt)
{
if (slv.Size != fmt.TotalWidth)
{
throw new ArgumentException("Vector does not match specified floating point format");
}
slv = slv.ProperValue;
StdLogicVector mantissa = slv[fmt.FractionWidth - 1, 0];
StdLogicVector exponent = slv[fmt.FractionWidth + fmt.ExponentWidth - 1, fmt.FractionWidth];
StdLogic sign = slv[fmt.FractionWidth + fmt.ExponentWidth];
int exp = (int)exponent.ULongValue - fmt.Bias;
if (exponent.Equals(StdLogicVector._0s(fmt.ExponentWidth)))
{
// denormalized
long mant = mantissa.LongValue;
double result = (double)mant * Math.Pow(2.0, exp - 1);
return(result);
}
else if (exponent.Equals(StdLogicVector._1s(fmt.ExponentWidth)))
{
// Infinity / NaN
if (mantissa.Equals(StdLogicVector._0s(fmt.FractionWidth)))
{
// infinity
if (sign == '1')
{
return(double.NegativeInfinity);
}
else
{
return(double.PositiveInfinity);
}
}
else
{
// NaN
return(double.NaN);
}
}
else
{
// normalized
StdLogicVector number = StdLogicVector._1s(1).Concat(mantissa);
ulong mant = number.ULongValue;
double result = (double)mant * Math.Pow(2.0, exp - fmt.FractionWidth);
if (sign == '1')
{
result = -result;
}
return(result);
}
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="inIntWidth">operand integer bits</param>
/// <param name="fracWidth">operand and result fractional bits
/// (operand and result automatically have same number of fractional bits)</param>
/// <param name="outIntWidth">result integer bits</param>
public FixFPMod1(int inIntWidth, int fracWidth, int outIntWidth)
{
Contract.Requires(inIntWidth >= 2 && outIntWidth >= 2);
InIntWidth = inIntWidth;
OutIntWidth = outIntWidth;
FracWidth = fracWidth;
_zeroes = StdLogicVector._0s(FracWidth);
_padZeroes = StdLogicVector._0s(OutIntWidth - 1);
_padOnes = StdLogicVector._1s(OutIntWidth - 1);
TASite = new FPMod1TransactionSite(this);
}
protected override void PreInitialize()
{
if (StartupAddr.Size != AddrWidth)
{
throw new InvalidOperationException("BCU: Invalid startup address");
}
_lastAddr = new SLVSignal(StdLogicVector._0s(AddrWidth));
_outAddr = new SLVSignal(AddrWidth);
if (Latency > 1)
{
_rstPat = StdLogicVector._1s(Latency - 1);
_rstq = new SLVSignal(_rstPat);
}
}
protected async void MasterWrite(StdLogicVector addr, StdLogicVector data)
{
ip2bus_mstrd_req.Next = '0';
ip2bus_mstwr_req.Next = '1';
ip2bus_mst_type.Next = '0';
ip2bus_mst_addr.Next = addr;
ip2bus_mst_be.Next = StdLogicVector._1s(NativeDataWidth / 8);
ip2bus_mst_length.Next = StdLogicVector._0s(LengthWidth);
ip2bus_mst_lock.Next = '0';
ip2bus_mst_reset.Next = '0';
ip2bus_mstwr_d.Next = data;
ip2bus_mstwr_rem.Next = StdLogicVector._0s(NativeDataWidth / 8);
ip2bus_mstwr_sof_n.Next = '0';
ip2bus_mstwr_eof_n.Next = '0';
ip2bus_mstwr_src_rdy_n.Next = '0';
ip2bus_mstwr_src_dsc_n.Next = '1';
do
{
await Tick;
} while (bus2ip_mst_cmdack.Cur != '1');
do
{
ip2bus_mstwr_req.Next = '0';
if (bus2ip_mstwr_dst_rdy_n.Cur == '0')
{
break;
}
await Tick;
} while (true);
ip2bus_mstwr_src_rdy_n.Next = '1';
ip2bus_mstwr_sof_n.Next = '1';
ip2bus_mstwr_eof_n.Next = '1';
await Tick;
ProgramFlow.IOBarrier();
}
public override void Establish(IAutoBinder binder)
{
if (_allocated)
{
return;
}
_brAltFlagP = (SLVSignal)binder.GetSignal(EPortUsage.Default, "BCU_BrP", null, StdLogicVector._0s(1));
_brAltFlagN = (SLVSignal)binder.GetSignal(EPortUsage.Default, "BCU_BrN", null, StdLogicVector._1s(1));
_curState = binder.GetSignal(EPortUsage.State, "BCU_CurState", null, null).Descriptor;
_tState = _curState.ElementType.CILType;
Array enumValues = _tState.GetEnumValues();
int numStates = enumValues.Length;
object defaultState = Activator.CreateInstance(_tState);
_incState = binder.GetSignal(EPortUsage.Default, "BCU_IncState", null, defaultState).Descriptor;
_altState = binder.GetSignal(EPortUsage.Default, "BCU_AltState", null, defaultState).Descriptor;
_nextState = binder.GetSignal(EPortUsage.Default, "BCU_NextState", null, defaultState).Descriptor;
IncStateProcessBuilder ispb = new IncStateProcessBuilder(this);
Function incStateFn = ispb.GetAlgorithm();
incStateFn.Name = "BCU_IncState";
binder.CreateProcess(Process.EProcessKind.Triggered, incStateFn, _curState);
SyncProcessBuilder spb = new SyncProcessBuilder(this, binder);
Function syncStateFn = spb.GetAlgorithm();
syncStateFn.Name = "BCU_FSM";
ISignalOrPortDescriptor sdClock = binder.GetSignal <StdLogic>(EPortUsage.Clock, "Clk", null, '0').Descriptor;
binder.CreateProcess(Process.EProcessKind.Triggered, syncStateFn, sdClock);
_allocated = true;
}
/// <summary>
/// Creates an instance of a Counter component.
/// </summary>
/// <param name="width">the desired bit-width of the counter</param>
public Counter(int width)
{
_ctr = new SLVSignal(StdLogicVector._1s(width));
}
/// <summary>
/// Creates an instance.
/// </summary>
/// <param name="userLogic">component under test</param>
public AXIMasterUserLogicTestbench(AXIMasterUserLogic userLogic)
{
user_logic = userLogic;
_sig_Bus2IP_Clk = new SLSignal();
_sig_Bus2IP_Resetn = new SLSignal()
{
InitialValue = '0'
};
_sig_Bus2IP_Data = new SLVSignal(userLogic.SLVDWidth)
{
InitialValue = StdLogicVector.Xs(userLogic.SLVDWidth)
};
_sig_Bus2IP_BE = new SLVSignal(userLogic.SLVDWidth / 8)
{
InitialValue = StdLogicVector._0s(userLogic.SLVDWidth / 8)
};
_sig_Bus2IP_RdCE = new SLVSignal(userLogic.NumRegs)
{
InitialValue = StdLogicVector._0s(userLogic.NumRegs)
};
_sig_Bus2IP_WrCE = new SLVSignal(userLogic.NumRegs)
{
InitialValue = StdLogicVector._0s(userLogic.NumRegs)
};
_sig_IP2Bus_Data = new SLVSignal(userLogic.SLVDWidth)
{
InitialValue = StdLogicVector._0s(userLogic.SLVDWidth)
};
_sig_IP2Bus_RdAck = new SLSignal()
{
InitialValue = '0'
};
_sig_IP2Bus_WrAck = new SLSignal()
{
InitialValue = '0'
};
_sig_IP2Bus_Error = new SLSignal()
{
InitialValue = '0'
};
_sig_ip2bus_mstrd_req = new SLSignal()
{
InitialValue = '0'
};
_sig_ip2bus_mstwr_req = new SLSignal()
{
InitialValue = '0'
};
_sig_ip2bus_mst_addr = new SLVSignal(userLogic.MasterAXIAddrWidth)
{
InitialValue = StdLogicVector.Us(userLogic.MasterAXIAddrWidth)
};
_sig_ip2bus_mst_be = new SLVSignal(userLogic.NativeDataWidth / 8)
{
InitialValue = StdLogicVector._1s(userLogic.NativeDataWidth / 8)
};
_sig_ip2bus_mst_length = new SLVSignal(userLogic.LengthWidth)
{
InitialValue = StdLogicVector._0s(userLogic.LengthWidth)
};
_sig_ip2bus_mst_type = new SLSignal()
{
InitialValue = '0'
};
_sig_ip2bus_mst_lock = new SLSignal()
{
InitialValue = '0'
};
_sig_ip2bus_mst_reset = new SLSignal()
{
InitialValue = '0'
};
_sig_bus2ip_mst_cmdack = new SLSignal()
{
InitialValue = '0'
};
_sig_bus2ip_mst_cmplt = new SLSignal()
{
InitialValue = '0'
};
_sig_bus2ip_mst_error = new SLSignal()
{
InitialValue = '0'
};
_sig_bus2ip_mst_rearbitrate = new SLSignal()
{
InitialValue = '0'
};
_sig_bus2ip_mst_cmd_timeout = new SLSignal()
{
InitialValue = '0'
};
_sig_bus2ip_mstrd_d = new SLVSignal(userLogic.NativeDataWidth);
_sig_bus2ip_mstrd_rem = new SLVSignal(userLogic.NativeDataWidth / 8)
{
InitialValue = StdLogicVector._0s(userLogic.NativeDataWidth / 8)
};
_sig_bus2ip_mstrd_sof_n = new SLSignal()
{
InitialValue = '0'
};
_sig_bus2ip_mstrd_eof_n = new SLSignal()
{
InitialValue = '0'
};
_sig_bus2ip_mstrd_src_rdy_n = new SLSignal()
{
InitialValue = '1'
};
_sig_bus2ip_mstrd_src_dsc_n = new SLSignal()
{
InitialValue = '1'
};
_sig_ip2bus_mstrd_dst_rdy_n = new SLSignal()
{
InitialValue = '1'
};
_sig_ip2bus_mstrd_dst_dsc_n = new SLSignal()
{
InitialValue = '1'
};
_sig_ip2bus_mstwr_d = new SLVSignal(userLogic.NativeDataWidth);
_sig_ip2bus_mstwr_rem = new SLVSignal(userLogic.NativeDataWidth / 8)
{
InitialValue = StdLogicVector._0s(userLogic.NativeDataWidth / 8)
};
_sig_ip2bus_mstwr_src_rdy_n = new SLSignal()
{
InitialValue = '1'
};
_sig_ip2bus_mstwr_src_dsc_n = new SLSignal()
{
InitialValue = '1'
};
_sig_ip2bus_mstwr_sof_n = new SLSignal()
{
InitialValue = '1'
};
_sig_ip2bus_mstwr_eof_n = new SLSignal()
{
InitialValue = '1'
};
_sig_bus2ip_mstwr_dst_rdy_n = new SLSignal()
{
InitialValue = '1'
};
_sig_bus2ip_mstwr_dst_dsc_n = new SLSignal()
{
InitialValue = '1'
};
userLogic.Bus2IP_Clk = _sig_Bus2IP_Clk;
userLogic.Bus2IP_BE = _sig_Bus2IP_BE;
userLogic.Bus2IP_Clk = _sig_Bus2IP_Clk;
userLogic.Bus2IP_Data = _sig_Bus2IP_Data;
userLogic.Bus2IP_RdCE = _sig_Bus2IP_RdCE;
userLogic.Bus2IP_Resetn = _sig_Bus2IP_Resetn;
userLogic.Bus2IP_WrCE = _sig_Bus2IP_WrCE;
userLogic.IP2Bus_Data = _sig_IP2Bus_Data;
userLogic.IP2Bus_Error = _sig_IP2Bus_Error;
userLogic.IP2Bus_RdAck = _sig_IP2Bus_RdAck;
userLogic.IP2Bus_WrAck = _sig_IP2Bus_WrAck;
userLogic.ip2bus_mstrd_req = _sig_ip2bus_mstrd_req;
userLogic.ip2bus_mstwr_req = _sig_ip2bus_mstwr_req;
userLogic.ip2bus_mst_addr = _sig_ip2bus_mst_addr;
userLogic.ip2bus_mst_be = _sig_ip2bus_mst_be;
userLogic.ip2bus_mst_length = _sig_ip2bus_mst_length;
userLogic.ip2bus_mst_type = _sig_ip2bus_mst_type;
userLogic.ip2bus_mst_lock = _sig_ip2bus_mst_lock;
userLogic.ip2bus_mst_reset = _sig_ip2bus_mst_reset;
userLogic.bus2ip_mst_cmdack = _sig_bus2ip_mst_cmdack;
userLogic.bus2ip_mst_cmplt = _sig_bus2ip_mst_cmplt;
userLogic.bus2ip_mst_error = _sig_bus2ip_mst_error;
userLogic.bus2ip_mst_rearbitrate = _sig_bus2ip_mst_rearbitrate;
userLogic.bus2ip_mst_cmd_timeout = _sig_bus2ip_mst_cmd_timeout;
userLogic.bus2ip_mstrd_d = _sig_bus2ip_mstrd_d;
userLogic.bus2ip_mstrd_rem = _sig_bus2ip_mstrd_rem;
userLogic.bus2ip_mstrd_sof_n = _sig_bus2ip_mstrd_sof_n;
userLogic.bus2ip_mstrd_eof_n = _sig_bus2ip_mstrd_eof_n;
userLogic.bus2ip_mstrd_src_rdy_n = _sig_bus2ip_mstrd_src_rdy_n;
userLogic.bus2ip_mstrd_src_dsc_n = _sig_bus2ip_mstrd_src_dsc_n;
userLogic.ip2bus_mstrd_dst_rdy_n = _sig_ip2bus_mstrd_dst_rdy_n;
userLogic.ip2bus_mstrd_dst_dsc_n = _sig_ip2bus_mstrd_dst_dsc_n;
userLogic.ip2bus_mstwr_d = _sig_ip2bus_mstwr_d;
userLogic.ip2bus_mstwr_rem = _sig_ip2bus_mstwr_rem;
userLogic.ip2bus_mstwr_src_rdy_n = _sig_ip2bus_mstwr_src_rdy_n;
userLogic.ip2bus_mstwr_src_dsc_n = _sig_ip2bus_mstwr_src_dsc_n;
userLogic.ip2bus_mstwr_sof_n = _sig_ip2bus_mstwr_sof_n;
userLogic.ip2bus_mstwr_eof_n = _sig_ip2bus_mstwr_eof_n;
userLogic.bus2ip_mstwr_dst_rdy_n = _sig_bus2ip_mstwr_dst_rdy_n;
userLogic.bus2ip_mstwr_dst_dsc_n = _sig_bus2ip_mstwr_dst_dsc_n;
_clockGen = new Clock(new Time(10.0, ETimeUnit.ns))
{
Clk = _sig_Bus2IP_Clk
};
}
