Struct support

include/scalehls-c/Dialect/HLS/HLS.h

@@ -28,6 +28,10 @@ mlirSemanticsInitializeBlockArguments(MlirOperation semantics,
 // HLS Dialect Types
 //===----------------------------------------------------------------------===//
 
+MLIR_CAPI_EXPORTED bool mlirTypeIsHLSStructType(MlirType type);
+MLIR_CAPI_EXPORTED MlirType mlirHLSStructTypeGet(MlirStringRef name,
+                                                 MlirContext ctx);
+
 MLIR_CAPI_EXPORTED bool mlirTypeIsHLSTypeType(MlirType type);
 MLIR_CAPI_EXPORTED MlirType mlirHLSTypeTypeGet(MlirContext ctx);
 

include/scalehls/Dialect/HLS/IR/HLS.h

@@ -11,6 +11,7 @@
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
@@ -38,6 +39,37 @@ struct Push : public MemoryEffects::Effect::Base<Push> {};
 struct Pop : public MemoryEffects::Effect::Base<Pop> {};
 } // namespace StreamEffects
 
+/// Printer hook for custom directive in assemblyFormat.
+///
+///   custom<DynamicTemplateList>($templates, $staticTemplates)
+///
+/// where `template` is of ODS type `Variadic<AnyType>` and `staticTemplates`
+/// is of ODS type `ArrayAttr`. Prints a list with either (1) the static
+/// attribute value in `staticTemplates` is `dynVal` or (2) the next value
+/// otherwise. This allows idiomatic printing of mixed value and attributes in a
+/// list. E.g. `<%arg0, 7, f32, %arg42>`.
+void printDynamicTemplateList(OpAsmPrinter &printer, Operation *op,
+                              OperandRange templates,
+                              ArrayAttr staticTemplates);
+
+/// Pasrer hook for custom directive in assemblyFormat.
+///
+///   custom<DynamicTemplateList>($templates, $staticTemplates)
+///
+/// where `templates` is of ODS type `Variadic<AnyType>` and `staticTemplates`
+/// is of ODS type `ArrayAttr`. Parse a mixed list with either (1) static
+/// templates or (2) SSA templates. Fill `staticTemplates` with the ArrayAttr,
+/// where `dynVal` encodes the position of SSA templates. Add the parsed SSA
+/// templates to `templates` in-order.
+//
+/// E.g. after parsing "<%arg0, 7, f32, %arg42>":
+///   1. `result` is filled with the ArrayAttr "[`dynVal`, 7, f32, `dynVal`]"
+///   2. `ssa` is filled with "[%arg0, %arg42]".
+ParseResult parseDynamicTemplateList(
+    OpAsmParser &parser,
+    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &templates,
+    ArrayAttr &staticTemplates);
+
 } // namespace hls
 } // namespace scalehls
 } // namespace mlir

include/scalehls/Dialect/HLS/IR/HLSAttributes.td

@@ -15,6 +15,10 @@ include "mlir/IR/EnumAttr.td"
 class HLSAttr<string name, list<Trait> traits = []> :
     AttrDef<HLSDialect, name, traits>;
 
+def IndexArrayAttr : TypedArrayAttrBase<IndexAttr, "index array attribute"> {
+  let constBuilderCall = "$_builder.getIndexArrayAttr($0)";
+}
+
 //===----------------------------------------------------------------------===//
 // DSE Attributes
 //===----------------------------------------------------------------------===//
@@ -45,7 +49,7 @@ def TaskImplAttr : HLSAttr<"TaskImpl"> {
   let parameters = (ins IPLibraryParam:$library, IPNameParam:$name);
 
   let mnemonic = "impl";
-  let assemblyFormat = "`<` $library `_` $name `>`";
+  let assemblyFormat = "`<` $library `:` $name `>`";
 
   let extraClassDeclaration = [{
     bool isDefaultImpl() {

include/scalehls/Dialect/HLS/IR/HLSInterfaces.td

@@ -9,6 +9,25 @@
 
 include "mlir/IR/OpBase.td"
 
+def TemplatedOpInterface : OpInterface<"TemplatedOpInterface"> {
+  let methods = [
+    InterfaceMethod<"Return the composed templates",
+      "mlir::SmallVector<OpFoldResult>", "getComposedTemplates", (ins), [{
+        SmallVector<OpFoldResult> composedTemplates;
+        unsigned dynIdx = 0;
+        for (auto attr : $_op.getStaticTemplates()) {
+          if (auto intAttr = attr.template dyn_cast<IntegerAttr>())
+            if (intAttr.getInt() == ShapedType::kDynamic) {
+              composedTemplates.push_back($_op.getTemplates()[dynIdx++]);
+              continue;
+            }
+          composedTemplates.push_back(attr);
+        }
+        return composedTemplates;
+      }]>
+  ];
+}
+
 def ParamLikeInterface : OpInterface<"ParamLikeInterface"> {
   let methods = [
     InterfaceMethod<"Return the value of the parameter if it exists",

include/scalehls/Dialect/HLS/IR/HLSTypes.td

@@ -12,11 +12,40 @@ include "scalehls/Dialect/HLS/IR/HLSAttributes.td"
 class HLSType<string name, list<Trait> traits = []> :
     TypeDef<HLSDialect, name, traits>;
 
+def StreamType : HLSType<"Stream"> {
+  let summary = "An HLS stream type";
+  let description = [{
+    Represents a stream of any type that can be transfered between HLS modules.
+    This type is equal to the hls::stream<> type in Xilinx Vivado HLS.
+  }];
+  let mnemonic = "stream";
+
+  let parameters = (ins "mlir::Type":$elementType, "unsigned":$depth);
+  let assemblyFormat = "`<` qualified($elementType) `,` $depth `>`";
+
+  let extraClassDeclaration = [{
+    static StreamType get(mlir::Type elementType, unsigned depth) {
+      return get(elementType.getContext(), elementType, depth);
+    }
+    static StreamType get(mlir::Type elementType) {
+      return get(elementType, 1);
+    }
+  }];
+}
+
 def SpaceType : HLSType<"Space"> {
   let summary = "Represent a design space containing multiple parameters";
   let mnemonic = "space";
 }
 
+def StructType : HLSType<"Struct"> {
+  let summary = "Represent a struct type";
+  let mnemonic = "struct";
+
+  let parameters = (ins StringRefParameter<>:$name);
+  let assemblyFormat = "`<` $name `>`";
+}
+
 def TypeType : HLSType<"Type"> {
   let summary = "Used to represent a type";
   let mnemonic = "type";
@@ -37,16 +66,4 @@ def MemoryKindType : HLSType<"MemoryKind"> {
   let mnemonic = "memory";
 }
 
-def StreamType : HLSType<"Stream"> {
-  let summary = "An HLS stream type";
-  let description = [{
-    Represents a stream of any type that can be transfered between HLS modules.
-    This type is equal to the hls::stream<> type in Xilinx Vivado HLS.
-  }];
-  let mnemonic = "stream";
-
-  let parameters = (ins "mlir::Type":$elementType, "unsigned":$depth);
-  let assemblyFormat = "`<` qualified($elementType) `,` $depth `>`";
-}
-
 #endif // SCALEHLS_DIALECT_HLS_HLSTYPES_TD

include/scalehls/Dialect/HLS/IR/HLSUBUFOps.td

@@ -11,6 +11,36 @@
 // Unified Buffer (UBUF) Operations
 //===----------------------------------------------------------------------===//
 
+def TensorToStreamOp : HLSOp<"ubuf.tensor_to_stream",[
+      AttrSizedOperandSegments, NoMemoryEffect]> {
+  let summary = "Convert a tensor to a stream channel";
+
+  let arguments = (ins AnyTensor:$tensor, Variadic<Index>:$dims,
+      Variadic<Index>:$symbols, MemRefLayoutAttrInterface:$stream_layout,
+      MemRefLayoutAttrInterface:$memory_layout);
+  let results = (outs StreamOf<[AnyType]>:$stream);
+  let assemblyFormat = [{
+    $tensor (`[` $dims^ `]`)? (`(` $symbols^ `)`)? `stream_layout`
+    $stream_layout `memory_layout` $memory_layout attr-dict `:`
+    functional-type($tensor, $stream)
+  }];
+}
+
+def StreamToTensorOp : HLSOp<"ubuf.stream_to_tensor", [
+      AttrSizedOperandSegments, NoMemoryEffect]> {
+  let summary = "Convert a stream channel to a tensor";
+
+  let arguments = (ins StreamOf<[AnyType]>:$stream, Variadic<Index>:$dims,
+      Variadic<Index>:$symbols, MemRefLayoutAttrInterface:$stream_layout,
+      MemRefLayoutAttrInterface:$memory_layout);
+  let results = (outs AnyTensor:$tensor);
+  let assemblyFormat = [{
+    $stream (`[` $dims^ `]`)? (`(` $symbols^ `)`)? `stream_layout`
+    $stream_layout `memory_layout` $memory_layout attr-dict `:`
+    functional-type($stream, $tensor)
+  }];
+}
+
 def BufferOp : HLSOp<"ubuf.buffer", [
       DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
       DeclareOpInterfaceMethods<BufferLikeInterface>]> {

include/scalehls/Dialect/HLS/IR/HLSUIPOps.td

@@ -39,19 +39,27 @@ def DeclareOp : HLSOp<"uip.declare", [IsolatedFromAbove, SymbolTable, Symbol,
   }];
 }
 
-def InstanceOp : HLSOp<"uip.instance", [
-      DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
+def InstanceOp : HLSOp<"uip.instance", [AttrSizedOperandSegments,
+      DeclareOpInterfaceMethods<SymbolUserOpInterface>,
+      DeclareOpInterfaceMethods<TemplatedOpInterface>]> {
   let summary = "Instantiate an IP declared by DeclareOp";
 
-  let arguments = (ins Variadic<AnyType>:$ports, ArrayAttr:$templates,
-      SymbolRefAttr:$name);
+  let arguments = (ins Variadic<AnyType>:$ports, Variadic<AnyType>:$templates,
+      ArrayAttr:$static_templates, SymbolRefAttr:$name);
   let results = (outs Variadic<AnyType>:$results);
 
   let assemblyFormat = [{
-    $name `<` $templates `>` `(` $ports `)` attr-dict `:`
+    $name custom<DynamicTemplateList>($templates, $static_templates) `(` $ports
+    `)` attr-dict `:` (`<` type($templates)^ `>`)?
     functional-type($ports, $results)
   }];
 
+  let builders = [
+    OpBuilder<(ins "mlir::TypeRange":$results, "mlir::ValueRange":$ports,
+        "mlir::ArrayRef<mlir::OpFoldResult>":$composedTemplates,
+        "mlir::SymbolRefAttr":$name)>
+  ];
+
   let extraClassDeclaration = [{
     /// Get the type of operand: input, output, or param.
     PortKind getPortKind(OpOperand &operand);
@@ -65,17 +73,27 @@ def InstanceOp : HLSOp<"uip.instance", [
   }];
 }
 
-def PortOp : HLSOp<"uip.port", [Symbol, HasParent<"DeclareOp">]> {
+def PortOp : HLSOp<"uip.port", [Symbol, AttrSizedOperandSegments, 
+      HasParent<"DeclareOp">]> {
   let summary = "Declare a port of an IP";
 
-  let arguments = (ins TypeType:$type, Variadic<AnyType>:$sizes,
-      MemRefLayoutAttrInterface:$layout, PortKindAttr:$kind,
+  let arguments = (ins TypeType:$type, Variadic<AnyType>:$dims,
+      Variadic<AnyType>:$symbols, PortKindAttr:$kind,
+      OptionalAttr<MemRefLayoutAttrInterface>:$stream_layout,
+      MemRefLayoutAttrInterface:$memory_layout,
       OptionalAttr<TypedAttrInterface>:$value, SymbolNameAttr:$sym_name);
   let results = (outs PortType:$result);
 
   let assemblyFormat = [{
-    $sym_name $kind `type` $type `sizes` `(` $sizes `)` $layout attr-dict
-    `:` functional-type($sizes, $result)
+    $sym_name $kind `type` $type (`[` $dims^ `]`)? (`(` $symbols^ `)`)?
+    (`stream_layout` $stream_layout^)? `memory_layout` $memory_layout attr-dict
+    `:` (`[` type($dims)^ `]`)? functional-type($symbols, $result)
+  }];
+
+  let extraClassDeclaration = [{
+    bool isStream() {
+      return getStreamLayout().has_value();
+    }
   }];
 }
 
@@ -86,8 +104,40 @@ def IncludeOp : HLSOp<"uip.include", [HasParent<"DeclareOp">]> {
   let assemblyFormat = "$paths attr-dict";
 }
 
-def IndexArrayAttr : TypedArrayAttrBase<IndexAttr, "index array attribute"> {
-  let constBuilderCall = "$_builder.getIndexArrayAttr($0)";
+def StructOp : HLSOp<"uip.struct", [Symbol, AttrSizedOperandSegments,
+      HasParent<"SpaceOp, DeclareOp">]> {
+  let summary = "Declare a struct containing multiple parameters";
+
+  let arguments = (ins Variadic<AnyType>:$params, Variadic<AnyType>:$templates,
+      SymbolNameAttr:$sym_name);
+  let results = (outs StructType:$result);
+
+  let assemblyFormat = [{
+    $sym_name (`<` $templates^ `>`)? `(` $params `)` attr-dict `:`
+    (`<` type($templates)^ `>`)? functional-type($params, $result)
+  }];
+}
+
+def StructInstanceOp : HLSOp<"uip.struct_instance", [AttrSizedOperandSegments,
+      DeclareOpInterfaceMethods<SymbolUserOpInterface>,
+      DeclareOpInterfaceMethods<TemplatedOpInterface>]> {
+  let summary = "Instantiate a struct declared by StructOp";
+
+  let arguments = (ins Variadic<AnyType>:$params, Variadic<AnyType>:$templates,
+      ArrayAttr:$static_templates, SymbolRefAttr:$name);
+  let results = (outs StructType:$result);
+
+  let assemblyFormat = [{
+    $name custom<DynamicTemplateList>($templates, $static_templates) `(` $params
+    `)` attr-dict `:` (`<` type($templates)^ `>`)?
+    functional-type($params, $result)
+  }];
+
+  let builders = [
+    OpBuilder<(ins "mlir::Type":$result, "mlir::ValueRange":$params,
+        "mlir::ArrayRef<mlir::OpFoldResult>":$composedTemplates,
+        "mlir::SymbolRefAttr":$name)>
+  ];
 }
 
 def SemanticsOp : HLSOp<"uip.semantics", [Terminator, IsolatedFromAbove,
@@ -120,6 +170,11 @@ def SemanticsOp : HLSOp<"uip.semantics", [Terminator, IsolatedFromAbove,
 
     PortKind getPortKind(OpOperand &operand);
     PortKind getPortKind(unsigned operandIdx);
+
+    /// The template of an IP could be recursively a struct type. This method
+    /// can recursively peel off all the structs and return the real templates,
+    /// which are gauranteed to be ParamOp.
+    SmallVector<Value> getStructPeeledTemplates();
   }];
 }
 

include/scalehls/Utils/Matchers.h → include/scalehls/Dialect/HLS/Utils/Matchers.h

@@ -4,8 +4,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SCALEHLS_UTILS_MATCHERS_H
-#define SCALEHLS_UTILS_MATCHERS_H
+#ifndef SCALEHLS_DIALECT_HLS_UTILS_MATCHERS_H
+#define SCALEHLS_DIALECT_HLS_UTILS_MATCHERS_H
 
 #include "scalehls/Dialect/HLS/IR/HLS.h"
 #include "scalehls/Utils/Utils.h"
@@ -15,8 +15,7 @@
 
 namespace mlir {
 namespace scalehls {
-
-using namespace hls;
+namespace hls {
 
 //===----------------------------------------------------------------------===//
 // BlockMatcher
@@ -257,7 +256,7 @@ struct Port : OpFoldResult {
 
 struct IPMatchingResult {
   const SmallVector<Port> instPorts;
-  const SmallVector<Attribute> instTemplates;
+  const SmallVector<Attribute> instStructPeeledTemplates;
   const LinalgMatchingResult result;
 
   unsigned mapIpResIndexToPayload(unsigned ipResIndex) const {
@@ -268,9 +267,10 @@ struct IPMatchingResult {
   }
 
   IPMatchingResult(const SmallVector<Port> &instPorts,
-                   const SmallVector<Attribute> &instTemplates,
+                   const SmallVector<Attribute> &instStructPeeledTemplates,
                    const LinalgMatchingResult &result)
-      : instPorts(instPorts), instTemplates(instTemplates), result(result) {}
+      : instPorts(instPorts),
+        instStructPeeledTemplates(instStructPeeledTemplates), result(result) {}
 };
 
 struct IPMatchingStatus {
@@ -369,7 +369,7 @@ struct IPMatcher {
             unsigned maxIterations = 3)
       : payload(payload), declare(declare), maxIterations(maxIterations),
         status(declare.getSemanticsOp().getPorts(),
-               declare.getSemanticsOp().getTemplates()) {}
+               declare.getSemanticsOp().getStructPeeledTemplates()) {}
 
   FailureOr<IPMatchingResult> match();
 
@@ -380,7 +380,8 @@ struct IPMatcher {
   IPMatchingStatus status;
 };
 
+} // namespace hls
 } // namespace scalehls
 } // namespace mlir
 
-#endif // SCALEHLS_UTILS_MATCHERS_H
+#endif // SCALEHLS_DIALECT_HLS_UTILS_MATCHERS_H