关于RocketChip中LazyModule的疑问：实例化时机与非lazy赋值影响

Hey there! Let's start by clarifying your initial conclusion first, then break down what happens when you skip the lazy keyword with LazyModule instances.

Correcting Your Initial Thought #

Your idea that "LazyModule subclass objects are only instantiated when first accessed" isn't exactly accurate. Here's the real deal:

• When you run new MyLazyModule(...), the LazyModule instance itself is created right away—just like any regular Scala class. No deferral here.
• What's actually delayed is the creation of its hardware implementation: the LazyModuleImp subclass (like the module val you spotted in RocketTile.scala). This hardware part only gets built when LazyModule.root is invoked (typically at the top of your design) or when explicitly triggered. This is core to diplomacy's workflow, letting it resolve all connections and parameters before generating actual hardware.

What Happens Without the lazy Keyword? #

Now to your main question: if you declare a variable holding a LazyModule instance without lazy, here's what goes down:

• Immediate LazyModule instantiation: Since it's a standard Scala val/var, the new MyLazyModule(...) call executes the moment the enclosing class is constructed—not when you first access the variable.
• Early diplomacy setup: Any diplomacy logic inside the LazyModule's constructor (like defining nodes, configuring parameters) runs right away, instead of waiting until the design's root is processed.
• Risk of broken parameter resolution: Diplomacy relies on a phase-based process where connections are sorted out before hardware is made. If you instantiate LazyModules early (no lazy), you might hit unresolvable node connections, missing parameter propagations, or confusing bugs because dependencies haven't been fully set up yet.

Example from RocketTile #

In RocketTile.scala, you'll see code like:

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

That lazy ensures the hardware implementation doesn't get built until the RocketTile's diplomacy setup is complete. If you stripped out the lazy here, the LazyModuleImp would try to generate hardware immediately when the RocketTile LazyModule is created—before any of its node connections (to the core, cache, or bus) are resolved. This would almost certainly throw errors, since the hardware depends on parameters that haven't been negotiated yet.

Quick Recap #

Always use lazy when declaring variables that hold LazyModule instances or their module implementations. This keeps things aligned with diplomacy's deferred execution model, making sure parameter resolution and connection setup happen in the right order before hardware is generated.

内容的提问来源于stack exchange，提问作者apaj