AdvTester

Instance Constructors

new AdvTester(dut: T, base: Int = 16, logFile: Option[File] = chiselMain.context.logFile)

Type Members

class DecoupledSink[T <: Data, R] extends IrrevocableSink[T, R]
class DecoupledSource[T <: Data, R] extends Processable
class IrrevocableSink[T <: Data, R] extends Processable
class ValidSink[T <: Data, R] extends Processable
class ValidSource[T <: Data, R] extends Processable

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object DecoupledSink
object DecoupledSource
object IrrevocableSink
object ValidSink
object ValidSource
implicit val _base: Int

Definition Classes
PeekPokeTester
var _cycles: Long
implicit val _verbose: Boolean

Definition Classes
PeekPokeTester
final def asInstanceOf[T0]: T0

Definition Classes
Any
def assert(expr: Boolean, errMsg: String = ""): Boolean
val backend: Backend

*************************
*************************

Definition Classes
PeekPokeTester
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cycles: Long
val defaultMaxCycles: Long
def do_until(work: ⇒ Unit)(pred: ⇒ Boolean, maxCycles: Long = defaultMaxCycles): Boolean
val dut: T

Definition Classes
PeekPokeTester
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def eventually(pred: ⇒ Boolean, maxCycles: Long = defaultMaxCycles): Boolean
def expect(signal: Bundle, expected: Map[String, BigInt]): Boolean

Return true or false if an aggregate signal (Bundle) matches the expected map of values.
Return true or false if an aggregate signal (Bundle) matches the expected map of values. TODO: deal with Vecs
signal
the Bundle to "expect"
expected
a map of signal names ("dotted" Bundle notation) to BigInt values
returns
true if the specified values match, false otherwise.

Definition Classes
PeekPokeTester
def expect(signal: Aggregate, expected: IndexedSeq[BigInt]): Boolean

Definition Classes
PeekPokeTester
def expect[T <: Element](signal: T, expected: Int, msg: ⇒ String)(implicit arg0: Pokeable[T]): Boolean

Definition Classes
PeekPokeTester
def expect[T <: Element](signal: T, expected: BigInt, msg: ⇒ String = "")(implicit arg0: Pokeable[T]): Boolean

Definition Classes
PeekPokeTester
def expect(good: Boolean, msg: ⇒ String): Boolean

Definition Classes
PeekPokeTester
def expectFixedPoint(signal: FixedPoint, expected: Double, msg: ⇒ String, epsilon: Double = 0.01): Boolean

Uses a Double as the expected value
Uses a Double as the expected value
Consider using the more reliable expectFixedPointBig
signal
signal
expected
value expected
msg
message on failure
epsilon
error bounds on expected value are +/- epsilon

Definition Classes
PeekPokeTester
def expectFixedPointBig(signal: FixedPoint, expected: BigDecimal, msg: ⇒ String, epsilon: BigDecimal = 0.01): Boolean

Uses a BigDecimal as the expected value
Uses a BigDecimal as the expected value
signal
signal
expected
value expected
msg
message on failure
epsilon
error bounds on expected value are +/- epsilon

Definition Classes
PeekPokeTester
def expectInterval(signal: Interval, expected: Double, msg: ⇒ String, epsilon: Double = 0.01): Boolean

Uses a Double as the expected value
Uses a Double as the expected value
Consider using the more reliable expectIntervalBig
signal
signal
expected
value expected
msg
message on failure
epsilon
error bounds on expected value are +/- epsilon

Definition Classes
PeekPokeTester
def expectIntervalBig(signal: Interval, expected: BigDecimal, msg: ⇒ String, epsilon: BigDecimal = 0.01): Boolean

Uses a BigDecimal as the expected value
Uses a BigDecimal as the expected value
signal
signal
expected
value expected
msg
message on failure
epsilon
error bounds on expected value are +/- epsilon

Definition Classes
PeekPokeTester
def fail: Unit

Definition Classes
PeekPokeTester
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def finish: Boolean

Definition Classes
PeekPokeTester
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def incTime(n: Int): Unit

Definition Classes
AdvTester → PeekPokeTester
implicit def int[T <: Element](x: T)(implicit arg0: Pokeable[T]): BigInt

Convert Pokeables to BigInt
Convert Pokeables to BigInt

Definition Classes
PeekPokeTester
implicit def int(x: Boolean): BigInt

Convert a Boolean to BigInt
Convert a Boolean to BigInt

Definition Classes
PeekPokeTester
def intToUnsignedBigInt(x: Int): BigInt

Convert an Int to unsigned (effectively 32-bit) BigInt
Convert an Int to unsigned (effectively 32-bit) BigInt
x
number to be converted

Definition Classes
PeekPokeTester
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit val logger: TestErrorLog

Definition Classes
PeekPokeTester
implicit def longToInt(x: Long): Int

Definition Classes
PeekPokeTester
def longToUnsignedBigInt(x: Long): BigInt

Convert an Int to unsigned (effectively 64-bit) BigInt
Convert an Int to unsigned (effectively 64-bit) BigInt
x
long to be converted

Definition Classes
PeekPokeTester
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val optionsManager: TesterOptionsManager

Definition Classes
PeekPokeTester
def peek(signal: Bundle): LinkedHashMap[String, BigInt]

Peek an aggregate (Bundle) signal.
Peek an aggregate (Bundle) signal.
signal
the signal to peek
returns
a map of signal names ("dotted" Bundle) to BigInt values.

Definition Classes
PeekPokeTester
def peek(signal: Aggregate): Seq[BigInt]

Definition Classes
PeekPokeTester
def peek[T <: Element](signal: T)(implicit arg0: Pokeable[T]): BigInt

Definition Classes
PeekPokeTester
def peek(path: String): BigInt

Definition Classes
PeekPokeTester
def peekAt[TT <: Element](data: MemBase[TT], off: Int)(implicit arg0: Pokeable[TT]): BigInt

Definition Classes
PeekPokeTester
def peekFixedPoint(signal: FixedPoint): Double

Returns the value signal as a Double.
Returns the value signal as a Double. Double may not be big enough to contain the value without precision loss. This situation will Throw ChiselException Consider using the more reliable peekFixedPointBig

Definition Classes
PeekPokeTester
def peekFixedPointBig(signal: FixedPoint): BigDecimal

returns the value of signal as BigDecimal
returns the value of signal as BigDecimal

Definition Classes
PeekPokeTester
def peekInterval(signal: Interval): Double

Returns the value signal as a Double.
Returns the value signal as a Double. Double may not be big enough to contain the value without precision loss. This situation will Throw ChiselException Consider using the more reliable peekIntervalBig

Definition Classes
PeekPokeTester
def peekIntervalBig(signal: Interval): BigDecimal

returns the value of signal as BigDecimal
returns the value of signal as BigDecimal

Definition Classes
PeekPokeTester
def poke[T <: Element](port: T, target: BigInt)(implicit arg0: Pokeable[T]): Unit

Definition Classes
AdvTester → PeekPokeTester
def poke(signal: Aggregate, value: IndexedSeq[BigInt]): Unit

Definition Classes
PeekPokeTester
def poke(signal: Bundle, map: Map[String, BigInt]): Unit

Poke a Bundle given a map of elements and values.
Poke a Bundle given a map of elements and values.
signal
the bundle to be poked
map
a map from names (using '.' to delimit bundle elements), to BigInt values

Definition Classes
PeekPokeTester
def poke[T <: Element](signal: T, value: Long)(implicit arg0: Pokeable[T]): Unit

Definition Classes
PeekPokeTester
def poke[T <: Element](signal: T, value: Int)(implicit arg0: Pokeable[T]): Unit

Definition Classes
PeekPokeTester
def poke(path: String, value: Long): Unit

Definition Classes
PeekPokeTester
def poke(path: String, value: Int): Unit

Definition Classes
PeekPokeTester
def poke(path: String, value: BigInt): Unit

Definition Classes
PeekPokeTester
def pokeAt[TT <: Element](data: MemBase[TT], value: BigInt, off: Int)(implicit arg0: Pokeable[TT]): Unit

Definition Classes
PeekPokeTester
def pokeFixedPoint(signal: FixedPoint, value: Double): Unit

Definition Classes
PeekPokeTester
def pokeFixedPointBig(signal: FixedPoint, value: BigDecimal): Unit

Definition Classes
PeekPokeTester
def pokeInterval(signal: Interval, value: Double): Unit

Definition Classes
PeekPokeTester
def pokeIntervalBig(signal: Interval, value: BigDecimal): Unit

Definition Classes
PeekPokeTester
val postprocessors: ArrayBuffer[Processable]
val preprocessors: ArrayBuffer[Processable]
def println(msg: String = ""): Unit

Definition Classes
PeekPokeTester
def reg_poke[T <: Element](port: T, target: BigInt)(implicit arg0: Pokeable[T]): Unit
def reset(n: Int = 1): Unit

Definition Classes
PeekPokeTester
val rnd: Random

Definition Classes
PeekPokeTester
def step(n: Int): Unit

Definition Classes
PeekPokeTester
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def t: Long

Definition Classes
PeekPokeTester
def takestep(work: ⇒ Unit = {}): Unit
def takesteps(n: Int)(work: ⇒ Unit = {}): Unit
def toString(): String

Definition Classes
AnyRef → Any
def until(pred: ⇒ Boolean, maxCycles: Long = defaultMaxCycles)(work: ⇒ Unit): Boolean
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def wire_poke[T <: Element](port: T, target: BigInt)(implicit arg0: Pokeable[T]): Unit

Related Doc: package iotesters

abstract class AdvTester[+T <: Module] extends PeekPokeTester[T]

Instance Constructors

new AdvTester(dut: T, base: Int = 16, logFile: Option[File] = chiselMain.context.logFile)

Type Members

class DecoupledSink[T <: Data, R] extends IrrevocableSink[T, R]

class DecoupledSource[T <: Data, R] extends Processable

class IrrevocableSink[T <: Data, R] extends Processable

class ValidSink[T <: Data, R] extends Processable

class ValidSource[T <: Data, R] extends Processable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object DecoupledSink

object DecoupledSource

object IrrevocableSink

object ValidSink

object ValidSource

implicit val _base: Int

var _cycles: Long

implicit val _verbose: Boolean

final def asInstanceOf[T0]: T0

def assert(expr: Boolean, errMsg: String = ""): Boolean

val backend: Backend

def clone(): AnyRef

def cycles: Long

val defaultMaxCycles: Long

def do_until(work: ⇒ Unit)(pred: ⇒ Boolean, maxCycles: Long = defaultMaxCycles): Boolean

val dut: T

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eventually(pred: ⇒ Boolean, maxCycles: Long = defaultMaxCycles): Boolean

def expect(signal: Bundle, expected: Map[String, BigInt]): Boolean

def expect(signal: Aggregate, expected: IndexedSeq[BigInt]): Boolean

def expect[T <: Element](signal: T, expected: Int, msg: ⇒ String)(implicit arg0: Pokeable[T]): Boolean

def expect[T <: Element](signal: T, expected: BigInt, msg: ⇒ String = "")(implicit arg0: Pokeable[T]): Boolean

def expect(good: Boolean, msg: ⇒ String): Boolean

def expectFixedPoint(signal: FixedPoint, expected: Double, msg: ⇒ String, epsilon: Double = 0.01): Boolean

def expectFixedPointBig(signal: FixedPoint, expected: BigDecimal, msg: ⇒ String, epsilon: BigDecimal = 0.01): Boolean

def expectInterval(signal: Interval, expected: Double, msg: ⇒ String, epsilon: Double = 0.01): Boolean

def expectIntervalBig(signal: Interval, expected: BigDecimal, msg: ⇒ String, epsilon: BigDecimal = 0.01): Boolean

def fail: Unit

def finalize(): Unit

def finish: Boolean

final def getClass(): Class[_]

def hashCode(): Int

def incTime(n: Int): Unit

implicit def int[T <: Element](x: T)(implicit arg0: Pokeable[T]): BigInt

implicit def int(x: Boolean): BigInt

def intToUnsignedBigInt(x: Int): BigInt

final def isInstanceOf[T0]: Boolean

implicit val logger: TestErrorLog

implicit def longToInt(x: Long): Int

def longToUnsignedBigInt(x: Long): BigInt

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val optionsManager: TesterOptionsManager

def peek(signal: Bundle): LinkedHashMap[String, BigInt]

def peek(signal: Aggregate): Seq[BigInt]

def peek[T <: Element](signal: T)(implicit arg0: Pokeable[T]): BigInt

def peek(path: String): BigInt

def peekAt[TT <: Element](data: MemBase[TT], off: Int)(implicit arg0: Pokeable[TT]): BigInt

def peekFixedPoint(signal: FixedPoint): Double

def peekFixedPointBig(signal: FixedPoint): BigDecimal

def peekInterval(signal: Interval): Double

def peekIntervalBig(signal: Interval): BigDecimal

def poke[T <: Element](port: T, target: BigInt)(implicit arg0: Pokeable[T]): Unit

def poke(signal: Aggregate, value: IndexedSeq[BigInt]): Unit

def poke(signal: Bundle, map: Map[String, BigInt]): Unit

def poke[T <: Element](signal: T, value: Long)(implicit arg0: Pokeable[T]): Unit

def poke[T <: Element](signal: T, value: Int)(implicit arg0: Pokeable[T]): Unit

def poke(path: String, value: Long): Unit

def poke(path: String, value: Int): Unit

def poke(path: String, value: BigInt): Unit

def pokeAt[TT <: Element](data: MemBase[TT], value: BigInt, off: Int)(implicit arg0: Pokeable[TT]): Unit

def pokeFixedPoint(signal: FixedPoint, value: Double): Unit

def pokeFixedPointBig(signal: FixedPoint, value: BigDecimal): Unit