From 2635bb4f80131ea7355abf18e6fcd06574bd49ab Mon Sep 17 00:00:00 2001 From: abejgonzalez Date: Sat, 8 Oct 2022 10:41:09 -0700 Subject: [PATCH 01/11] No-op barstools SFC compiler --- .../transforms/GenerateTopAndHarness.scala | 88 ++--------- .../transforms/stage/TapeoutStage.scala | 149 ++---------------- 2 files changed, 27 insertions(+), 210 deletions(-) diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala index ef9c5408..cede5d38 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala @@ -13,46 +13,28 @@ import logger.LazyLogging // Requires two phases, one to collect modules below synTop in the hierarchy // and a second to remove those modules to generate the test harness private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogging { - val synTop: Option[String] = annotations.collectFirst { case SynTopAnnotation(s) => s } - val topFir: Option[String] = annotations.collectFirst { case TopFirAnnotation(s) => s } - val harnessFir: Option[String] = annotations.collectFirst { case HarnessFirAnnotation(s) => s } - val topAnnoOut: Option[String] = annotations.collectFirst { case TopAnnoOutAnnotation(s) => s } - val harnessAnnoOut: Option[String] = annotations.collectFirst { case HarnessAnnoOutAnnotation(s) => s } - val harnessTop: Option[String] = annotations.collectFirst { case HarnessTopAnnotation(h) => h } - val harnessConf: Option[String] = annotations.collectFirst { case HarnessConfAnnotation(h) => h } - val harnessOutput: Option[String] = annotations.collectFirst { case HarnessOutputAnnotation(h) => h } - val topDotfOut: Option[String] = annotations.collectFirst { case TopDotfOutAnnotation(h) => h } - val harnessDotfOut: Option[String] = annotations.collectFirst { case HarnessDotfOutAnnotation(h) => h } - - val annoFiles: List[String] = annotations.flatMap { - case InputAnnotationFileAnnotation(f) => Some(f) - case _ => None - }.toList - - lazy val rootCircuitTarget = CircuitTarget(harnessTop.get) - - val topAnnos = synTop.map(st => ReParentCircuitAnnotation(rootCircuitTarget.module(st))) ++ - topDotfOut.map(BlackBoxResourceFileNameAnno) + val outFir: Option[String] = annotations.collectFirst { case OutFirAnnotation(s) => s } + val outAnno: Option[String] = annotations.collectFirst { case OutAnnoAnnotation(s) => s } // Dump firrtl and annotation files protected def dump( circuit: Circuit, annotations: AnnotationSeq, - firFile: Option[String], - annoFile: Option[String] ): Unit = { - firFile.foreach { firPath => + outFir.foreach { firPath => val outputFile = new java.io.PrintWriter(firPath) outputFile.write(circuit.serialize) outputFile.close() } - annoFile.foreach { annoPath => + outAnno.foreach { annoPath => val outputFile = new java.io.PrintWriter(annoPath) outputFile.write(JsonProtocol.serialize(annotations.filter(_ match { case _: DeletedAnnotation => false case _: EmittedComponent => false case _: EmittedAnnotation[_] => false case _: FirrtlCircuitAnnotation => false + case _: OutAnnoAnnotation => false + case _: OutFirAnnotation => false case _ => true }))) outputFile.close() @@ -60,65 +42,15 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg } // Top Generation - def executeTop(): Seq[ExtModule] = { - val annos = new FirrtlStage().execute( - Array.empty, - annotations ++ Seq( - RunFirrtlTransformAnnotation(Dependency[ReParentCircuit]), - RunFirrtlTransformAnnotation(Dependency[RemoveUnusedModules]) - ) ++ - topAnnos - ) + def executeTop(): Unit = { + val annos = new FirrtlStage().execute(Array.empty, annotations) annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { case Some(circuit) => - dump(circuit, annos, topFir, topAnnoOut) - circuit.modules.collect { case e: ExtModule => e } - case _ => - throw new Exception(s"executeTop failed while executing FIRRTL!\n") - } - } - - // Top and harness generation - def executeTopAndHarness(): Unit = { - // Execute top and get list of ExtModules to avoid collisions - val topExtModules = executeTop() - - // order is determined by DependencyAPIMigration - val harnessAnnos = - harnessDotfOut.map(BlackBoxResourceFileNameAnno).toSeq ++ - harnessTop.map(ht => ModuleNameSuffixAnnotation(rootCircuitTarget, s"_in${ht}")) ++ - synTop.map(st => ConvertToExtModAnnotation(rootCircuitTarget.module(st))) ++ - Seq( - LinkExtModulesAnnotation(topExtModules), - RunFirrtlTransformAnnotation(Dependency[ConvertToExtMod]), - RunFirrtlTransformAnnotation(Dependency[RemoveUnusedModules]), - RunFirrtlTransformAnnotation(Dependency[AvoidExtModuleCollisions]), - RunFirrtlTransformAnnotation(Dependency[AddSuffixToModuleNames]) - ) - - // For harness run, change some firrtlOptions (below) for harness phase - // customTransforms: setup harness transforms, add AvoidExtModuleCollisions - // outputFileNameOverride: change to harnessOutput - // conf file must change to harnessConf by mapping annotations - - val generatorAnnotations = annotations - .filterNot(_.isInstanceOf[OutputFileAnnotation]) - .map { - case ReplSeqMemAnnotation(i, _) => ReplSeqMemAnnotation(i, harnessConf.get) - case HarnessOutputAnnotation(s) => OutputFileAnnotation(s) - case anno => anno - } ++ harnessAnnos - - val annos = new FirrtlStage().execute(Array.empty, generatorAnnotations) - annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { - case Some(circuit) => - dump(circuit, annos, harnessFir, harnessAnnoOut) + dump(circuit, annos) case _ => throw new Exception(s"executeTop failed while executing FIRRTL!\n") } } } -object GenerateTop extends StageMain(new TapeoutStage(doHarness = false)) - -object GenerateTopAndHarness extends StageMain(new TapeoutStage(doHarness = true)) +object GenerateTop extends StageMain(new TapeoutStage) diff --git a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala index 7bbb046a..67d2715f 100644 --- a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala +++ b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala @@ -14,132 +14,28 @@ sealed trait TapeoutOption extends Unserializable { this: Annotation => } -case class HarnessOutputAnnotation(harnessOutput: String) extends NoTargetAnnotation with TapeoutOption +case class OutFirAnnotation(outFir: String) extends NoTargetAnnotation with TapeoutOption -object HarnessOutputAnnotation extends HasShellOptions { +object OutFirAnnotation extends HasShellOptions { val options: Seq[ShellOption[_]] = Seq( new ShellOption[String]( - longOption = "harness-o", - shortOption = Some("tho"), - toAnnotationSeq = (s: String) => Seq(HarnessOutputAnnotation(s)), - helpText = "use this to generate a harness at " + longOption = "out-fir-file", + shortOption = Some("off"), + toAnnotationSeq = (s: String) => Seq(OutFirAnnotation(s)), + helpText = "out-fir-file" ) ) } -case class SynTopAnnotation(synTop: String) extends NoTargetAnnotation with TapeoutOption +case class OutAnnoAnnotation(outAnno: String) extends NoTargetAnnotation with TapeoutOption -object SynTopAnnotation extends HasShellOptions { +object OutAnnoAnnotation extends HasShellOptions { val options: Seq[ShellOption[_]] = Seq( new ShellOption[String]( - longOption = "syn-top", - shortOption = Some("tst"), - toAnnotationSeq = (s: String) => Seq(SynTopAnnotation(s)), - helpText = "use this to set synTop" - ) - ) -} - -case class TopFirAnnotation(topFir: String) extends NoTargetAnnotation with TapeoutOption - -object TopFirAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "top-fir", - shortOption = Some("tsf"), - toAnnotationSeq = (s: String) => Seq(TopFirAnnotation(s)), - helpText = "use this to set topFir" - ) - ) -} - -case class TopAnnoOutAnnotation(topAnnoOut: String) extends NoTargetAnnotation with TapeoutOption - -object TopAnnoOutAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "top-anno-out", - shortOption = Some("tsaof"), - toAnnotationSeq = (s: String) => Seq(TopAnnoOutAnnotation(s)), - helpText = "use this to set topAnnoOut" - ) - ) -} - -case class TopDotfOutAnnotation(topDotfOut: String) extends NoTargetAnnotation with TapeoutOption - -object TopDotfOutAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "top-dotf-out", - shortOption = Some("tdf"), - toAnnotationSeq = (s: String) => Seq(TopDotfOutAnnotation(s)), - helpText = "use this to set the filename for the top resource .f file" - ) - ) -} - -case class HarnessTopAnnotation(harnessTop: String) extends NoTargetAnnotation with TapeoutOption - -object HarnessTopAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "harness-top", - shortOption = Some("tht"), - toAnnotationSeq = (s: String) => Seq(HarnessTopAnnotation(s)), - helpText = "use this to set harnessTop" - ) - ) -} - -case class HarnessFirAnnotation(harnessFir: String) extends NoTargetAnnotation with TapeoutOption - -object HarnessFirAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "harness-fir", - shortOption = Some("thf"), - toAnnotationSeq = (s: String) => Seq(HarnessFirAnnotation(s)), - helpText = "use this to set harnessFir" - ) - ) -} - -case class HarnessAnnoOutAnnotation(harnessAnnoOut: String) extends NoTargetAnnotation with TapeoutOption - -object HarnessAnnoOutAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "harness-anno-out", - shortOption = Some("thaof"), - toAnnotationSeq = (s: String) => Seq(HarnessAnnoOutAnnotation(s)), - helpText = "use this to set harnessAnnoOut" - ) - ) -} - -case class HarnessDotfOutAnnotation(harnessDotfOut: String) extends NoTargetAnnotation with TapeoutOption - -object HarnessDotfOutAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "harness-dotf-out", - shortOption = Some("hdf"), - toAnnotationSeq = (s: String) => Seq(HarnessDotfOutAnnotation(s)), - helpText = "use this to set the filename for the harness resource .f file" - ) - ) -} - -case class HarnessConfAnnotation(harnessConf: String) extends NoTargetAnnotation with TapeoutOption - -object HarnessConfAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "harness-conf", - shortOption = Some("thconf"), - toAnnotationSeq = (s: String) => Seq(HarnessConfAnnotation(s)), - helpText = "use this to set the harness conf file location" + longOption = "out-anno-file", + shortOption = Some("oaf"), + toAnnotationSeq = (s: String) => Seq(OutAnnoAnnotation(s)), + helpText = "out-anno-file" ) ) } @@ -149,32 +45,21 @@ trait TapeoutCli { parser.note("Tapeout specific options") Seq( - HarnessOutputAnnotation, - SynTopAnnotation, - TopFirAnnotation, - TopAnnoOutAnnotation, - TopDotfOutAnnotation, - HarnessTopAnnotation, - HarnessFirAnnotation, - HarnessAnnoOutAnnotation, - HarnessDotfOutAnnotation, - HarnessConfAnnotation + OutAnnoAnnotation, + OutFirAnnotation, ).foreach(_.addOptions(parser)) } -class TapeoutStage(doHarness: Boolean) extends Stage { +class TapeoutStage extends Stage { override val shell: Shell = new Shell(applicationName = "tapeout") with TapeoutCli with ChiselCli with FirrtlCli override def run(annotations: AnnotationSeq): AnnotationSeq = { Logger.makeScope(annotations) { val generator = new GenerateTopAndHarness(annotations) - if (doHarness) { - generator.executeTopAndHarness() - } else { - generator.executeTop() - } + generator.executeTop() } annotations } } + From cf75889804f640eb5f053396974f5a3f6b8372b6 Mon Sep 17 00:00:00 2001 From: abejgonzalez Date: Sun, 9 Oct 2022 17:01:06 -0700 Subject: [PATCH 02/11] Attempt at checking for Fixed types --- .../CheckForUnsupportedFirtoolTypes.scala | 72 +++++++++++++++++++ .../transforms/GenerateTopAndHarness.scala | 14 ++-- .../transforms/stage/TapeoutStage.scala | 14 ---- 3 files changed, 78 insertions(+), 22 deletions(-) create mode 100644 src/main/scala/barstools/tapeout/transforms/CheckForUnsupportedFirtoolTypes.scala diff --git a/src/main/scala/barstools/tapeout/transforms/CheckForUnsupportedFirtoolTypes.scala b/src/main/scala/barstools/tapeout/transforms/CheckForUnsupportedFirtoolTypes.scala new file mode 100644 index 00000000..d584b147 --- /dev/null +++ b/src/main/scala/barstools/tapeout/transforms/CheckForUnsupportedFirtoolTypes.scala @@ -0,0 +1,72 @@ +// See LICENSE for license details. + +package barstools.tapeout.transforms + +import firrtl._ +import firrtl.annotations.{ModuleTarget, ReferenceTarget, SingleTargetAnnotation} +import firrtl.ir._ +import firrtl.options.Dependency +import firrtl.passes.memlib.ReplSeqMem +import firrtl.stage.Forms +import firrtl.stage.{RunFirrtlTransformAnnotation} +import firrtl.stage.TransformManager.TransformDependency + +class CheckForUnsupportedFirtoolTypes extends Transform with DependencyAPIMigration { + override def prerequisites: Seq[TransformDependency] = Forms.ChirrtlForm + override def optionalPrerequisites: Seq[TransformDependency] = Seq.empty + override def optionalPrerequisiteOf: Seq[TransformDependency] = Seq.empty + override def invalidates(a: Transform): Boolean = false + + def run(state: CircuitState): Boolean = { + val c = state.circuit + + //def checkFixed(t: Type): Unit = { + // println(s"checkFixed -> $t") + // t match { + // case FixedType(_, _) => { + // runLowering = true + // println(s"runLowering is $runLowering") + // } + // case _ => Unit + // } + //} + + def onStmtType(s: Statement): Boolean = { + var runLowering = false + println(s"Entering onStmtType") + + def recursive(s: Statement): Unit = { + s match { + case x: DefRegister => x.foreachType(_ => println(s"It works!")) + case x: DefWire => x.foreachType(_ => println(s"1 It works!")) + case x: DefNode => x.foreachType(_ => println(s"2 It works!")) + case x: DefMemory => x.foreachType(_ => println(s"3 It works!")) + case x: WDefInstance => x.foreachType(_ => println(s"4 It works!")) + case x: Connect => x.foreachType(_ => println(s"5 It works!")) + case x: PartialConnect => x.foreachType(_ => println(s"6 It works!")) + case x: Block => x.foreachStmt(recursive) + case x => x.foreachType(_ => println(s"Uh oh")) + } + } + + //s.foreachType(checkFixed) + s.foreachType(_ => println("Reached")) + + runLowering + } + + val runLoweringOverall = c.modules.map { + case m: ExtModule => false + case m: Module => onStmtType(m.body) + } + + runLoweringOverall.reduce(_ || _) + } + + def execute(state: CircuitState): CircuitState = { + val runLoweringAnnos = Seq(RunFirrtlTransformAnnotation(new MiddleFirrtlEmitter)) + val doLowering = run(state) + println(s"DEBUG: Final doLowering -> $doLowering") + state.copy(annotations = state.annotations) + } +} diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala index cede5d38..44aa37cf 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala @@ -7,13 +7,13 @@ import firrtl.ir._ import firrtl.options.{Dependency, InputAnnotationFileAnnotation, StageMain} import firrtl.passes.memlib.ReplSeqMemAnnotation import firrtl.stage.{FirrtlCircuitAnnotation, FirrtlStage, OutputFileAnnotation, RunFirrtlTransformAnnotation} +import firrtl.passes.{ConvertFixedToSInt} import firrtl.transforms.BlackBoxResourceFileNameAnno import logger.LazyLogging // Requires two phases, one to collect modules below synTop in the hierarchy // and a second to remove those modules to generate the test harness private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogging { - val outFir: Option[String] = annotations.collectFirst { case OutFirAnnotation(s) => s } val outAnno: Option[String] = annotations.collectFirst { case OutAnnoAnnotation(s) => s } // Dump firrtl and annotation files @@ -21,11 +21,6 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg circuit: Circuit, annotations: AnnotationSeq, ): Unit = { - outFir.foreach { firPath => - val outputFile = new java.io.PrintWriter(firPath) - outputFile.write(circuit.serialize) - outputFile.close() - } outAnno.foreach { annoPath => val outputFile = new java.io.PrintWriter(annoPath) outputFile.write(JsonProtocol.serialize(annotations.filter(_ match { @@ -34,16 +29,19 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg case _: EmittedAnnotation[_] => false case _: FirrtlCircuitAnnotation => false case _: OutAnnoAnnotation => false - case _: OutFirAnnotation => false case _ => true }))) outputFile.close() } } + // TODO: Filter out blackbox dumping from this FIRRTL step, let CIRCT do it + // Top Generation def executeTop(): Unit = { - val annos = new FirrtlStage().execute(Array.empty, annotations) + val annos = new FirrtlStage().execute(Array.empty, annotations) //++ Seq( + // RunFirrtlTransformAnnotation(Dependency[CheckForUnsupportedFirtoolTypes] + //))) annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { case Some(circuit) => dump(circuit, annos) diff --git a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala index 67d2715f..2ba0bdb8 100644 --- a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala +++ b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala @@ -14,19 +14,6 @@ sealed trait TapeoutOption extends Unserializable { this: Annotation => } -case class OutFirAnnotation(outFir: String) extends NoTargetAnnotation with TapeoutOption - -object OutFirAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "out-fir-file", - shortOption = Some("off"), - toAnnotationSeq = (s: String) => Seq(OutFirAnnotation(s)), - helpText = "out-fir-file" - ) - ) -} - case class OutAnnoAnnotation(outAnno: String) extends NoTargetAnnotation with TapeoutOption object OutAnnoAnnotation extends HasShellOptions { @@ -46,7 +33,6 @@ trait TapeoutCli { Seq( OutAnnoAnnotation, - OutFirAnnotation, ).foreach(_.addOptions(parser)) } From d1295e68f87e2adb377a97b75967fc20cdca5950 Mon Sep 17 00:00:00 2001 From: joey0320 Date: Fri, 23 Dec 2022 11:21:08 -0800 Subject: [PATCH 03/11] Add back HarnessConf --- .../transforms/GenerateTopAndHarness.scala | 33 ++++++++++++++++++- .../transforms/stage/TapeoutStage.scala | 22 +++++++++++-- 2 files changed, 52 insertions(+), 3 deletions(-) diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala index 44aa37cf..448d6b1a 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala @@ -15,6 +15,12 @@ import logger.LazyLogging // and a second to remove those modules to generate the test harness private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogging { val outAnno: Option[String] = annotations.collectFirst { case OutAnnoAnnotation(s) => s } + val harnessConf: Option[String] = annotations.collectFirst { case HarnessConfAnnotation(h) => h } + + val annoFiles: List[String] = annotations.flatMap { + case InputAnnotationFileAnnotation(f) => Some(f) + case _ => None + }.toList // Dump firrtl and annotation files protected def dump( @@ -49,6 +55,31 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg throw new Exception(s"executeTop failed while executing FIRRTL!\n") } } + + // Top and harness generation + def executeTopAndHarness(): Unit = { + executeTop() + + // For harness run, change some firrtlOptions (below) for harness phase + // customTransforms: setup harness transforms, add AvoidExtModuleCollisions + // outputFileNameOverride: change to harnessOutput + // conf file must change to harnessConf by mapping annotations + val generatorAnnotations = annotations + .filterNot(_.isInstanceOf[OutputFileAnnotation]) + .map { + case ReplSeqMemAnnotation(i, _) => ReplSeqMemAnnotation(i, harnessConf.get) + case anno => anno + } + + val annos = new FirrtlStage().execute(Array.empty, generatorAnnotations) + annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { + case Some(circuit) => + dump(circuit, annos) + case _ => + throw new Exception(s"executeTop failed while executing FIRRTL!\n") + } + } } -object GenerateTop extends StageMain(new TapeoutStage) +object GenerateTop extends StageMain(new TapeoutStage(doHarness = false)) +object GenerateTopAndHarness extends StageMain(new TapeoutStage(doHarness = true)) diff --git a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala index 2ba0bdb8..9de5e04f 100644 --- a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala +++ b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala @@ -27,23 +27,41 @@ object OutAnnoAnnotation extends HasShellOptions { ) } +case class HarnessConfAnnotation(harnessConf: String) extends NoTargetAnnotation with TapeoutOption + +object HarnessConfAnnotation extends HasShellOptions { + val options: Seq[ShellOption[_]] = Seq( + new ShellOption[String]( + longOption = "harness-conf", + shortOption = Some("thconf"), + toAnnotationSeq = (s: String) => Seq(HarnessConfAnnotation(s)), + helpText = "use this to set the harness conf file location" + ) + ) +} + trait TapeoutCli { this: Shell => parser.note("Tapeout specific options") Seq( OutAnnoAnnotation, + HarnessConfAnnotation, ).foreach(_.addOptions(parser)) } -class TapeoutStage extends Stage { +class TapeoutStage(doHarness: Boolean) extends Stage { override val shell: Shell = new Shell(applicationName = "tapeout") with TapeoutCli with ChiselCli with FirrtlCli override def run(annotations: AnnotationSeq): AnnotationSeq = { Logger.makeScope(annotations) { val generator = new GenerateTopAndHarness(annotations) - generator.executeTop() + if (doHarness) { + generator.executeTopAndHarness() + } else { + generator.executeTop() + } } annotations } From 850f613a14662c143ccf22b88c2078aa72898ece Mon Sep 17 00:00:00 2001 From: joey0320 Date: Fri, 23 Dec 2022 20:11:07 -0800 Subject: [PATCH 04/11] Remove CheckForUnsupportedFirtoolTypes --- .../CheckForUnsupportedFirtoolTypes.scala | 72 ------------------- .../transforms/GenerateTopAndHarness.scala | 5 +- 2 files changed, 2 insertions(+), 75 deletions(-) delete mode 100644 src/main/scala/barstools/tapeout/transforms/CheckForUnsupportedFirtoolTypes.scala diff --git a/src/main/scala/barstools/tapeout/transforms/CheckForUnsupportedFirtoolTypes.scala b/src/main/scala/barstools/tapeout/transforms/CheckForUnsupportedFirtoolTypes.scala deleted file mode 100644 index d584b147..00000000 --- a/src/main/scala/barstools/tapeout/transforms/CheckForUnsupportedFirtoolTypes.scala +++ /dev/null @@ -1,72 +0,0 @@ -// See LICENSE for license details. - -package barstools.tapeout.transforms - -import firrtl._ -import firrtl.annotations.{ModuleTarget, ReferenceTarget, SingleTargetAnnotation} -import firrtl.ir._ -import firrtl.options.Dependency -import firrtl.passes.memlib.ReplSeqMem -import firrtl.stage.Forms -import firrtl.stage.{RunFirrtlTransformAnnotation} -import firrtl.stage.TransformManager.TransformDependency - -class CheckForUnsupportedFirtoolTypes extends Transform with DependencyAPIMigration { - override def prerequisites: Seq[TransformDependency] = Forms.ChirrtlForm - override def optionalPrerequisites: Seq[TransformDependency] = Seq.empty - override def optionalPrerequisiteOf: Seq[TransformDependency] = Seq.empty - override def invalidates(a: Transform): Boolean = false - - def run(state: CircuitState): Boolean = { - val c = state.circuit - - //def checkFixed(t: Type): Unit = { - // println(s"checkFixed -> $t") - // t match { - // case FixedType(_, _) => { - // runLowering = true - // println(s"runLowering is $runLowering") - // } - // case _ => Unit - // } - //} - - def onStmtType(s: Statement): Boolean = { - var runLowering = false - println(s"Entering onStmtType") - - def recursive(s: Statement): Unit = { - s match { - case x: DefRegister => x.foreachType(_ => println(s"It works!")) - case x: DefWire => x.foreachType(_ => println(s"1 It works!")) - case x: DefNode => x.foreachType(_ => println(s"2 It works!")) - case x: DefMemory => x.foreachType(_ => println(s"3 It works!")) - case x: WDefInstance => x.foreachType(_ => println(s"4 It works!")) - case x: Connect => x.foreachType(_ => println(s"5 It works!")) - case x: PartialConnect => x.foreachType(_ => println(s"6 It works!")) - case x: Block => x.foreachStmt(recursive) - case x => x.foreachType(_ => println(s"Uh oh")) - } - } - - //s.foreachType(checkFixed) - s.foreachType(_ => println("Reached")) - - runLowering - } - - val runLoweringOverall = c.modules.map { - case m: ExtModule => false - case m: Module => onStmtType(m.body) - } - - runLoweringOverall.reduce(_ || _) - } - - def execute(state: CircuitState): CircuitState = { - val runLoweringAnnos = Seq(RunFirrtlTransformAnnotation(new MiddleFirrtlEmitter)) - val doLowering = run(state) - println(s"DEBUG: Final doLowering -> $doLowering") - state.copy(annotations = state.annotations) - } -} diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala index 448d6b1a..b1d6b79a 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala @@ -45,9 +45,8 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg // Top Generation def executeTop(): Unit = { - val annos = new FirrtlStage().execute(Array.empty, annotations) //++ Seq( - // RunFirrtlTransformAnnotation(Dependency[CheckForUnsupportedFirtoolTypes] - //))) + val annos = new FirrtlStage().execute(Array.empty, annotations) + annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { case Some(circuit) => dump(circuit, annos) From 2dfa1847e7199a15bf64f4cf9283a7d1c9957a58 Mon Sep 17 00:00:00 2001 From: joey0320 Date: Fri, 23 Dec 2022 20:38:40 -0800 Subject: [PATCH 05/11] Fix formatting --- .../tapeout/transforms/GenerateTopAndHarness.scala | 8 ++++---- .../barstools/tapeout/transforms/stage/TapeoutStage.scala | 3 +-- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala index b1d6b79a..4df6e799 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala @@ -14,8 +14,8 @@ import logger.LazyLogging // Requires two phases, one to collect modules below synTop in the hierarchy // and a second to remove those modules to generate the test harness private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogging { - val outAnno: Option[String] = annotations.collectFirst { case OutAnnoAnnotation(s) => s } - val harnessConf: Option[String] = annotations.collectFirst { case HarnessConfAnnotation(h) => h } + val outAnno: Option[String] = annotations.collectFirst { case OutAnnoAnnotation(s) => s } + val harnessConf: Option[String] = annotations.collectFirst { case HarnessConfAnnotation(h) => h } val annoFiles: List[String] = annotations.flatMap { case InputAnnotationFileAnnotation(f) => Some(f) @@ -25,7 +25,7 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg // Dump firrtl and annotation files protected def dump( circuit: Circuit, - annotations: AnnotationSeq, + annotations: AnnotationSeq ): Unit = { outAnno.foreach { annoPath => val outputFile = new java.io.PrintWriter(annoPath) @@ -34,7 +34,7 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg case _: EmittedComponent => false case _: EmittedAnnotation[_] => false case _: FirrtlCircuitAnnotation => false - case _: OutAnnoAnnotation => false + case _: OutAnnoAnnotation => false case _ => true }))) outputFile.close() diff --git a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala index 9de5e04f..338cbc86 100644 --- a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala +++ b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala @@ -46,7 +46,7 @@ trait TapeoutCli { Seq( OutAnnoAnnotation, - HarnessConfAnnotation, + HarnessConfAnnotation ).foreach(_.addOptions(parser)) } @@ -66,4 +66,3 @@ class TapeoutStage(doHarness: Boolean) extends Stage { annotations } } - From 13e2bb92ab7360f0ce3b2ff4d27b3024736111fb Mon Sep 17 00:00:00 2001 From: joey0320 Date: Fri, 23 Dec 2022 20:50:42 -0800 Subject: [PATCH 06/11] Remove GenerateTopSpec.scala test as the FIRRTL passes are removed --- .../tapeout/transforms/GenerateTopSpec.scala | 98 ------------------- 1 file changed, 98 deletions(-) delete mode 100644 src/test/scala/barstools/tapeout/transforms/GenerateTopSpec.scala diff --git a/src/test/scala/barstools/tapeout/transforms/GenerateTopSpec.scala b/src/test/scala/barstools/tapeout/transforms/GenerateTopSpec.scala deleted file mode 100644 index d967c8df..00000000 --- a/src/test/scala/barstools/tapeout/transforms/GenerateTopSpec.scala +++ /dev/null @@ -1,98 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 - -package barstools.tapeout.transforms - -import chisel3.stage.ChiselStage -import firrtl.FileUtils -import org.scalatest.freespec.AnyFreeSpec -import org.scalatest.matchers.should.Matchers - -import java.io.{File, PrintWriter} - -class GenerateTopSpec extends AnyFreeSpec with Matchers { - "Generate top and harness" - { - "should include the following transforms" in { - val targetDir = "test_run_dir/generate_top_and_harness" - val transformListName = s"$targetDir/ExampleModuleNeesResetInvertTransforms.log" - FileUtils.makeDirectory(targetDir) - (new ChiselStage).emitChirrtl(new ExampleModuleNeedsResetInverted, Array("--target-dir", targetDir)) - - GenerateTopAndHarness.main( - Array( - "-i", - s"$targetDir/ExampleModuleNeedsResetInverted.fir", - "-ll", - "info", - "--log-file", - transformListName - ) - ) - - val output = FileUtils.getText(transformListName) - output should include("barstools.tapeout.transforms.AddSuffixToModuleNames") - output should include("barstools.tapeout.transforms.ConvertToExtMod") - output should include("barstools.tapeout.transforms.RemoveUnusedModules") - output should include("barstools.tapeout.transforms.AvoidExtModuleCollisions") - } - } - - "generate harness should be generated" ignore { - val targetDir = "test_run_dir/generate_top_spec" - val logOutputName = s"$targetDir/top_spec_output.log" - FileUtils.makeDirectory(targetDir) - - val input = FileUtils.getLinesResource("/BlackBoxFloatTester.fir") - val printWriter = new PrintWriter(new File(s"$targetDir/BlackBoxFloatTester.fir")) - printWriter.write(input.mkString("\n")) - printWriter.close() - - println(s"""Resource: ${input.mkString("\n")}""") - - GenerateTopAndHarness.main( - Array( - "--target-dir", - "test_run_dir/generate_top_spec", - "-i", - s"$targetDir/BlackBoxFloatTester.fir", - "-o", - "chipyard.unittest.TestHarness.IceNetUnitTestConfig.top.v", - "-tho", - "chipyard.unittest.TestHarness.IceNetUnitTestConfig.harness.v", - "-i", - "chipyard.unittest.TestHarness.IceNetUnitTestConfig.fir", - "--syn-top", - "UnitTestSuite", - "--harness-top", - "TestHarness", - "-faf", - "chipyard.unittest.TestHarness.IceNetUnitTestConfig.anno.json", - "-tsaof", - "chipyard.unittest.TestHarness.IceNetUnitTestConfig.top.anno.json", - "-tdf", - "firrtl_black_box_resource_files.top.f", - "-tsf", - "chipyard.unittest.TestHarness.IceNetUnitTestConfig.top.fir", - "-thaof", - "chipyard.unittest.TestHarness.IceNetUnitTestConfig.harness.anno.json", - "-hdf", - "firrtl_black_box_resource_files.harness.f", - "-thf", - "chipyard.unittest.TestHarness.IceNetUnitTestConfig.harness.fir", - "--infer-rw", - "--repl-seq-mem", - "-c:TestHarness:-o:chipyard.unittest.TestHarness.IceNetUnitTestConfig.top.mems.conf", - "-thconf", - "chipyard.unittest.TestHarness.IceNetUnitTestConfig.harness.mems.conf", - "-td", - "test_run_dir/from-ci", - "-ll", - "info", - "--log-file", - logOutputName - ) - ) - - val output = FileUtils.getText(logOutputName) - println(output) - } -} From 5af7f216487df81a5ad8cda6d4fb4b79cee0e4d2 Mon Sep 17 00:00:00 2001 From: joey0320 Date: Wed, 28 Dec 2022 11:12:18 -0800 Subject: [PATCH 07/11] Remove executeTop & make everything to execute --- .../transforms/GenerateTopAndHarness.scala | 30 ++++--------------- .../transforms/stage/TapeoutStage.scala | 9 ++---- 2 files changed, 7 insertions(+), 32 deletions(-) diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala index 4df6e799..de3b8a65 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala @@ -7,7 +7,6 @@ import firrtl.ir._ import firrtl.options.{Dependency, InputAnnotationFileAnnotation, StageMain} import firrtl.passes.memlib.ReplSeqMemAnnotation import firrtl.stage.{FirrtlCircuitAnnotation, FirrtlStage, OutputFileAnnotation, RunFirrtlTransformAnnotation} -import firrtl.passes.{ConvertFixedToSInt} import firrtl.transforms.BlackBoxResourceFileNameAnno import logger.LazyLogging @@ -23,8 +22,8 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg }.toList // Dump firrtl and annotation files - protected def dump( - circuit: Circuit, + // Reads global params "outAnno" + protected def dumpAnnos( annotations: AnnotationSeq ): Unit = { outAnno.foreach { annoPath => @@ -43,26 +42,8 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg // TODO: Filter out blackbox dumping from this FIRRTL step, let CIRCT do it - // Top Generation - def executeTop(): Unit = { - val annos = new FirrtlStage().execute(Array.empty, annotations) - - annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { - case Some(circuit) => - dump(circuit, annos) - case _ => - throw new Exception(s"executeTop failed while executing FIRRTL!\n") - } - } - // Top and harness generation - def executeTopAndHarness(): Unit = { - executeTop() - - // For harness run, change some firrtlOptions (below) for harness phase - // customTransforms: setup harness transforms, add AvoidExtModuleCollisions - // outputFileNameOverride: change to harnessOutput - // conf file must change to harnessConf by mapping annotations + def execute(): Unit = { val generatorAnnotations = annotations .filterNot(_.isInstanceOf[OutputFileAnnotation]) .map { @@ -73,12 +54,11 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg val annos = new FirrtlStage().execute(Array.empty, generatorAnnotations) annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { case Some(circuit) => - dump(circuit, annos) + dumpAnnos(annos) case _ => throw new Exception(s"executeTop failed while executing FIRRTL!\n") } } } -object GenerateTop extends StageMain(new TapeoutStage(doHarness = false)) -object GenerateTopAndHarness extends StageMain(new TapeoutStage(doHarness = true)) +object GenerateTopAndHarness extends StageMain(new TapeoutStage()) diff --git a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala index 338cbc86..730bbfac 100644 --- a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala +++ b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala @@ -50,18 +50,13 @@ trait TapeoutCli { ).foreach(_.addOptions(parser)) } -class TapeoutStage(doHarness: Boolean) extends Stage { +class TapeoutStage() extends Stage { override val shell: Shell = new Shell(applicationName = "tapeout") with TapeoutCli with ChiselCli with FirrtlCli override def run(annotations: AnnotationSeq): AnnotationSeq = { Logger.makeScope(annotations) { val generator = new GenerateTopAndHarness(annotations) - - if (doHarness) { - generator.executeTopAndHarness() - } else { - generator.executeTop() - } + generator.execute() } annotations } From 723bab78b948c2da0e56dde4fe087443d3f31d60 Mon Sep 17 00:00:00 2001 From: joey0320 Date: Wed, 28 Dec 2022 13:09:27 -0800 Subject: [PATCH 08/11] Revert "Remove executeTop & make everything to execute" This reverts commit 5af7f216487df81a5ad8cda6d4fb4b79cee0e4d2. --- .../transforms/GenerateTopAndHarness.scala | 30 +++++++++++++++---- .../transforms/stage/TapeoutStage.scala | 9 ++++-- 2 files changed, 32 insertions(+), 7 deletions(-) diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala index de3b8a65..4df6e799 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala @@ -7,6 +7,7 @@ import firrtl.ir._ import firrtl.options.{Dependency, InputAnnotationFileAnnotation, StageMain} import firrtl.passes.memlib.ReplSeqMemAnnotation import firrtl.stage.{FirrtlCircuitAnnotation, FirrtlStage, OutputFileAnnotation, RunFirrtlTransformAnnotation} +import firrtl.passes.{ConvertFixedToSInt} import firrtl.transforms.BlackBoxResourceFileNameAnno import logger.LazyLogging @@ -22,8 +23,8 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg }.toList // Dump firrtl and annotation files - // Reads global params "outAnno" - protected def dumpAnnos( + protected def dump( + circuit: Circuit, annotations: AnnotationSeq ): Unit = { outAnno.foreach { annoPath => @@ -42,8 +43,26 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg // TODO: Filter out blackbox dumping from this FIRRTL step, let CIRCT do it + // Top Generation + def executeTop(): Unit = { + val annos = new FirrtlStage().execute(Array.empty, annotations) + + annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { + case Some(circuit) => + dump(circuit, annos) + case _ => + throw new Exception(s"executeTop failed while executing FIRRTL!\n") + } + } + // Top and harness generation - def execute(): Unit = { + def executeTopAndHarness(): Unit = { + executeTop() + + // For harness run, change some firrtlOptions (below) for harness phase + // customTransforms: setup harness transforms, add AvoidExtModuleCollisions + // outputFileNameOverride: change to harnessOutput + // conf file must change to harnessConf by mapping annotations val generatorAnnotations = annotations .filterNot(_.isInstanceOf[OutputFileAnnotation]) .map { @@ -54,11 +73,12 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg val annos = new FirrtlStage().execute(Array.empty, generatorAnnotations) annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { case Some(circuit) => - dumpAnnos(annos) + dump(circuit, annos) case _ => throw new Exception(s"executeTop failed while executing FIRRTL!\n") } } } -object GenerateTopAndHarness extends StageMain(new TapeoutStage()) +object GenerateTop extends StageMain(new TapeoutStage(doHarness = false)) +object GenerateTopAndHarness extends StageMain(new TapeoutStage(doHarness = true)) diff --git a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala index 730bbfac..338cbc86 100644 --- a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala +++ b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala @@ -50,13 +50,18 @@ trait TapeoutCli { ).foreach(_.addOptions(parser)) } -class TapeoutStage() extends Stage { +class TapeoutStage(doHarness: Boolean) extends Stage { override val shell: Shell = new Shell(applicationName = "tapeout") with TapeoutCli with ChiselCli with FirrtlCli override def run(annotations: AnnotationSeq): AnnotationSeq = { Logger.makeScope(annotations) { val generator = new GenerateTopAndHarness(annotations) - generator.execute() + + if (doHarness) { + generator.executeTopAndHarness() + } else { + generator.executeTop() + } } annotations } From 899387f4fb54279a8d5c0a16e543c2cc6e60f6b8 Mon Sep 17 00:00:00 2001 From: joey0320 Date: Wed, 28 Dec 2022 13:11:18 -0800 Subject: [PATCH 09/11] Fix dump to dumpAnnos --- .../tapeout/transforms/GenerateTopAndHarness.scala | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala index 4df6e799..12c416cf 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala @@ -7,7 +7,6 @@ import firrtl.ir._ import firrtl.options.{Dependency, InputAnnotationFileAnnotation, StageMain} import firrtl.passes.memlib.ReplSeqMemAnnotation import firrtl.stage.{FirrtlCircuitAnnotation, FirrtlStage, OutputFileAnnotation, RunFirrtlTransformAnnotation} -import firrtl.passes.{ConvertFixedToSInt} import firrtl.transforms.BlackBoxResourceFileNameAnno import logger.LazyLogging @@ -23,8 +22,8 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg }.toList // Dump firrtl and annotation files - protected def dump( - circuit: Circuit, + // Use global param outAnno + protected def dumpAnnos( annotations: AnnotationSeq ): Unit = { outAnno.foreach { annoPath => @@ -49,7 +48,7 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { case Some(circuit) => - dump(circuit, annos) + dumpAnnos(annos) case _ => throw new Exception(s"executeTop failed while executing FIRRTL!\n") } @@ -73,7 +72,7 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg val annos = new FirrtlStage().execute(Array.empty, generatorAnnotations) annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { case Some(circuit) => - dump(circuit, annos) + dumpAnnos(annos) case _ => throw new Exception(s"executeTop failed while executing FIRRTL!\n") } From e340f1240a2c5feeb85160a7f81a32496916a7c4 Mon Sep 17 00:00:00 2001 From: joey0320 Date: Wed, 28 Dec 2022 23:39:49 -0800 Subject: [PATCH 10/11] Remove all passes again | rename GenerateTopAndHarness to GenerateModelStageMain --- ...ess.scala => GenerateModelStageMain.scala} | 37 ++----------------- .../transforms/stage/TapeoutStage.scala | 27 ++------------ 2 files changed, 7 insertions(+), 57 deletions(-) rename src/main/scala/barstools/tapeout/transforms/{GenerateTopAndHarness.scala => GenerateModelStageMain.scala} (51%) diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala b/src/main/scala/barstools/tapeout/transforms/GenerateModelStageMain.scala similarity index 51% rename from src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala rename to src/main/scala/barstools/tapeout/transforms/GenerateModelStageMain.scala index 12c416cf..2de98408 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateTopAndHarness.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateModelStageMain.scala @@ -10,11 +10,8 @@ import firrtl.stage.{FirrtlCircuitAnnotation, FirrtlStage, OutputFileAnnotation, import firrtl.transforms.BlackBoxResourceFileNameAnno import logger.LazyLogging -// Requires two phases, one to collect modules below synTop in the hierarchy -// and a second to remove those modules to generate the test harness -private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogging { +private class GenerateModelStageMain(annotations: AnnotationSeq) extends LazyLogging { val outAnno: Option[String] = annotations.collectFirst { case OutAnnoAnnotation(s) => s } - val harnessConf: Option[String] = annotations.collectFirst { case HarnessConfAnnotation(h) => h } val annoFiles: List[String] = annotations.flatMap { case InputAnnotationFileAnnotation(f) => Some(f) @@ -40,10 +37,7 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg } } - // TODO: Filter out blackbox dumping from this FIRRTL step, let CIRCT do it - - // Top Generation - def executeTop(): Unit = { + def executeStageMain(): Unit = { val annos = new FirrtlStage().execute(Array.empty, annotations) annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { @@ -53,31 +47,6 @@ private class GenerateTopAndHarness(annotations: AnnotationSeq) extends LazyLogg throw new Exception(s"executeTop failed while executing FIRRTL!\n") } } - - // Top and harness generation - def executeTopAndHarness(): Unit = { - executeTop() - - // For harness run, change some firrtlOptions (below) for harness phase - // customTransforms: setup harness transforms, add AvoidExtModuleCollisions - // outputFileNameOverride: change to harnessOutput - // conf file must change to harnessConf by mapping annotations - val generatorAnnotations = annotations - .filterNot(_.isInstanceOf[OutputFileAnnotation]) - .map { - case ReplSeqMemAnnotation(i, _) => ReplSeqMemAnnotation(i, harnessConf.get) - case anno => anno - } - - val annos = new FirrtlStage().execute(Array.empty, generatorAnnotations) - annos.collectFirst { case FirrtlCircuitAnnotation(circuit) => circuit } match { - case Some(circuit) => - dumpAnnos(annos) - case _ => - throw new Exception(s"executeTop failed while executing FIRRTL!\n") - } - } } -object GenerateTop extends StageMain(new TapeoutStage(doHarness = false)) -object GenerateTopAndHarness extends StageMain(new TapeoutStage(doHarness = true)) +object GenerateModelStageMain extends StageMain(new TapeoutStage()) diff --git a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala index 338cbc86..bff297b1 100644 --- a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala +++ b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala @@ -2,7 +2,7 @@ package barstools.tapeout.transforms.stage -import barstools.tapeout.transforms.GenerateTopAndHarness +import barstools.tapeout.transforms.GenerateModelStageMain import chisel3.stage.ChiselCli import firrtl.AnnotationSeq import firrtl.annotations.{Annotation, NoTargetAnnotation} @@ -27,41 +27,22 @@ object OutAnnoAnnotation extends HasShellOptions { ) } -case class HarnessConfAnnotation(harnessConf: String) extends NoTargetAnnotation with TapeoutOption - -object HarnessConfAnnotation extends HasShellOptions { - val options: Seq[ShellOption[_]] = Seq( - new ShellOption[String]( - longOption = "harness-conf", - shortOption = Some("thconf"), - toAnnotationSeq = (s: String) => Seq(HarnessConfAnnotation(s)), - helpText = "use this to set the harness conf file location" - ) - ) -} - trait TapeoutCli { this: Shell => parser.note("Tapeout specific options") Seq( OutAnnoAnnotation, - HarnessConfAnnotation ).foreach(_.addOptions(parser)) } -class TapeoutStage(doHarness: Boolean) extends Stage { +class TapeoutStage() extends Stage { override val shell: Shell = new Shell(applicationName = "tapeout") with TapeoutCli with ChiselCli with FirrtlCli override def run(annotations: AnnotationSeq): AnnotationSeq = { Logger.makeScope(annotations) { - val generator = new GenerateTopAndHarness(annotations) - - if (doHarness) { - generator.executeTopAndHarness() - } else { - generator.executeTop() - } + val stageMain = new GenerateModelStageMain(annotations) + stageMain.executeStageMain() } annotations } From 06db6059022c55df8e6943702653798c43ead3d8 Mon Sep 17 00:00:00 2001 From: joey0320 Date: Wed, 28 Dec 2022 23:55:10 -0800 Subject: [PATCH 11/11] Fixes test for CI --- .../barstools/tapeout/transforms/GenerateModelStageMain.scala | 2 +- .../scala/barstools/tapeout/transforms/stage/TapeoutStage.scala | 2 +- src/test/scala/barstools/tapeout/transforms/GenerateSpec.scala | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/scala/barstools/tapeout/transforms/GenerateModelStageMain.scala b/src/main/scala/barstools/tapeout/transforms/GenerateModelStageMain.scala index 2de98408..c48d4c35 100644 --- a/src/main/scala/barstools/tapeout/transforms/GenerateModelStageMain.scala +++ b/src/main/scala/barstools/tapeout/transforms/GenerateModelStageMain.scala @@ -11,7 +11,7 @@ import firrtl.transforms.BlackBoxResourceFileNameAnno import logger.LazyLogging private class GenerateModelStageMain(annotations: AnnotationSeq) extends LazyLogging { - val outAnno: Option[String] = annotations.collectFirst { case OutAnnoAnnotation(s) => s } + val outAnno: Option[String] = annotations.collectFirst { case OutAnnoAnnotation(s) => s } val annoFiles: List[String] = annotations.flatMap { case InputAnnotationFileAnnotation(f) => Some(f) diff --git a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala index bff297b1..7ab59717 100644 --- a/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala +++ b/src/main/scala/barstools/tapeout/transforms/stage/TapeoutStage.scala @@ -32,7 +32,7 @@ trait TapeoutCli { parser.note("Tapeout specific options") Seq( - OutAnnoAnnotation, + OutAnnoAnnotation ).foreach(_.addOptions(parser)) } diff --git a/src/test/scala/barstools/tapeout/transforms/GenerateSpec.scala b/src/test/scala/barstools/tapeout/transforms/GenerateSpec.scala index a4dcd780..bb089de9 100644 --- a/src/test/scala/barstools/tapeout/transforms/GenerateSpec.scala +++ b/src/test/scala/barstools/tapeout/transforms/GenerateSpec.scala @@ -91,7 +91,7 @@ class GenerateSpec extends AnyFreeSpec { val targetDir = "test_run_dir/generate_spec" generateTestData(targetDir) - GenerateTop.main( + GenerateModelStageMain.main( Array( "-i", s"$targetDir/GenerateExampleTester.fir",