Question

我在RocketChip中看到了一些示例，但在API reference中找不到信息

  masterNode :=* tlOtherMastersNode
  DisableMonitors { implicit p => tlSlaveXbar.node :*= slaveNode }

Answer 1

这些不是Chisel运算符。相反，它们是由Rocket Chip的diplomacy包定义和使用的。这些是在外交节点之间进行不同类型绑定的简写运算符。

不存在有关此问题的已发布API文档，但是您可以开始在diplomacy包中进行查找。定义它们的相关位置是src/main/scala/diplomacy/Nodes.scala。

Answer 2

阅读低风险的有关外交的文档可能会很有用：the HDP 3.1 docs

Answer 3

此API上的pull request comment非常有用。

通常，A := B在A和B中创建一对主端口和从端口。 A :=* B表示端口对的数量由B := Other的数量决定， A :*= B反之。

最违反直觉的部分是链接的重复不是通过中间模块重复，但是中间模块的端口列表正在扩展。

我写了一个简单的例子来研究星形连接器的行为。

在以下代码段中，一个TLIdentifyNode使用:=连接3个TLClientNode，然后使用:=*作为交叉开关的主节点，连接到交叉开关节点。同时，一个TLIdentifyNode使用:=连接2个TLManagerNode，然后使用:*=连接到同一个Crossbar节点，作为对Crossbar的控制。

import chisel3._
import chisel3.core.dontTouch
import freechips.rocketchip.config._
import freechips.rocketchip.diplomacy._
import freechips.rocketchip.tilelink._


class ClientConnector(implicit p: Parameters) extends LazyModule {
  val node = TLIdentityNode()
  override lazy val module = new LazyModuleImp(this) {
    (node.in zip node.out) foreach { case ((bundleIn, edgeIn), (bundleOut, edgeOut)) =>
      bundleOut <> bundleIn
    }
  }
}


class ManagerConnector(implicit p: Parameters) extends LazyModule {
  val node = TLIdentityNode()
  override lazy val module = new LazyModuleImp(this) {
    (node.in zip node.out) foreach { case ((bundleIn, edgeIn), (bundleOut, edgeOut)) =>
      bundleOut <> bundleIn
    }
  }
}



class Client(implicit p: Parameters) extends LazyModule {
  val node = TLClientNode(
    portParams = Seq(
      TLClientPortParameters(Seq(
        TLClientParameters("myclient1", IdRange(0, 1), supportsGet = TransferSizes(4), supportsProbe = TransferSizes(4))
      ))
    )
  )

  override lazy val module = new LazyModuleImp(this) {
    node.out.foreach { case(bundle, edge) =>
        val (legal, a) = edge.Get(0.U, 0x1000.U, 2.U)
        bundle.a.bits := a
        bundle.a.valid := legal

        bundle.d.ready := true.B

        dontTouch(bundle)
    }
  }
}


class Manager(base: Int)(implicit p: Parameters) extends LazyModule {
  val node = TLManagerNode(Seq(TLManagerPortParameters(Seq(TLManagerParameters(
    address = Seq(AddressSet(base, 0xffff)),
    supportsGet = TransferSizes(4)
  )), beatBytes = 4)))

  override lazy val module = new LazyModuleImp(this) {
    node.in.foreach { case (bundle, edge) =>
        when (bundle.a.fire()) {
          val d = edge.AccessAck(bundle.a.bits, 0xdeadbeafL.U)
          bundle.d.bits := d
          bundle.d.valid := true.B
        }
        bundle.a.ready := true.B
    }
  }
}


class Playground(implicit p: Parameters) extends LazyModule {

  val xbr               = TLXbar()
  val clientConnectors  = LazyModule(new ClientConnector())
  val managerConnectors = LazyModule(new ManagerConnector())
  val clients           = Seq.fill(3) { LazyModule(new Client()).node }
  val managers          = Seq.tabulate(2) { i: Int => LazyModule(new Manager(0x10000 * i)).node }

  clients.foreach(clientConnectors.node := _)
  managers.foreach(_ := managerConnectors.node)

  managerConnectors.node :*= xbr
  xbr :=* clientConnectors.node

  override lazy val module = new LazyModuleImp(this) {
  }
}

ManagerConnector的对应Verilog代码为（简而言之）：

module ManagerConnector(
  `tilelink_bundle(auto_in_0),
  `tilelink_bundle(auto_in_1),
  `tilelink_bundle(auto_out_0),
  `tilelink_bundle(auto_out_1)
);
// ...
endmodule

我们可以看到diplomacy框架仅负责参数协商，端口列表生成和端口连接。通过*连接引入的重复由公共代码模式保证：

(node.in zip node.out) foreach { ... }

我认为，此API简化了交叉开关节点与特定模块内各个节点之间的连接，并使连接语法保持一致。

[参考]火箭筹码阅读笔记：https://github.com/cnrv/rocket-chip-read/blob/master/diplomacy/Nodes.md

：* =和：= *运算符的含义是什么？

3 个答案: