Chisel

package Chisel

Visibility
  1. Public
  2. All

Type Members

  1. abstract class AccessTracker extends Delay

  2. abstract class Aggregate extends Data

  3. class Arbiter[T <: Data] extends LockingArbiter[T]

    Hardware module that is used to sequence n producers into 1 consumer.

    Hardware module that is used to sequence n producers into 1 consumer. Priority is given to lower producer

    Example usage: val arb = Module(new Arbiter(2, UInt())) arb.io.in(0) <> producer0.io.out arb.io.in(1) <> producer1.io.out consumer.io.in <> arb.io.out

  4. class ArbiterIO[T <: Data] extends Bundle

  5. class Assert extends Delay

  6. class AsyncFifo[T <: Data] extends Module

  7. abstract class Backend extends FileSystemUtilities

  8. case class BinaryOp(op: String) extends Op with Product with Serializable

  9. class Binding extends Node

  10. abstract class Bits extends Data with proc

    Base class for built-in Chisel types Bits and SInt.

  11. class BitsInObject extends UInt

  12. abstract class BlackBox extends Module

  13. class Bool extends UInt

  14. case class BoolEx(expr: Ex[Boolean]) extends Product with Serializable

  15. class Bundle extends Aggregate

    Defines a collection of datum of different types into a single coherent whole.

  16. class CEntry extends AnyRef

  17. class CSENode extends AnyRef

  18. class ChiselConfig extends AnyRef

  19. class ChiselError extends AnyRef

  20. class ChiselException extends Exception

  21. class Clock extends Node

  22. class Collector extends World

  23. class Complex[T <: Data with Num[T]] extends Bundle

  24. class ComplexTest extends Module

  25. class ComponentDef extends AnyRef

  26. class Counter extends AnyRef

  27. class CppBackend extends Backend

  28. abstract class Data extends Node

    *Data* is part of the *Node* Composite Pattern class hierarchy.

    *Data* is part of the *Node* Composite Pattern class hierarchy. It is the root of the type system which includes composites (Bundle, Vec) and atomic types (UInt, SInt, etc.).

    Instances of Data are meant to help with construction and correctness of a logic graph. They will trimmed out of the graph before a *Backend* generates target code.

  29. class Dbl extends Bits with Num[Dbl]

  30. class DecoupledIO[+T <: Data] extends Bundle

  31. class DecoupledIOC[+T <: Data] extends Bundle

  32. class Delay extends Node

  33. class DeqIO[T <: Data] extends DecoupledIO[T]

  34. case class DivisorParam(pname: String, init: Int, min: Int, max: Int, par: Param[Any]) extends Param[Int] with Product with Serializable

  35. class DotBackend extends Backend

  36. class EnqIO[T <: Data] extends DecoupledIO[T]

  37. case class EnumParam(pname: String, init: String, values: List[String]) extends Param[String] with Product with Serializable

  38. abstract class Ex[T] extends AnyRef

  39. final case class ExAdd(a: Ex[Int], b: Ex[Int]) extends Ex[Int] with Product with Serializable

  40. final case class ExAnd(a: Ex[Boolean], b: Ex[Boolean]) extends Ex[Boolean] with Product with Serializable

  41. final case class ExEq[T](a: Ex[T], b: Ex[T]) extends Ex[Boolean] with Product with Serializable

  42. final case class ExGt(a: Ex[Int], b: Ex[Int]) extends Ex[Boolean] with Product with Serializable

  43. final case class ExGte(a: Ex[Int], b: Ex[Int]) extends Ex[Boolean] with Product with Serializable

  44. final case class ExLit[T](value: T) extends Ex[T] with Product with Serializable

  45. final case class ExLt(a: Ex[Int], b: Ex[Int]) extends Ex[Boolean] with Product with Serializable

  46. final case class ExLte(a: Ex[Int], b: Ex[Int]) extends Ex[Boolean] with Product with Serializable

  47. final case class ExMod(a: Ex[Int], b: Ex[Int]) extends Ex[Int] with Product with Serializable

  48. final case class ExMul(a: Ex[Int], b: Ex[Int]) extends Ex[Int] with Product with Serializable

  49. final case class ExNeq[T](a: Ex[T], b: Ex[T]) extends Ex[Boolean] with Product with Serializable

  50. final case class ExOr(a: Ex[Boolean], b: Ex[Boolean]) extends Ex[Boolean] with Product with Serializable

  51. final case class ExSub(a: Ex[Int], b: Ex[Int]) extends Ex[Int] with Product with Serializable

  52. final case class ExVar[T](name: Any) extends Ex[T] with Product with Serializable

  53. final case class ExXor(a: Ex[Boolean], b: Ex[Boolean]) extends Ex[Boolean] with Product with Serializable

  54. class Extract extends Node

  55. class FPGABackend extends VerilogBackend

  56. class Fame1CppBackend extends CppBackend with Fame1Transform

  57. class Fame1FPGABackend extends FPGABackend with Fame1Transform

  58. trait Fame1Transform extends Backend

  59. class Fame1VerilogBackend extends VerilogBackend with Fame1Transform

  60. class Fame1Wrapper extends Module

  61. class Fame1WrapperIO extends Bundle

  62. class FameDecoupledIO[+T <: Data] extends Bundle

  63. class FameQueue[T <: Data] extends Module

  64. class FameQueueTracker extends Module

  65. class FameQueueTrackerIO extends Bundle

  66. class Field[T] extends AnyRef

  67. trait FileSystemUtilities extends AnyRef

  68. class Flo extends Bits with Num[Flo]

  69. class FloBackend extends Backend

  70. class GetWidthException extends Exception

  71. case class GreaterEqParam(pname: String, init: Int, par: Param[Any], max: Int) extends Param[Int] with Product with Serializable

  72. case class GreaterParam(pname: String, init: Int, par: Param[Any], max: Int) extends Param[Int] with Product with Serializable

  73. trait IODirection extends AnyRef

  74. class Insert extends Node with proc

  75. class Instance extends World

  76. case class IntEx(expr: Ex[Int]) extends Product with Serializable

  77. final case class Knob[T](name: Any) extends Product with Serializable

  78. class KnobUndefinedException extends RuntimeException

  79. case class LessEqParam(pname: String, init: Int, min: Int, par: Param[Any]) extends Param[Int] with Product with Serializable

  80. case class LessParam(pname: String, init: Int, min: Int, par: Param[Any]) extends Param[Int] with Product with Serializable

  81. class Literal extends Node

    Stores the actual value of a scala literal as a string.

    Stores the actual value of a scala literal as a string. This class should not end-up being instantiated directly in user code.

  82. class LockingArbiter[T <: Data] extends LockingArbiterLike[T]

  83. abstract class LockingArbiterLike[T <: Data] extends Module

  84. class LockingRRArbiter[T <: Data] extends LockingArbiterLike[T]

  85. class Log2 extends Log2Like

  86. abstract class Log2Like extends Op

  87. case class LogicalOp(op: String) extends Op with Product with Serializable

  88. class ManualTester[+T <: Module] extends AnyRef

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

  90. class Mem[T <: Data] extends AccessTracker with VecLike[T]

  91. abstract class MemAccess extends Node

  92. class MemRead extends MemAccess

  93. class MemReadWrite extends MemAccess

  94. class MemSeqRead extends MemAccess

  95. class MemWrite extends MemAccess

  96. abstract class Module extends AnyRef

  97. class Mux extends Op

  98. abstract class Node extends nameable

    *Node* defines the root class of the class hierarchy for a [Composite Pattern](http://en.wikipedia.org/wiki/Composite_pattern).

    *Node* defines the root class of the class hierarchy for a [Composite Pattern](http://en.wikipedia.org/wiki/Composite_pattern).

    A digital logic graph is encoded as adjacency graph where instances of *Node* describe vertices and *inputs*, *consumers* member fields are used to traverse the directed graph respectively backward (from output to input) and forward (from input to output).

  99. trait Num[T <: Data] extends AnyRef

  100. class OHToUInt extends Log2Like

  101. abstract class Op extends Node

  102. abstract class Param[+T] extends AnyRef

  103. case class ParamInvalidException(msg: String) extends Exception with Product with Serializable

  104. class ParameterUndefinedException extends RuntimeException

  105. final class Parameters extends AnyRef

  106. class Pipe[T <: Data] extends Module

  107. case class Poke(node: Node, index: Int, value: BigInt) extends Product with Serializable

  108. class Printf extends PrintfBase

  109. class PrintfBase extends Node

  110. class PriorityEncoder extends Log2Like

  111. class PutativeMemWrite extends Node with proc

  112. class Queue[T <: Data] extends Module

  113. class QueueIO[T <: Data] extends Bundle

  114. class ROM[T <: Data] extends Vec[T]

  115. class ROMData extends Node

  116. class ROMRead extends Node

  117. class RRArbiter[T <: Data] extends LockingRRArbiter[T]

    Hardware module that is used to sequence n producers into 1 consumer.

    Hardware module that is used to sequence n producers into 1 consumer. Producers are chosen in round robin order.

    Example usage: val arb = new RRArbiter(2, UInt()) arb.io.in(0) <> producer0.io.out arb.io.in(1) <> producer1.io.out consumer.io.in <> arb.io.out

  118. case class RangeParam(pname: String, init: Int, min: Int, max: Int) extends Param[Int] with Product with Serializable

  119. case class ReductionOp(op: String) extends Op with Product with Serializable

  120. class Reg extends Delay with proc

  121. class RegIO[T <: Data] extends Bundle

  122. class RegReset extends Reg

  123. class SInt extends Bits with Num[SInt]

  124. class Snapshot extends AnyRef

  125. class Sprintf extends PrintfBase

  126. class SysCBackend extends CppBackend

  127. class TestIO extends AnyRef

  128. class Tester[+T <: Module] extends ManualTester[T]

  129. class UInt extends Bits with Num[UInt]

  130. case class UnaryOp(op: String) extends Op with Product with Serializable

  131. trait UsesParameters extends AnyRef

  132. class ValidIO[+T <: Data] extends Bundle

  133. case class ValueParam(pname: String, init: Any) extends Param[Any] with Product with Serializable

  134. class VcdBackend extends Backend

  135. class Vec[T <: Data] extends Aggregate with VecLike[T] with Cloneable

  136. trait VecLike[T <: Data] extends IndexedSeq[T]

  137. class VecProc extends Node with proc

  138. class VerilogBackend extends Backend

  139. abstract class View extends AnyRef

  140. final case class ViewSym(view: View) extends Product with Serializable

  141. class Width extends Ordered[Width]

  142. abstract class World extends AnyRef

  143. abstract class _Lookup extends AnyRef

  144. sealed abstract class _Var[T] extends AnyRef

  145. final case class _VarKnob[T](kname: Any) extends _Var[T] with Product with Serializable

  146. final case class _VarLet[T](pname: Any, expr: Ex[T]) extends _Var[T] with Product with Serializable

  147. trait nameable extends AnyRef

  148. trait proc extends Node

  149. class when extends AnyRef

Value Members

  1. object ACos

  2. object ASin

  3. object ATan

  4. package AdvTester

  5. object ArbiterCtrl

  6. object Backend

  7. object BinaryOp extends Serializable

  8. object Binding

  9. object Bits

  10. object Bool

  11. object Bundle

  12. object CSE

  13. object CString

  14. object Cat

  15. object Ceil

  16. object ChiselError

    This Singleton implements a log4j compatible interface.

    This Singleton implements a log4j compatible interface. It is used through out the Chisel package to report errors and warnings detected at runtime.

  17. object Complex

  18. object Concatenate

  19. object Cos

  20. object Counter

  21. object Dbl

  22. object Decoupled

    Adds a ready-valid handshaking protocol to any interface.

    Adds a ready-valid handshaking protocol to any interface. The standard used is that the consumer uses the flipped interface.

  23. object Driver extends FileSystemUtilities

  24. object Dump

  25. object Enum

  26. object Ex

  27. object Extract

  28. object Fame1Transform

  29. object FameDecoupledIO

  30. object Fill

  31. object FillInterleaved

  32. object Flo

  33. object Floor

  34. object INPUT extends IODirection

  35. object ImplicitConversions

  36. object Implicits

  37. object IntParam

  38. object JHFormat

  39. object LFSR16

    linear feedback shift register

  40. object ListLookup

  41. object Lit

  42. object Literal

  43. object Log

  44. object Log2

  45. object LogicalOp extends Serializable

  46. object Lookup

  47. object Mem

    *seqRead* means that if a port tries to read the same address that another port is writing to in the same cycle, the read data is random garbage (from a LFSR, which returns "1" on its first invocation).

  48. object Module

  49. object Multiplex

  50. object Mux

  51. object Mux1H

    Builds a Mux tree out of the input signal vector using a one hot encoded select signal.

    Builds a Mux tree out of the input signal vector using a one hot encoded select signal. Returns the output of the Mux tree.

  52. object MuxCase

  53. object MuxLookup

  54. object Node

  55. object NodeExtract

  56. object NodeFill

  57. object OHToUInt

    Does the inverse of UIntToOH.

  58. object OUTPUT extends IODirection

  59. object Op

  60. object Parameters

  61. object Params

  62. object PartitionIslands

  63. object Pipe

    A hardware module that delays data coming down the pipeline by the number of cycles set by the latency parameter.

    A hardware module that delays data coming down the pipeline by the number of cycles set by the latency parameter. Functionality is similar to ShiftRegister but this exposes a Pipe interface.

    Example usage: val pipe = new Pipe(UInt()) pipe.io.enq <> produce.io.out consumer.io.in <> pipe.io.deq

  64. object PopCount

    Returns the number of bits set (i.e value is 1) in the input signal.

  65. object Pow

  66. object Printer

  67. object PriorityEncoder

    Returns the bit position of the trailing 1 in the input vector with the assumption that multiple bits of the input bit vector can be set

  68. object PriorityEncoderOH

    Returns a bit vector in which only the least-significant 1 bit in the input vector, if any, is set.

  69. object PriorityMux

    Builds a Mux tree under the assumption that multiple select signals can be enabled.

    Builds a Mux tree under the assumption that multiple select signals can be enabled. Priority is given to the first select signal.

    Returns the output of the Mux tree.

  70. object Queue

    Generic hardware queue.

    Generic hardware queue. Required parameter entries controls the depth of the queues. The width of the queue is determined from the inputs.

    Example usage: val q = new Queue(UInt(), 16) q.io.enq <> producer.io.out consumer.io.in <> q.io.deq

  71. object ROM

  72. object ReductionOp extends Serializable

  73. object Reg

  74. object RegEnable

  75. object RegInit

  76. object RegNext

  77. object Reverse

    Litte/big bit endian convertion: reverse the order of the bits in a UInt.

  78. object Round

  79. object SCWrapper

  80. object SInt

  81. object Scanner

  82. object ShiftRegister

    Returns the n-cycle delayed version of the input signal.

  83. object Sin

  84. object Sqrt

  85. object Tan

  86. object UInt

  87. object UIntToOH

    Returns the one hot encoding of the input UInt.

  88. object UnaryOp extends Serializable

  89. object Valid

    Adds a valid protocol to any interface.

    Adds a valid protocol to any interface. The standard used is that the consumer uses the flipped interface.

  90. object Vec

  91. object VecMux

  92. object VerilogBackend

  93. object Width

  94. object World

  95. object andR

  96. object chiselCast

  97. object chiselMain

    _chiselMain_ behaves as if it constructs an execution tree from the constructor of a sub class of Module which is passed as a parameter.

    _chiselMain_ behaves as if it constructs an execution tree from the constructor of a sub class of Module which is passed as a parameter. That execution tree is simplified by aggregating all calls which are not constructors of a Module instance into the parent which is. The simplified tree (encoded through _Driver.children_) forms the basis of the generated verilog. Each node in the simplified execution tree is a _Module_ instance from which a verilog module is textually derived. As an optimization, _Backend_ classes output modules which are textually equivalent only once and update a _Module_ instance's _moduleName_ accordingly.

  98. object chiselMainTest

  99. object foldR

  100. object is

  101. object isLessThan

  102. object isPow2

  103. object log2Ceil

  104. object log2Down

  105. object log2Floor

  106. object log2Up

  107. object orR

  108. object switch

  109. object throwException

  110. object unless

  111. object when

  112. object xorR

Ungrouped