diff --git a/include/Analysis/Passes.td b/include/Analysis/Passes.td index c704cbf..f143e89 100644 --- a/include/Analysis/Passes.td +++ b/include/Analysis/Passes.td @@ -10,9 +10,10 @@ include "mlir/Pass/PassBase.td" def QoREstimation : Pass<"qor-estimation", "ModuleOp"> { let summary = "Estimate the performance and resource utilization"; let description = [{ - This qor-estimation pass will analyze the input CDFG and pragma operations - (if applied) for estimating performance and resource utilization of the HLS - results. + This qor-estimation pass will analyze the input IR and estimate the latency + and resource utilization of HLS C++ synthesis. This pass will take all + dependency and resource constraints and pragma settings into consideration, + and conduct the estimation through an ALAP scheduling. }]; let constructor = "mlir::scalehls::createQoREstimationPass()"; diff --git a/include/Conversion/Passes.td b/include/Conversion/Passes.td index 94e0d6b..964c196 100644 --- a/include/Conversion/Passes.td +++ b/include/Conversion/Passes.td @@ -14,8 +14,9 @@ include "mlir/Pass/PassBase.td" def LegalizeToHLSCpp : Pass<"legalize-to-hlscpp", "FuncOp"> { let summary = "Convert to emittable MLIR code"; let description = [{ - This legalize-to-hlscpp converts MLIR code in Affine/Standard/SCF level to - emittable and estimatable MLIR code. + This legalize-to-hlscpp pass will legalize the input IR to make it + emittable. Meanwhile, this pass will set some default pragmas for the + convenience of the subsequent transforms and analysis. }]; let constructor = "mlir::scalehls::createLegalizeToHLSCppPass()"; @@ -29,8 +30,8 @@ def LegalizeToHLSCpp : Pass<"legalize-to-hlscpp", "FuncOp"> { def HLSKernelToAffine : Pass<"hlskernel-to-affine", "FuncOp"> { let summary = "Convert HLSKernel operation to Affine loops"; let description = [{ - This hlskernel-to-affine converts HLSKernel operations to their Affine level - representations. + This hlskernel-to-affine pass converts HLSKernel operations to their Affine + level representations. }]; let constructor = "mlir::scalehls::createHLSKernelToAffinePass()"; diff --git a/include/Dialect/HLSCpp/HLSCpp.td b/include/Dialect/HLSCpp/HLSCpp.td index c9eabb6..17db397 100644 --- a/include/Dialect/HLSCpp/HLSCpp.td +++ b/include/Dialect/HLSCpp/HLSCpp.td @@ -11,11 +11,11 @@ def HLSCppDialect : Dialect { let name = "hlscpp"; let summary = "An HLSCpp out-of-tree MLIR dialect"; let description = [{ - This dialect contains dedicated operations, interfaces, and passes designed + This dialect contains dedicated operations, attributes, and passes designed for representing HLS C++ specific structures and components in MLIR, while enabling comprehensive optimization for both performance and area. Passes - in this dialect can optimize and generate IRs, which can be translated to - synthesizable HLS C++ code by EmitHLSCpp tool. + in this dialect can optimize and generate IRs, which can then be translated + to synthesizable HLS C++ code by scalehls-translate tool. }]; let cppNamespace = "::mlir::scalehls::hlscpp"; } diff --git a/include/Dialect/HLSCpp/StructureOps.td b/include/Dialect/HLSCpp/StructureOps.td index d6e65c0..fda7a47 100644 --- a/include/Dialect/HLSCpp/StructureOps.td +++ b/include/Dialect/HLSCpp/StructureOps.td @@ -6,12 +6,12 @@ #define SCALEHLS_DIALECT_HLSCPP_STRUCTUREOPS_TD def AssignOp : HLSCppOp<"assign", [SameOperandsAndResultType]> { - let summary = "Assign input value to the output"; + let summary = "Assign the input value to the output"; let description = [{ This hlscpp.assign operation assigns the input value to the output, and can be inserted anywhere without changing the original semantic. This is useful - for EmitHLSCpp to handle some weird corner cases (e.g. the operand of return - operation is function argument, and etc). + for EmitHLSCpp to handle some weird corner cases (e.g., the operand of + return operation is function argument, etc.). }]; let arguments = (ins AnyType : $input); diff --git a/include/Transforms/Passes.td b/include/Transforms/Passes.td index 1003747..a75383a 100644 --- a/include/Transforms/Passes.td +++ b/include/Transforms/Passes.td @@ -12,11 +12,11 @@ include "mlir/Pass/PassBase.td" //===----------------------------------------------------------------------===// def ArrayPartition : Pass<"array-partition", "FuncOp"> { - let summary = "Apply optimized array partition optimization"; + let summary = "Apply optimized array partition strategy"; let description = [{ This array-partition pass will automatically search for the best array - partition solution of each on-chip memory instance and insert array - partition pragmas. + partition solution for each on-chip memory instance and apply the solution + through changing the layout AffineMap of the corresponding MemRefType. }]; let constructor = "mlir::scalehls::createArrayPartitionPass()"; @@ -25,8 +25,8 @@ def ArrayPartition : Pass<"array-partition", "FuncOp"> { def LoopPipelining : Pass<"loop-pipelining", "FuncOp"> { let summary = "Apply loop pipelining"; let description = [{ - This loop-pipelining pass will insert pipeline pragma to the innermost n-th - loop level, and automatically unroll all inner loops. + This loop-pipelining pass will insert pipeline pragma to the target loop + level, and automatically unroll all inner loops. }]; let constructor = "mlir::scalehls::createLoopPipeliningPass()"; @@ -38,13 +38,13 @@ def LoopPipelining : Pass<"loop-pipelining", "FuncOp"> { } def PragmaDSE : Pass<"pragma-dse", "ModuleOp"> { - let summary = "Optimize pragma configuration of each optimizable region"; + let summary = "Optimize pragma configurations"; let description = [{ This pragma-dse pass will automatically tune HLS pragma insertion and configuration for performance and area optimization. By calling methods - provided by hlscpp-qor-estimation, this pass is able to rapidly obtain the - QoR estimation of the current design point, and feed it back to the design - space exploration engine for an efficient convergence. + provided by qor-estimation, this pass is able to rapidly obtain the QoR + estimation of the current design point, and feed it back to the design space + exploration engine for an efficient convergence. }]; let constructor = "mlir::scalehls::createPragmaDSEPass()"; @@ -59,8 +59,8 @@ def AffineLoopPerfection : Pass<"affine-loop-perfection", "FuncOp"> { let description = [{ This affine-loop-perfection pass will try to perfect all affine loops. Specifically, this pass will move operations under non-innermost loops into - innermost loop and create affine if regions to ensure the correctness of the - movement. + innermost loop and create AffineIf regions to ensure the correctness of the + transformation. }]; let constructor = "mlir::scalehls::createAffineLoopPerfectionPass()"; @@ -69,9 +69,9 @@ def AffineLoopPerfection : Pass<"affine-loop-perfection", "FuncOp"> { def PartialAffineLoopTile : Pass<"partial-affine-loop-tile", "FuncOp"> { let summary = "Partially tile affine nested loops"; let description = [{ - This partial-affine-loop-tile pass will try to tile the nested loops. The - difference with the official affine-loop-tile pass is this pass will only - tile the first "tileLevel" outermost loop levels rather than all loops + This partial-affine-loop-tile pass will try to tile all affine nested loops. + The difference with the official affine-loop-tile pass is this pass will + only tile the first "tileLevel" outermost loop levels rather than all loops levels. }]; @@ -89,9 +89,9 @@ def RemoveVariableBound : Pass<"remove-variable-bound", "FuncOp"> { let summary = "Try to remove variable loop bounds"; let description = [{ This remove-variable-bound pass will try to remove the variable loop bounds. - Specifically, this is only possible when the variable loop bound is an - affine expression of induction variables of other loops with constant lower - or upper bound. + Specifically, this is only feasible when the loop bound is an affine + expression of induction variables of other loops with constant lower and + upper bound. }]; let constructor = "mlir::scalehls::createRemoveVariableBoundPass()"; @@ -101,35 +101,35 @@ def RemoveVariableBound : Pass<"remove-variable-bound", "FuncOp"> { // Dataflow Optimization Passes //===----------------------------------------------------------------------===// -def SplitFunction : Pass<"split-function", "ModuleOp"> { - let summary = "Split function for enabling dataflow"; - let description = [{ - This split-function pass should be applied in HLSKernel level. This pass - will split each HLSKernel operation into a separate function for applying - dataflow pragma to the top function. - }]; - - let constructor = "mlir::scalehls::createSplitFunctionPass()"; -} - def LegalizeDataflow : Pass<"legalize-dataflow", "FuncOp"> { - let summary = "Legalize code for the dataflow pragma"; + let summary = "Legalize the dataflow scheduling"; let description = [{ - This legalize-dataflow pass will legalize the dataflow by inserting some - dummy nodes and grouping nodes in the same level to meet the requirements of - the dataflow pragma: 1) single-producer single-consumer 2) no bypass. + This legalize-dataflow pass will legalize the dataflow scheduling to meet + the requirements of the dataflow pragma: 1) single-producer single-consumer; + 2) no bypass paths. }]; let constructor = "mlir::scalehls::createLegalizeDataflowPass()"; let options = [ Option<"insertCopy", "insert-copy", "bool", /*default=*/"true", - "Whether insert copy to break bypass paths">, + "Whether insert copy operations to break bypass paths">, Option<"minGran", "min-gran", "unsigned", /*default=*/"1", "Positive number: the minimum granularity of dataflow"> ]; } +def SplitFunction : Pass<"split-function", "ModuleOp"> { + let summary = "Split function for enabling the dataflow pragma"; + let description = [{ + This split-function pass will split operations/loops scheduled at the same + dataflow level into a separate sub-function for applying the dataflow pragma + to the top function. + }]; + + let constructor = "mlir::scalehls::createSplitFunctionPass()"; +} + //===----------------------------------------------------------------------===// // Bufferization Passes //===----------------------------------------------------------------------===// @@ -150,8 +150,8 @@ def HLSKernelBufferize : Pass<"hlskernel-bufferize", "FuncOp"> { def AffineStoreForward : Pass<"affine-store-forward", "FuncOp"> { let summary = "Forward store to load, including conditional stores"; let description = [{ - This affine-store-forward pass is similar to memref-dataflow-opt, but support to - forward stores in if statements. + This affine-store-forward pass is similar to memref-dataflow-opt, but + supports to forward stores located in AffineIf regions. }]; let constructor = "mlir::scalehls::createAffineStoreForwardPass()";