Merge pull request #258 from DFiantHDL/caching

v0.11.0

Author: soronpo

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.9.4
+version = 3.9.7
 runner.dialect = scala3
 
 maxColumn = 100
@@ -14,4 +14,5 @@ binPack.literalsInclude = [".*"]
 binPack.literalsIncludeSimpleExpr = true
 binPack.literalsSingleLine = false
 
-newlines.selectChains = keep
+newlines.selectChains = keep
+newlines.source = keep

build.sbt

@@ -3,7 +3,7 @@ commands += DFHDLCommands.docExamplesRefUpdate
 
 // format: off
 val projectName = "dfhdl"
-val compilerVersion = "3.7.0-RC4"
+val compilerVersion = "3.7.1"
 
 inThisBuild(
   List(
@@ -78,7 +78,8 @@ lazy val plugin = project
 lazy val compiler_ir = (project in file("compiler/ir"))
   .settings(
     name := s"$projectName-compiler-ir",
-    settings
+    settings,
+    libraryDependencies += dependencies.upickle
   ).dependsOn(internals)
 
 lazy val core = project
@@ -146,17 +147,20 @@ lazy val devices = (project in file("devices"))
 lazy val dependencies =
   new {
     private val scodecV = "1.2.1"
-    private val munitV = "1.1.0"
+    private val munitV = "1.1.1"
     private val scalafmtV = "3.8.3"
-    private val airframelogV = "2025.1.10"
+    private val airframelogV = "2025.1.12"
     private val oslibV = "0.9.2"
     private val scallopV = "5.2.0"
+    private val upickleV = "4.1.0"
+
     val scodec = "org.scodec" %% "scodec-bits" % scodecV
     val munit = "org.scalameta" %% "munit" % munitV % Test
     val scalafmt = ("org.scalameta" %% "scalafmt-dynamic" % scalafmtV).cross(CrossVersion.for3Use2_13)
     val airframelog = "org.wvlet.airframe" %% "airframe-log" % airframelogV
     val oslib = "com.lihaoyi" %% "os-lib" % oslibV
     val scallop = "org.rogach" %% "scallop" % scallopV
+    val upickle = "com.lihaoyi" %% "upickle" % upickleV
   }
 
 lazy val commonDependencies = Seq(

compiler/ir/src/main/scala/dfhdl/compiler/analysis/DFConditionalAnalysis.scala

@@ -6,7 +6,6 @@ import DFConditional.DFCaseBlock.Pattern
 import DFVal.Modifier
 
 import scala.annotation.tailrec
-import scala.reflect.{ClassTag, classTag}
 import dfhdl.compiler.ir.DFConditional.DFMatchHeader
 
 extension [CB <: DFConditional.Block](cb: CB)(using MemberGetSet)

compiler/ir/src/main/scala/dfhdl/compiler/analysis/DFValAnalysis.scala

@@ -7,18 +7,18 @@ import DFVal.Modifier
 import DFVal.Func.Op as FuncOp
 import DFVal.Alias.History.Op as HistoryOp
 import scala.annotation.tailrec
-import scala.reflect.{ClassTag, classTag}
 import DFDesignBlock.InstMode
 import scala.util.boundary, boundary.break
 import scala.annotation.targetName
+import scala.collection.immutable.ListMap
 
 object IteratorDcl:
   def unapply(dcl: DFVal.Dcl)(using MemberGetSet): Boolean =
-    dcl.hasTagOf[DFVal.Dcl.IteratorTag.type]
+    dcl.hasTagOf[IteratorTag]
 
 object Ident:
   def unapply(alias: DFVal.Alias.AsIs)(using MemberGetSet): Option[DFVal] =
-    if (alias.hasTagOf[DFVal.Alias.IdentTag.type]) Some(alias.relValRef.get)
+    if (alias.hasTagOf[IdentTag]) Some(alias.relValRef.get)
     else None
 
 object StrippedPortByNameSelect:
@@ -49,11 +49,11 @@ object StrippedPortByNameSelect:
 //```
 // object DesignParam:
 //   def unapply(alias: DFVal.Alias.AsIs)(using MemberGetSet): Option[DFVal] =
-//     if (alias.hasTagOf[DFVal.Alias.DesignParamTag.type])
+//     if (alias.hasTagOf[DFVal.Alias.DesignParamTag])
 //       val relVal = alias.relValRef.get
 //       // if (
 //       //   relVal.existsInComposedReadDeps { dep =>
-//       //     dep.hasTagOf[DFVal.Alias.DesignParamTag.type] &&
+//       //     dep.hasTagOf[DFVal.Alias.DesignParamTag] &&
 //       //     dep.isSameOwnerDesignAs(alias)
 //       //   }
 //       // ) None
@@ -84,7 +84,7 @@ object AsOpaque:
 
 object Bind:
   def unapply(alias: DFVal.Alias)(using MemberGetSet): Option[DFVal] =
-    if (alias.getTagOf[Pattern.Bind.Tag.type].isDefined)
+    if (alias.getTagOf[BindTag].isDefined)
       Some(alias.relValRef.get)
     else None
 
@@ -407,14 +407,32 @@ extension (textOut: TextOut)
       .flatMap(_.collectRelMembers(false)).toList
 
 extension (member: DFMember)
-  def isPublicMember(using MemberGetSet): Boolean =
+  private def isPublicMember(using MemberGetSet): Boolean =
     member match
       case DclPort()            => true
       case _: DFVal.DesignParam => true
       case _: DomainBlock       => true
       case _                    => false
 end extension
 
+extension (members: List[DFMember])
+  def filterPublicMembers(using MemberGetSet): List[DFMember] =
+    def getPublicMembersDeps(member: DFMember): List[DFMember] =
+      member :: member.getRefs.flatMap { r =>
+        val publicMemberCandidate = r.get
+        publicMemberCandidate match
+          case _: DFMember.Empty                          => Nil
+          case dfVal: DFVal.CanBeGlobal if dfVal.isGlobal => Nil
+          case _ if publicMemberCandidate.isSameOwnerDesignAs(member) =>
+            getPublicMembersDeps(publicMemberCandidate)
+          case _ => Nil
+      }
+    members.view.filter(_.isPublicMember).flatMap {
+      case p: DFVal.DesignParam => getPublicMembersDeps(p).reverse
+      case m                    => Some(m)
+    }.toList.distinct
+end extension
+
 extension (member: DFMember)
   def consumesCycles(using MemberGetSet): Boolean =
     member match
@@ -427,3 +445,46 @@ extension (member: DFMember)
         cb.members(MemberView.Folded).exists(_.consumesCycles)
       case _ => false
 end extension
+
+/** An extractor that transforms a DFType using a provided update function.
+  *
+  * This extractor works in two phases:
+  *   1. It first applies the `preCheck` predicate to determine if the type should be transformed
+  *      and to extract a helper object of type H.
+  *   2. Then it recursively processes any nested types (for structs, vectors, opaques).
+  *   3. Finally, it applies the `updateFunc` to either the original type or the recursively
+  *      processed type, along with the helper object.
+  *
+  * @tparam H
+  *   The type of the helper object produced by preCheck and consumed by updateFunc
+  */
+class ComposedDFTypeReplacement[H](
+    preCheck: DFType => Option[H],
+    updateFunc: PartialFunction[(DFType, H), DFType]
+)(using
+    MemberGetSet
+):
+  Extractor =>
+  def unapply(dfType: DFType): Option[DFType] =
+    val composed = dfType match
+      case dt: DFStruct =>
+        val updatedMap = ListMap.from(dt.fieldMap.view.collect { case (name, Extractor(dfType)) =>
+          (name, dfType)
+        })
+        if (updatedMap.nonEmpty) Some(dt.copy(fieldMap = updatedMap))
+        else None
+      case dt: DFOpaque =>
+        dt.actualType match
+          case Extractor(dfType) => Some(dt.copy(actualType = dfType))
+          case _                 => None
+      case dt: DFVector =>
+        dt.cellType match
+          case Extractor(dfType) => Some(dt.copy(cellType = dfType))
+          case _                 => None
+      case _ => None
+    // if the original type matches the precheck, the extractor will always return some updated value
+    preCheck(dfType) match
+      case Some(helper) => Some(updateFunc(composed.getOrElse(dfType), helper))
+      case None         => composed
+  end unapply
+end ComposedDFTypeReplacement

compiler/ir/src/main/scala/dfhdl/compiler/ir/Config.scala

@@ -1,5 +1,6 @@
 package dfhdl.compiler.ir
-
+import dfhdl.internals.StableEnum
+import upickle.default.*
 opaque type ConfigN[T] = T | None.type
 object ConfigN:
   given [T]: Conversion[None.type, ConfigN[T]] with
@@ -10,10 +11,22 @@ object ConfigN:
   given [T]: CanEqual[ConfigN[T], None.type] = CanEqual.derived
   given [T]: CanEqual[None.type, ConfigN[T]] = CanEqual.derived
   given [L, R]: CanEqual[ConfigN[L], ConfigN[R]] = CanEqual.derived
+  given [T](using ReadWriter[T]): ReadWriter[ConfigN[T]] = readwriter[ujson.Value].bimap(
+    value =>
+      (value: @unchecked) match
+        case None     => ujson.Null
+        case value: T => writeJs(value)
+    ,
+    json =>
+      json match
+        case ujson.Null => None
+        case value      => read[T](value)
+  )
+end ConfigN
 
 /** Sets the policy for inclusing the clock or reset signals when they are not needed
   */
-enum ClkRstInclusionPolicy derives CanEqual:
+enum ClkRstInclusionPolicy extends StableEnum derives CanEqual, ReadWriter:
   /** Don't include if not needed
     */
   case AsNeeded
@@ -24,44 +37,42 @@ enum ClkRstInclusionPolicy derives CanEqual:
 
 type ClkCfg = ConfigN[ClkCfg.Explicit]
 object ClkCfg:
-  enum Edge derives CanEqual:
+  enum Edge extends StableEnum derives CanEqual, ReadWriter:
     case Rising, Falling
 
+  type RateData = (BigDecimal, DFFreq.Unit | DFTime.Unit)
+  given ReadWriter[DFFreq.Unit | DFTime.Unit] =
+    ReadWriter.merge(summon[ReadWriter[DFTime.Unit]], summon[ReadWriter[DFFreq.Unit]])
+
   final case class Explicit(
       edge: Edge,
-      rate: DFVal,
+      rate: RateData,
       portName: String,
       inclusionPolicy: ClkRstInclusionPolicy
-  ) extends HasRefCompare[Explicit] derives CanEqual:
-    override protected def prot_=~(that: Explicit)(using MemberGetSet): Boolean =
-      this.edge == that.edge && this.rate =~ that.rate && this.portName == that.portName &&
-        this.inclusionPolicy == that.inclusionPolicy
-    lazy val getRefs: List[DFRef.TwoWayAny] = rate.getRefs
-    def copyWithNewRefs: this.type = copy(rate = rate.copyWithNewRefs).asInstanceOf[this.type]
+  ) derives CanEqual,
+        ReadWriter
 end ClkCfg
 
 type RstCfg = ConfigN[RstCfg.Explicit]
 object RstCfg:
-  enum Mode derives CanEqual:
+  enum Mode extends StableEnum derives CanEqual, ReadWriter:
     case Async, Sync
-  enum Active derives CanEqual:
+  enum Active extends StableEnum derives CanEqual, ReadWriter:
     case Low, High
 
   final case class Explicit(
       mode: Mode,
       active: Active,
       portName: String,
       inclusionPolicy: ClkRstInclusionPolicy
-  ) derives CanEqual
+  ) derives CanEqual,
+        ReadWriter
 end RstCfg
 
-enum RTDomainCfg extends HasRefCompare[RTDomainCfg] derives CanEqual:
+enum RTDomainCfg extends HasRefCompare[RTDomainCfg], StableEnum derives CanEqual, ReadWriter:
   case Derived
   case Related(relatedDomainRef: RTDomainCfg.RelatedDomainRef) extends RTDomainCfg
-  case Explicit(name: String, clkCfg: ClkCfg, rstCfg: RstCfg)
-      extends RTDomainCfg,
-      NamedGlobal,
-      DFTagOf[DFDesignBlock]
+  case Explicit(name: String, clkCfg: ClkCfg, rstCfg: RstCfg) extends RTDomainCfg
 
   def isDerivedNoRst: Boolean = this match
     case cfg: Explicit if cfg.name.endsWith(".norst") => true
@@ -79,19 +90,16 @@ enum RTDomainCfg extends HasRefCompare[RTDomainCfg] derives CanEqual:
             Explicit(thisName, thisClkCfg: ClkCfg.Explicit, thisRstCfg),
             Explicit(thatName, thatClkCfg: ClkCfg.Explicit, thatRstCfg)
           ) =>
-        thisName == thatName && thisClkCfg =~ thatClkCfg && thisRstCfg == thatRstCfg
+        thisName == thatName && thisClkCfg == thatClkCfg && thisRstCfg == thatRstCfg
       case _ => this == that
 
   lazy val getRefs: List[DFRef.TwoWayAny] = this match
-    case Related(relatedDomainRef)                    => List(relatedDomainRef)
-    case Explicit(_, clkCfg: ClkCfg.Explicit, rstCfg) => clkCfg.getRefs
-    case _                                            => Nil
+    case Related(relatedDomainRef) => List(relatedDomainRef)
+    case _                         => Nil
 
-  def copyWithNewRefs: this.type = this match
+  def copyWithNewRefs(using RefGen): this.type = this match
     case Related(relatedDomainRef) => Related(relatedDomainRef.copyAsNewRef).asInstanceOf[this.type]
-    case Explicit(name, clkCfg: ClkCfg.Explicit, rstCfg) =>
-      Explicit(name, clkCfg.copyWithNewRefs, rstCfg).asInstanceOf[this.type]
-    case _ => this
+    case _                         => this
 end RTDomainCfg
 
 object RTDomainCfg:

compiler/ir/src/main/scala/dfhdl/compiler/ir/DB.scala

@@ -7,13 +7,14 @@ import scala.collection.immutable.{ListMap, ListSet, BitSet}
 import dfhdl.internals.*
 import dfhdl.compiler.printing.{Printer, DefaultPrinter}
 import DFDesignBlock.InstMode
+import upickle.default.*
 
 final case class DB(
     members: List[DFMember],
     refTable: Map[DFRefAny, DFMember],
-    globalTags: Map[(Any, ClassTag[?]), DFTag],
+    globalTags: DFTags,
     srcFiles: List[SourceFile]
-):
+) derives CanEqual, ReadWriter:
   private val self = this
   given getSet: MemberGetSet with
     val designDB: DB = self
@@ -26,12 +27,10 @@ final case class DB(
       newMemberFunc(originalMember)
     def replace[M <: DFMember](originalMember: M)(newMember: M): M = newMember
     def remove[M <: DFMember](member: M): M = member
-    def setGlobalTag[CT <: DFTag: ClassTag](
-        taggedElement: Any,
-        tag: CT
-    ): Unit = {}
-    def getGlobalTag[CT <: DFTag: ClassTag](taggedElement: Any): Option[CT] =
-      globalTags.get((taggedElement, classTag[CT])).asInstanceOf[Option[CT]]
+    def setGlobalTag[CT <: DFTag: ClassTag](tag: CT): Unit = throw new Exception(
+      "Cannot set global tag on immutable DB"
+    )
+    def getGlobalTag[CT <: DFTag: ClassTag]: Option[CT] = globalTags.getTagOf[CT]
   end getSet
 
   // considered to be in simulation if the top design has no ports
@@ -725,7 +724,7 @@ final case class DB(
     private def getExplicitCfg: RTDomainCfg.Explicit =
       domainOwner.domainType match
         case DomainType.RT(explicitCfg: RTDomainCfg.Explicit) => explicitCfg
-        case _ => top.getTagOf[RTDomainCfg.Explicit].get
+        case _ => globalTags.getTagOf[DefaultRTDomainCfgTag].get.cfg
     private def usesClkRst: (Boolean, Boolean) = domainOwner match
       case design: DFDesignBlock =>
         designUsesClkRst.getOrElseUpdate(
@@ -835,16 +834,16 @@ final case class DB(
                       |Message:   $msg""".stripMargin
       val ownerDomain = wait.getOwnerDomain
       trigger.getConstData match
-        case Some((waitValue: BigDecimal, waitUnit: DFPhysical.Unit.Time.Scale)) =>
+        case Some((waitValue: BigDecimal, waitUnit: DFTime.Unit)) =>
           // Check if the wait statement is in a domain with a clock rate configuration
           explicitRTDomainCfgMap.get(ownerDomain) match
             case Some(RTDomainCfg.Explicit(_, clkCfg: ClkCfg.Explicit, _)) =>
               // Get the clock period in picoseconds
-              val (clockPeriodPs: BigDecimal, desc: String) = clkCfg.rate.getConstData.get match
-                case (value: BigDecimal, unit: DFPhysical.Unit.Time.Scale) =>
+              val (clockPeriodPs: BigDecimal, desc: String) = clkCfg.rate match
+                case (value: BigDecimal, unit: DFTime.Unit) =>
                   // Direct period specification
                   (unit.to_ps(value), s"period ${value}.${unit}")
-                case (value: BigDecimal, unit: DFPhysical.Unit.Freq.Scale) =>
+                case (value: BigDecimal, unit: DFFreq.Unit) =>
                   // Frequency specification - convert to period
                   (unit.to_ps(value), s"frequency ${value}.${unit}")
               // Get wait duration in picoseconds
@@ -1038,8 +1037,11 @@ final case class DB(
 
 end DB
 
-//object DB:
-//end DB
+object DB:
+  extension (db: DB)
+    def toJsonString: String = write(db)
+  def fromJsonString(json: String): DB = read[DB](json)
+end DB
 
 enum MemberView derives CanEqual:
   case Folded, Flattened
@@ -1052,7 +1054,7 @@ trait MemberGetSet:
   def set[M <: DFMember](originalMember: M)(newMemberFunc: M => M): M
   def replace[M <: DFMember](originalMember: M)(newMember: M): M
   def remove[M <: DFMember](member: M): M
-  def setGlobalTag[CT <: DFTag: ClassTag](taggedElement: Any, tag: CT): Unit
-  def getGlobalTag[CT <: DFTag: ClassTag](taggedElement: Any): Option[CT]
+  def setGlobalTag[CT <: DFTag: ClassTag](tag: CT): Unit
+  def getGlobalTag[CT <: DFTag: ClassTag]: Option[CT]
 
 def getSet(using MemberGetSet): MemberGetSet = summon[MemberGetSet]