Tester

Instance Constructors

new Tester(c: T, isTrace: Boolean = true, _base: Int = 16, testCmd: Option[String] = Driver.testCommand, dumpFile: Option[String] = None)

c
The module under test
isTrace
print the all I/O operations and tests to stdout, default true
_base
base for prints, default 16 (hex)
testCmd
command to run the emulator
dumpFile
vcd/vpd file name

Type Members

class BasicObserver extends Observer
case class DumpEvent(msg: String) extends Event with Product with Serializable
abstract class Event extends AnyRef
case class ExpectDblEvent(b: Dbl, got: Double, expected: Double, msg: String) extends Event with Product with Serializable
case class ExpectEvent(b: Bits, got: BigInt, expected: BigInt, msg: String) extends Event with Product with Serializable
case class ExpectFloEvent(b: Bits, got: Float, expected: Float, msg: String) extends Event with Product with Serializable
case class ExpectMsgEvent(good: Boolean, msg: String) extends Event with Product with Serializable
case class FinishEvent(t: Long, pass: Boolean, fail_t: Long) extends Event with Product with Serializable
case class MuteEvent() extends Event with Product with Serializable
case class NoIdEvent(path: String) extends Event with Product with Serializable
class Observer extends AnyRef
case class PeekDblEvent(b: Dbl, v: Double) extends Event with Product with Serializable
case class PeekEvent(b: Bits, v: Option[BigInt]) extends Event with Product with Serializable
case class PeekFloEvent(b: Flo, v: Float) extends Event with Product with Serializable
case class PeekMemEvent[T <: Data](m: Mem[T], off: Int, v: BigInt) extends Event with Product with Serializable
case class PokeDblEvent(b: Dbl, v: Double) extends Event with Product with Serializable
case class PokeEvent(b: Bits, v: BigInt, good: Boolean = true) extends Event with Product with Serializable
case class PokeFloEvent(b: Flo, v: Float) extends Event with Product with Serializable
case class PokeMemEvent[T <: Data](m: Mem[T], off: Int, v: BigInt) extends Event with Product with Serializable
case class ResetEvent(n: Int) extends Event with Product with Serializable
case class StartEvent(seed: Long, cmd: String) extends Event with Product with Serializable
case class StepEvent(n: Int, t: Long) extends Event with Product with Serializable
case class UnmuteEvent() extends Event with Product with Serializable

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
val CC: String

Attributes
protected
Definition Classes
FileSystemUtilities
val CCFLAGS: String

Attributes
protected
Definition Classes
FileSystemUtilities
val CPPFLAGS: String

Attributes
protected
Definition Classes
FileSystemUtilities
val CXX: String

Attributes
protected
Definition Classes
FileSystemUtilities
val CXXFLAGS: String

Attributes
protected
Definition Classes
FileSystemUtilities
val LDFLAGS: String

Attributes
protected
Definition Classes
FileSystemUtilities
val _inputs: ListSet[Bits]
val _outputs: ListSet[Bits]
var _t: Long
def addEvent(e: Event): Unit
def addObserver(o: Observer): Unit
final def asInstanceOf[T0]: T0

Definition Classes
Any
def cc(dir: String, name: String, flags: String = "", isCC: Boolean = false): Unit

Definition Classes
FileSystemUtilities
val chiselENV: String

Attributes
protected
Definition Classes
FileSystemUtilities
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close: Unit
val cmd: String
implicit def cmdToId(cmd: SIM_CMD.Value): Int
def copyToTarget(filename: String): Unit

Definition Classes
FileSystemUtilities
def createOutputFile(name: String): FileWriter

Definition Classes
FileSystemUtilities
var delta: Int
def dumpName(data: Node): String
def ensureDir(dir: String): String

Ensures a directory *dir* exists on the filesystem.
Ensures a directory *dir* exists on the filesystem.

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

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

Definition Classes
AnyRef → Any
def expect(data: Bits, expected: Float): Boolean
def expect(data: Bits, expected: Float, msg: ⇒ String): Boolean

A tolerant expect for Float Allows for a single least significant bit error in the floating point representation
def expect(data: Dbl, expected: Double): Boolean
def expect(data: Dbl, expected: Double, msg: ⇒ String): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed
def expect(data: Flo, expected: Float): Boolean
def expect(data: Flo, expected: Float, msg: ⇒ String): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed
def expect(data: Bool, expected: Boolean): Boolean
def expect(data: Bool, expected: Boolean, msg: ⇒ String): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed
def expect(data: Bits, expected: Long): Boolean
def expect(data: Bits, expected: Long, msg: ⇒ String): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed
def expect(data: Bits, expected: Int): Boolean
def expect(data: Bits, expected: Int, msg: ⇒ String): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed
def expect(data: Aggregate, expected: Array[BigInt]): Boolean

Expect the value of Aggregate data to be have the values as passed in with the array
def expect(data: Bits, expected: BigInt): Boolean
def expect(data: Bits, expected: BigInt, msg: ⇒ String): Boolean

Expect the value of data to have the same bits as a BigInt
def expect(good: Boolean, msg: ⇒ String): Boolean

Expect a value to be true printing a message if it passes or fails
Expect a value to be true printing a message if it passes or fails
good
If the test passed or not
msg
The message to print out
def fail: Unit
def finalize(): Unit

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

Complete the simulation and inspect all tests
def getChunk(id: Int): Int

Attributes
protected
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getId(path: String): Int

Attributes
protected
def hashCode(): Int

Definition Classes
AnyRef → Any
def incTime(n: Int): Unit
def int(x: Bits): BigInt

Convert Bits to BigInt
def int(x: Long): BigInt

Convert a Long to BigInt
def int(x: Int): BigInt

Convert an Int to BigInt
def int(x: Boolean): BigInt

Convert a Boolean to BigInt
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def link(dir: String, target: String, objects: Seq[String], isCC: Boolean = false, isLib: Boolean = false): Unit

Definition Classes
FileSystemUtilities
implicit def longToInt(x: Long): Int
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newTestOutputString: String
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def peek(data: Dbl): Double

Interpret the data as a double precision float
def peek(data: Flo): Float

Interpret data as a single precision float
def peek(data: Aggregate): Array[BigInt]

Peek at Aggregate data
Peek at Aggregate data
returns
an Array of BigInts representing the data
def peek(data: Bits): BigInt

Peek at the value of some bits
Peek at the value of some bits
returns
a BigInt representation of the bits
def peekAt[T <: Bits](data: Mem[T], off: Int): BigInt

Peek at the value of some memory at an index
Peek at the value of some memory at an index
data
Memory to inspect
off
Offset in memory to look at
def peekNode(node: Node, off: Option[Int] = None): BigInt

Peek at the value of a node
Peek at the value of a node
node
Node to peek at
off
The index or offset to inspect
def peekPath(path: String): BigInt

Peek at the value of a node based on the path
def poke(data: Dbl, x: Double): Unit

Set the value of a hardware double precision floating point representation
def poke(data: Flo, x: Float): Unit

Set the value of a hardware single precision floating point representation
def poke(data: Aggregate, x: Array[BigInt]): Unit

Set the value of Aggregate data
def poke(data: Bits, x: BigInt): Unit

Set the value of some 'data' Node
def poke(data: Bits, x: Long): Unit

Set the value of some 'data' Node
def poke(data: Bits, x: Int): Unit

Set the value of some 'data' Node
def poke(data: Bits, x: Boolean): Unit

Set the value of some 'data' Node
def pokeAt[T <: Bits](data: Mem[T], value: BigInt, off: Int): Unit

set the value of some memory
set the value of some memory
data
The memory to write to
value
The BigInt representing the bits to set
off
The offset representing the index to write to memory
def pokeNode(node: Node, v: BigInt, off: Option[Int] = None, force: Boolean = false): Unit

set the value of a node
set the value of a node
node
The node to set
v
The BigInt representing the bits to set
off
The offset or index
def pokePath(path: String, v: BigInt, force: Boolean = false): Unit

set the value of a node with its path
set the value of a node with its path
path
The unique path of the node to set
v
The BigInt representing the bits to set
Example:
1. poke(path, BigInt(63) << 60, 2)
def printfs: Vector[String]
def reset(n: Int = 1): Unit

Send reset to the hardware
Send reset to the hardware
n
number of cycles to hold reset for, default 1
val rnd: Random
def run(cmd: String): Boolean

Definition Classes
FileSystemUtilities
def setClock(clk: Clock, len: Int): Unit
def setClocks(clocks: Iterable[(Clock, Int)]): Unit
def signed_fix(dtype: Bits, rv: BigInt): BigInt
def step(n: Int): Unit

Step time by the smallest amount to the next rising clock edge
Step time by the smallest amount to the next rising clock edge

Note
this is defined based on the period of the clock See Clock
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def t: Long
def takeStep: Unit

Attributes
protected
val target: String
val targetSubDir: String
def throwExceptionIfDead(exitValue: Future[Int]): Unit
def toString(): String

Definition Classes
AnyRef → Any
def update: Unit

Attributes
protected
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( ... )

Related Docs: object Tester | package Chisel

class Tester[+T <: Module] extends FileSystemUtilities

Instance Constructors

new Tester(c: T, isTrace: Boolean = true, _base: Int = 16, testCmd: Option[String] = Driver.testCommand, dumpFile: Option[String] = None)

Type Members

class BasicObserver extends Observer

case class DumpEvent(msg: String) extends Event with Product with Serializable

abstract class Event extends AnyRef

case class ExpectDblEvent(b: Dbl, got: Double, expected: Double, msg: String) extends Event with Product with Serializable

case class ExpectEvent(b: Bits, got: BigInt, expected: BigInt, msg: String) extends Event with Product with Serializable

case class ExpectFloEvent(b: Bits, got: Float, expected: Float, msg: String) extends Event with Product with Serializable

case class ExpectMsgEvent(good: Boolean, msg: String) extends Event with Product with Serializable

case class FinishEvent(t: Long, pass: Boolean, fail_t: Long) extends Event with Product with Serializable

case class MuteEvent() extends Event with Product with Serializable

case class NoIdEvent(path: String) extends Event with Product with Serializable

class Observer extends AnyRef

case class PeekDblEvent(b: Dbl, v: Double) extends Event with Product with Serializable

case class PeekEvent(b: Bits, v: Option[BigInt]) extends Event with Product with Serializable

case class PeekFloEvent(b: Flo, v: Float) extends Event with Product with Serializable

case class PeekMemEvent[T <: Data](m: Mem[T], off: Int, v: BigInt) extends Event with Product with Serializable

case class PokeDblEvent(b: Dbl, v: Double) extends Event with Product with Serializable

case class PokeEvent(b: Bits, v: BigInt, good: Boolean = true) extends Event with Product with Serializable

case class PokeFloEvent(b: Flo, v: Float) extends Event with Product with Serializable

case class PokeMemEvent[T <: Data](m: Mem[T], off: Int, v: BigInt) extends Event with Product with Serializable

case class ResetEvent(n: Int) extends Event with Product with Serializable

case class StartEvent(seed: Long, cmd: String) extends Event with Product with Serializable

case class StepEvent(n: Int, t: Long) extends Event with Product with Serializable

case class UnmuteEvent() extends Event with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val CC: String

val CCFLAGS: String

val CPPFLAGS: String

val CXX: String

val CXXFLAGS: String

val LDFLAGS: String

val _inputs: ListSet[Bits]

val _outputs: ListSet[Bits]

var _t: Long

def addEvent(e: Event): Unit

def addObserver(o: Observer): Unit

final def asInstanceOf[T0]: T0

def cc(dir: String, name: String, flags: String = "", isCC: Boolean = false): Unit

val chiselENV: String

def clone(): AnyRef

def close: Unit

val cmd: String

implicit def cmdToId(cmd: SIM_CMD.Value): Int

def copyToTarget(filename: String): Unit

def createOutputFile(name: String): FileWriter

var delta: Int

def dumpName(data: Node): String

def ensureDir(dir: String): String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expect(data: Bits, expected: Float): Boolean

def expect(data: Bits, expected: Float, msg: ⇒ String): Boolean

def expect(data: Dbl, expected: Double): Boolean

def expect(data: Dbl, expected: Double, msg: ⇒ String): Boolean

def expect(data: Flo, expected: Float): Boolean

def expect(data: Flo, expected: Float, msg: ⇒ String): Boolean

def expect(data: Bool, expected: Boolean): Boolean

def expect(data: Bool, expected: Boolean, msg: ⇒ String): Boolean

def expect(data: Bits, expected: Long): Boolean

def expect(data: Bits, expected: Long, msg: ⇒ String): Boolean

def expect(data: Bits, expected: Int): Boolean

def expect(data: Bits, expected: Int, msg: ⇒ String): Boolean

def expect(data: Aggregate, expected: Array[BigInt]): Boolean

def expect(data: Bits, expected: BigInt): Boolean

def expect(data: Bits, expected: BigInt, msg: ⇒ String): Boolean

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

def fail: Unit

def finalize(): Unit

def finish: Boolean

def getChunk(id: Int): Int

final def getClass(): Class[_]

def getId(path: String): Int