MapTester

Instance Constructors

new MapTester(c: T, testNodes: Seq[Node])

Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

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

Definition Classes
Tester
val _outputs: ListSet[Bits]

Definition Classes
Tester
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( ... )
val cmd: String

Definition Classes
Tester
val cmdChannelName: String

Definition Classes
Tester
implicit def cmdToId(cmd: Tester.SIM_CMD.Value): Int

Definition Classes
Tester
def copyToTarget(filename: String): Unit

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

Definition Classes
FileSystemUtilities
def defTests(body: ⇒ Boolean): Boolean
var delta: Int

Definition Classes
Tester
def dumpName(data: Node): String

Definition Classes
Tester
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
val exitValue: Future[Int]

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

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

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

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

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

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

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

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

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

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

Definition Classes
Tester
def expect(data: Bits, expected: BigInt, msg: ⇒ String): 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
def fail: Unit

Definition Classes
Tester
var failureTime: Int

Indicate a failure has occurred.
Indicate a failure has occurred.

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
def getChunk(id: Int): Int

Attributes
protected
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
val inChannelName: String

Definition Classes
Tester
val ins: Seq[Node]
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
def newTestOutputString: String

Definition Classes
Tester
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var ok: Boolean

Definition Classes
Tester
val outChannelName: String

Definition Classes
Tester
val outs: Seq[Node]
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 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(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: Aggregate, x: Array[BigInt]): Unit

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

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

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

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 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, 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
Definition Classes
Tester
Example:
1. poke(path, BigInt(63) << 60, 2)
def printfs: Vector[String]

Definition Classes
Tester
val process: Process

Definition Classes
Tester
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(svars: HashMap[Node, Node], ovars: HashMap[Node, Node] = HashMap.empty, isTrace: Boolean = true): Boolean
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
val target: String

Definition Classes
Tester
val targetSubDir: String

Definition Classes
Tester
val testNodes: Seq[Node]
var tests: () ⇒ Boolean
def toString(): String

Definition Classes
AnyRef → Any
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( ... )

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

Instance Constructors

new MapTester(c: T, testNodes: Seq[Node])

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

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]

final def asInstanceOf[T0]: T0

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

val chiselENV: String

def clone(): AnyRef

val cmd: String

val cmdChannelName: String

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

def copyToTarget(filename: String): Unit

def createOutputFile(name: String): FileWriter

def defTests(body: ⇒ Boolean): Boolean

var delta: Int

def dumpName(data: Node): String

def ensureDir(dir: String): String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val exitValue: Future[Int]

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: 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

var failureTime: Int

def finalize(): Unit

def finish: Unit

def getChunk(id: Int): Int

final def getClass(): Class[_]

def getId(path: String): Int

def hashCode(): Int

val inChannelName: String

val ins: Seq[Node]

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

def newTestOutputString: String

final def notify(): Unit

final def notifyAll(): Unit

var ok: Boolean

val outChannelName: String

val outs: Seq[Node]

def peek(data: Dbl): Double

def peek(data: Flo): Float

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

def peek(data: Bits): 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

def poke(data: Dbl, x: Double): Unit

def poke(data: Flo, x: Float): Unit