/// <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 }; }