AdvTester

Instance Constructors

new AdvTester(dut: T, isTrace: Boolean = false)

Type Members

class DecoupledSink[T <: Data, R] extends Processable
class DecoupledSource[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
def Boolean2Int(i: Boolean): Int
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
object DecoupledSink
object DecoupledSource
val LDFLAGS: String

Attributes
protected
Definition Classes
FileSystemUtilities
object SIM_CMD extends Enumeration

Valid commands to send to the Simulator
Valid commands to send to the Simulator

Definition Classes
Tester
To do
make private?
object ValidSink
object ValidSource
val _inputs: ListSet[Bits]

Definition Classes
Tester
val _logs: scala.collection.mutable.Queue[String]

Definition Classes
Tester
val _outputs: ListSet[Bits]

Definition Classes
Tester
final def asInstanceOf[T0]: T0

Definition Classes
Any
def assert(expr: Boolean, errMsg: String = ""): Boolean
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 copyToTarget(filename: String): Unit

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

Definition Classes
FileSystemUtilities
var cycles: Int
val defaultMaxCycles: Int
var delta: Int

Definition Classes
Tester
def do_registered_updates(): Unit
def do_until(work: ⇒ Unit)(pred: ⇒ Boolean, maxCycles: Int = defaultMaxCycles): Boolean
def dumpName(data: Node): String

Definition Classes
Tester
val dut: T
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 eventually(pred: ⇒ Boolean, maxCycles: Int = defaultMaxCycles): Boolean
def expect(data: Bits, expected: Float): Boolean

A tolerant expect for Float Allows for a single least significant bit error in the floating point representation
A tolerant expect for Float Allows for a single least significant bit error in the floating point representation

Definition Classes
Tester
def expect(data: Dbl, expected: Double): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed

Definition Classes
Tester
def expect(data: Flo, expected: Float): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed

Definition Classes
Tester
def expect(data: Bits, expected: Long): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed

Definition Classes
Tester
def expect(data: Bits, expected: Int): Boolean

Expect the value of 'data' to be 'expected'
Expect the value of 'data' to be 'expected'
returns
the test passed

Definition Classes
Tester
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
Expect the value of Aggregate data to be have the values as passed in with the array

Definition Classes
Tester
def expect(data: Bits, expected: BigInt): Boolean

Expect the value of data to have the same bits as a BigInt
Expect the value of data to have the same bits as a BigInt

Definition Classes
Tester
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

Definition Classes
Tester
var failureTime: Int

Definition Classes
Tester
def finalize(): Unit

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

Complete the simulation and inspect all tests
Complete the simulation and inspect all tests

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

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

Attributes
protected
Definition Classes
Tester
def hashCode(): Int

Definition Classes
AnyRef → Any
def int(x: Bits): BigInt

Convert Bits to BigInt
Convert Bits to BigInt

Definition Classes
Tester
def int(x: Long): BigInt

Convert a Long to BigInt
Convert a Long to BigInt

Definition Classes
Tester
def int(x: Int): BigInt

Convert an Int to BigInt
Convert an Int to BigInt

Definition Classes
Tester
def int(x: Boolean): BigInt

Convert a Boolean to BigInt
Convert a Boolean to BigInt

Definition Classes
Tester
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
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var ok: Boolean

Definition Classes
Tester
var pass: Boolean
def peek(data: Dbl): Double

Interpret the data as a double precision float
Interpret the data as a double precision float

Definition Classes
Tester
def peek(data: Flo): Float

Interpret data as a single precision float
Interpret data as a single precision float

Definition Classes
Tester
def peek(data: Aggregate): Array[BigInt]

Peek at Aggregate data
Peek at Aggregate data
returns
an Array of BigInts representing the data

Definition Classes
Tester
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

Definition Classes
Tester
def peek(id: Int): BigInt

id
the unique id of a node
returns
the current value of the node with the id

Definition Classes
Tester
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

Definition Classes
Tester
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

Definition Classes
Tester
def peekPath(path: String): BigInt

Peek at the value of a node based on the path
Peek at the value of a node based on the path

Definition Classes
Tester
def poke(port: Aggregate, target: Array[BigInt]): Unit

Set the value of Aggregate data
Set the value of Aggregate data

Definition Classes
AdvTester → Tester
def poke(port: Bits, target: BigInt): Unit

Set the value of some 'data' Node
Set the value of some 'data' Node

Definition Classes
AdvTester → Tester
def poke(data: Dbl, x: Double): Unit

Set the value of a hardware double precision floating point representation
Set the value of a hardware double precision floating point representation

Definition Classes
Tester
def poke(data: Flo, x: Float): Unit

Set the value of a hardware single precision floating point representation
Set the value of a hardware single precision floating point representation

Definition Classes
Tester
def poke(data: Bits, x: Long): Unit

Set the value of some 'data' Node
Set the value of some 'data' Node

Definition Classes
Tester
def poke(data: Bits, x: Int): Unit

Set the value of some 'data' Node
Set the value of some 'data' Node

Definition Classes
Tester
def poke(data: Bits, x: Boolean): Unit

Set the value of some 'data' Node
Set the value of some 'data' Node

Definition Classes
Tester
def poke(id: Int, v: BigInt, w: Int = 1): Unit

set the value of a node with unique 'id'
set the value of a node with unique 'id'
id
The unique id of the node to set
v
The BigInt representing the bits to set
w
The number of 64 bit chunks to write, default is 1
Definition Classes
Tester
Example:
1. poke(id, BigInt(63) << 60, 2)
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

Definition Classes
Tester
def pokeNode(node: Node, v: BigInt, off: Option[Int] = None): 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

Definition Classes
Tester
def pokePath(path: String, v: BigInt, w: Int = 1): 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
w
The number of 64 bit chunks to write, default is 1
Definition Classes
Tester
Example:
1. poke(path, BigInt(63) << 60, 2)
val postprocessors: ArrayBuffer[Processable]
val preprocessors: ArrayBuffer[Processable]
val process: Process

Definition Classes
Tester
def reg_poke(port: Aggregate, target: Array[BigInt]): Unit
def reg_poke(port: Bits, target: BigInt): Unit
val registered_aggr_updates: HashMap[Aggregate, Array[BigInt]]
val registered_bits_updates: HashMap[Bits, BigInt]
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

Definition Classes
Tester
val rnd: Random

Definition Classes
Tester
def run(cmd: String): Boolean

Definition Classes
FileSystemUtilities
def setClock(clk: Clock, len: Int): Unit

Definition Classes
Tester
def setClocks(clocks: Iterable[(Clock, Int)]): Unit

Definition Classes
Tester
def signed_fix(dtype: Bits, rv: BigInt): BigInt

Definition Classes
Tester
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

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

Definition Classes
AnyRef
var t: Int

Definition Classes
Tester
def takeStep: Unit

Attributes
protected
Definition Classes
Tester
def takestep(work: ⇒ Unit = {}): Unit
def takesteps(n: Int)(work: ⇒ Unit = {}): Unit
def testOutputString: String

Definition Classes
Tester
def toString(): String

Definition Classes
AnyRef → Any
def until(pred: ⇒ Boolean, maxCycles: Int = defaultMaxCycles)(work: ⇒ Unit): Boolean
def update: Unit

Attributes
protected
Definition Classes
Tester
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 waitForStreams(): Unit

Waits until the emulator streams are ready.
Waits until the emulator streams are ready. This is a dirty hack related to the way Process works. TODO: FIXME.

Definition Classes
Tester
def wire_poke(port: Aggregate, target: Array[BigInt]): Unit
def wire_poke(port: Bits, target: BigInt): Unit
def wire_poke(port: Bits, target: Long): Unit
def wire_poke(port: Bits, target: Int): Unit
def wire_poke(port: Bits, target: Boolean): Unit

Related Doc: package AdvTester

class AdvTester[+T <: Module] extends Tester[T]

Instance Constructors

new AdvTester(dut: T, isTrace: Boolean = false)

Type Members

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

class DecoupledSource[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

def Boolean2Int(i: Boolean): Int

val CC: String

val CCFLAGS: String

val CPPFLAGS: String

val CXX: String

val CXXFLAGS: String

object DecoupledSink

object DecoupledSource

val LDFLAGS: String

object SIM_CMD extends Enumeration

object ValidSink

object ValidSource

val _inputs: ListSet[Bits]

val _logs: scala.collection.mutable.Queue[String]

val _outputs: ListSet[Bits]

final def asInstanceOf[T0]: T0

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

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

val chiselENV: String

def clone(): AnyRef

def copyToTarget(filename: String): Unit

def createOutputFile(name: String): FileWriter

var cycles: Int

val defaultMaxCycles: Int

var delta: Int

def do_registered_updates(): Unit

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

def dumpName(data: Node): String

val dut: T

def ensureDir(dir: String): String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

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

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

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

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

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

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

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

var failureTime: Int

def finalize(): Unit

def finish: Unit

final def getClass(): Class[_]

def getId(path: String): Int

def hashCode(): Int

def int(x: Bits): BigInt

def int(x: Long): BigInt

def int(x: Int): BigInt

def int(x: Boolean): BigInt

final def isInstanceOf[T0]: Boolean

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var ok: Boolean

var pass: Boolean

def peek(data: Dbl): Double

def peek(data: Flo): Float

def peek(data: Aggregate): Array[BigInt]

def peek(data: Bits): BigInt

def peek(id: Int): BigInt

def peekAt[T <: Bits](data: Mem[T], off: Int): BigInt

def peekNode(node: Node, off: Option[Int] = None): BigInt

def peekPath(path: String): BigInt