Further extract FPGA code generation support (#2265)

- [x] Remove ArrayInterface
- [x] Remove other FPGA-related enumeration entries
- [x] Mitigate extraneous arguments in `dace.codegen.targets.cpp`
- [x] Remove runtime includes and references to DaCe-FPGA macros
- [x] Address TODOs from #2252

Author: tbennun

README.md

@@ -26,7 +26,7 @@ of performance optimization, regardless of the application or the target process
 DaCe generates high-performance programs for:
  * Multi-core CPUs (tested on Intel, IBM POWER9, and ARM with SVE)
  * NVIDIA GPUs and AMD GPUs (with HIP)
- * Xilinx and Intel FPGAs
+ * [Xilinx and Intel FPGAs](https://github.com/spcl/dace-fpga)
 
 DaCe can be written inline in Python and transformed in the command-line/Jupyter
 Notebooks or SDFGs can be interactively modified using our [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=phschaad.sdfv).

dace/codegen/dispatcher.py

@@ -28,8 +28,6 @@ class DefinedType(aenum.AutoNumberEnum):
     Object = ()  # An object moved by reference
     Stream = ()  # A stream object moved by reference and accessed via a push/pop API
     StreamArray = ()  # An array of Streams
-    # TODO Remove ArrayInterface in subsequent PR
-    ArrayInterface = ()  # An object representing an interface to an array, used mostly in FPGA
 
 
 class DefinedMemlets:

dace/codegen/target.py

@@ -238,15 +238,6 @@ def emit_interstate_variable_declaration(self, name: str, dtype: dtypes.typeclas
         """
         raise NotImplementedError('Abstract class')
 
-    def adjust_subset_for_codegen(self, nodedesc: dt.Data, subset: subsets.Subset) -> subsets.Subset:
-        """ Adjusts a memlet subset for code generation, if necessary.
-
-            :param subset: The original subset.
-            :param nodedesc: The data descriptor the subset applies to.
-            :return: The adjusted subset.
-        """
-        return subset
-
 
 class IllegalCopy(TargetCodeGenerator):
     """ A code generator that is triggered when invalid copies are specified

dace/codegen/targets/cpp.py

@@ -114,7 +114,7 @@ def copy_expr(
 
     add_offset = offset_cppstr != "0"
 
-    if def_type in [DefinedType.Pointer, DefinedType.ArrayInterface, DefinedType.Object]:
+    if def_type in [DefinedType.Pointer, DefinedType.Object]:
         return "{}{}{}".format(dt, expr, " + {}".format(offset_cppstr) if add_offset else "")
     elif def_type == DefinedType.StreamArray:
         return "{}[{}]".format(expr, offset_cppstr)
@@ -137,8 +137,7 @@ def memlet_copy_to_absolute_strides(dispatcher: 'TargetDispatcher',
                                     src_node: nodes.AccessNode,
                                     dst_node: nodes.AccessNode,
                                     src_name_override: Optional[str] = None,
-                                    dst_name_override: Optional[str] = None,
-                                    codegen: 'TargetCodeGenerator' = None):
+                                    dst_name_override: Optional[str] = None):
     memlet = edge.data
     copy_shape = memlet.subset.size_exact()
     src_nodedesc = src_node.desc(sdfg)
@@ -150,10 +149,6 @@ def memlet_copy_to_absolute_strides(dispatcher: 'TargetDispatcher',
     dst_subset = memlet.get_dst_subset(edge, state)
     is_src_write = not memlet._is_data_src
 
-    if codegen is not None:
-        src_subset = codegen.adjust_subset_for_codegen(src_nodedesc, src_subset)
-        dst_subset = codegen.adjust_subset_for_codegen(dst_nodedesc, dst_subset)
-
     if dispatcher is not None:
         src_expr = copy_expr(dispatcher,
                              sdfg,
@@ -288,7 +283,7 @@ def emit_memlet_reference(dispatcher: 'TargetDispatcher',
     """
     desc = sdfg.arrays[memlet.data]
     typedef = conntype.ctype
-    offset = cpp_offset_expr(desc, memlet.subset, codegen=codegen)
+    offset = cpp_offset_expr(desc, memlet.subset)
     offset_expr = '[' + offset + ']'
     is_scalar = not isinstance(conntype, dtypes.pointer)
     ptrname = codegen.ptr(memlet.data, desc, sdfg, subset=memlet.subset, ancestor=ancestor, is_write=is_write)
@@ -317,8 +312,7 @@ def make_const(expr: str) -> str:
         else:
             return expr
 
-    if (defined_type == DefinedType.Pointer
-            or (defined_type == DefinedType.ArrayInterface and isinstance(desc, data.View))):
+    if defined_type == DefinedType.Pointer:
         if not is_scalar and desc.dtype == conntype.base_type:
             # Cast potential consts
             typedef = defined_ctype
@@ -333,11 +327,6 @@ def make_const(expr: str) -> str:
             if memlet.data in dispatcher.frame.symbols_and_constants(sdfg):
                 ref = '*'
                 typedef = make_const(typedef)
-
-    elif defined_type == DefinedType.ArrayInterface:
-        base_ctype = conntype.base_type.ctype
-        typedef = f"{base_ctype}*" if is_write else f"const {base_ctype}*"
-        is_scalar = False
     elif defined_type == DefinedType.Scalar:
         typedef = defined_ctype if is_scalar else (defined_ctype + '*')
         if is_write is False and not isinstance(desc, data.Structure):
@@ -481,45 +470,22 @@ def ndcopy_to_strided_copy(
         if copy_shape == src_copy_shape:
             srcdim = copydim
         else:
-            # TODO: Remove try-except in subsequent FPGA PR
-            try:
-                srcdim = next(i for i, c in enumerate(src_copy_shape) if c != 1)
-            except StopIteration:
-                # NOTE: This is the old stride computation code for FPGA
-                # compatibility
-                if len(copy_shape) == len(src_shape):
-                    srcdim = copydim
-                else:
-                    srcdim = next(i for i, c in enumerate(src_shape) if c != 1)
+            srcdim = next(i for i, c in enumerate(src_copy_shape) if c != 1)
 
         # In destination strides
         dst_copy_shape = dst_subset.size_exact()
         if copy_shape == dst_copy_shape:
             dstdim = copydim
         else:
-            # TODO: Remove try-except in subsequent FPGA PR
-            try:
-                dstdim = next(i for i, c in enumerate(dst_copy_shape) if c != 1)
-            except StopIteration:
-                # NOTE: This is the old stride computation code for FPGA
-                # compatibility
-                if len(copy_shape) == len(dst_shape):
-                    dstdim = copydim
-                else:
-                    dstdim = next(i for i, c in enumerate(dst_shape) if c != 1)
+            dstdim = next(i for i, c in enumerate(dst_copy_shape) if c != 1)
 
         # Return new copy
         return [copy_shape[copydim]], [src_strides[srcdim]], [dst_strides[dstdim]]
     else:
         return None
 
 
-def cpp_offset_expr(d: data.Data,
-                    subset_in: subsets.Subset,
-                    offset=None,
-                    packed_veclen=1,
-                    indices=None,
-                    codegen: Optional['TargetCodeGenerator'] = None) -> str:
+def cpp_offset_expr(d: data.Data, subset_in: subsets.Subset, offset=None, packed_veclen=1, indices=None) -> str:
     """ Creates a C++ expression that can be added to a pointer in order
         to offset it to the beginning of the given subset and offset.
 
@@ -533,10 +499,6 @@ def cpp_offset_expr(d: data.Data,
         :param codegen: Optional code generator to adjust subset.
         :return: A string in C++ syntax with the correct offset
     """
-    # Offset according to code generator
-    if codegen is not None:
-        subset_in = codegen.adjust_subset_for_codegen(d, subset_in)
-
     # Offset according to parameters, then offset according to array
     if offset is not None:
         subset = subset_in.offset_new(offset, False)
@@ -570,7 +532,7 @@ def cpp_array_expr(sdfg,
     s = subset if relative_offset else subsets.Indices(offset)
     o = offset if relative_offset else None
     desc = (sdfg.arrays[memlet.data] if referenced_array is None else referenced_array)
-    offset_cppstr = cpp_offset_expr(desc, s, o, packed_veclen, indices=indices, codegen=codegen)
+    offset_cppstr = cpp_offset_expr(desc, s, o, packed_veclen, indices=indices)
 
     # NOTE: Are there any cases where a mix of '.' and '->' is needed when traversing nested structs?
     # TODO: Study this when changing Structures to be (optionally?) non-pointers.
@@ -599,7 +561,7 @@ def make_ptr_vector_cast(dst_expr, dst_dtype, src_dtype, is_scalar, defined_type
             dst_expr = '*(%s *)(&%s)' % (src_dtype.ctype, dst_expr)
         elif src_dtype.base_type != dst_dtype:
             dst_expr = '(%s)(&%s)' % (src_dtype.ctype, dst_expr)
-        elif defined_type in [DefinedType.Pointer, DefinedType.ArrayInterface]:
+        elif defined_type == DefinedType.Pointer:
             dst_expr = '&' + dst_expr
     elif not is_scalar:
         dst_expr = '&' + dst_expr
@@ -613,9 +575,7 @@ def cpp_ptr_expr(sdfg,
                  relative_offset=True,
                  use_other_subset=False,
                  indices=None,
-                 is_write=None,
-                 codegen: 'TargetCodeGenerator' = None,
-                 decouple_array_interface=False):
+                 codegen: 'TargetCodeGenerator' = None):
     """ Converts a memlet to a C++ pointer expression. """
     subset = memlet.subset if not use_other_subset else memlet.other_subset
     s = subset if relative_offset else subsets.Indices(offset)
@@ -624,7 +584,7 @@ def cpp_ptr_expr(sdfg,
     if isinstance(indices, str):
         offset_cppstr = indices
     else:
-        offset_cppstr = cpp_offset_expr(desc, s, o, indices=indices, codegen=codegen)
+        offset_cppstr = cpp_offset_expr(desc, s, o, indices=indices)
     dname = codegen.ptr(memlet.data, desc, sdfg, memlet.subset)
 
     if defined_type == DefinedType.Scalar:
@@ -1176,7 +1136,7 @@ def visit_Assign(self, node):
                         return node
                     elif isinstance(desc, data.Stream):
                         if desc.is_stream_array():
-                            index = cpp_offset_expr(desc, memlet.subset, codegen=self.codegen)
+                            index = cpp_offset_expr(desc, memlet.subset)
                             target = f"{ptrname}[{index}]"
                         else:
                             target = ptrname
@@ -1191,7 +1151,7 @@ def visit_Assign(self, node):
                                 ptrname,
                                 cppunparse.cppunparse(value, expr_semicolon=False),
                             ))
-                        elif (var_type != DefinedType.ArrayInterface or isinstance(desc, data.View)):
+                        elif isinstance(desc, data.View):
                             newnode = ast.Name(id="%s = %s;" % (
                                 cpp_array_expr(self.sdfg, memlet, codegen=self.codegen),
                                 cppunparse.cppunparse(value, expr_semicolon=False),

dace/codegen/targets/cpu.py

@@ -196,8 +196,7 @@ def allocate_view(self,
         # Check directionality of view (referencing dst or src)
         edge = sdutils.get_view_edge(dfg, node)
 
-        # When emitting ArrayInterface, we need to know if this is a read or
-        # write variation
+        # We need to know if this is a read or a write variation
         is_write = edge.src is node
 
         # Allocate the viewed data before the view, if necessary
@@ -237,12 +236,12 @@ def allocate_view(self,
 
             # Plain view into a container array
             if isinstance(vdesc, data.ContainerArray) and not isinstance(vdesc.stype, data.Structure):
-                offset = cpp.cpp_offset_expr(vdesc, memlet.subset, codegen=self)
+                offset = cpp.cpp_offset_expr(vdesc, memlet.subset)
                 value = f'{ptrname}[{offset}]'
             else:
                 if field_name is not None:
                     if isinstance(vdesc, data.ContainerArray):
-                        offset = cpp.cpp_offset_expr(vdesc, memlet.subset, codegen=self)
+                        offset = cpp.cpp_offset_expr(vdesc, memlet.subset)
                         arrexpr = f'{ptrname}[{offset}]'
                         stype = vdesc.stype
                     else:
@@ -746,8 +745,8 @@ def _emit_copy(
                     if memlet.data != src_node.data and memlet.other_subset:
                         stream_subset = memlet.other_subset
 
-                    stream_expr = cpp.cpp_offset_expr(src_nodedesc, stream_subset, codegen=self)
-                    array_expr = cpp.cpp_offset_expr(dst_nodedesc, array_subset, codegen=self)
+                    stream_expr = cpp.cpp_offset_expr(src_nodedesc, stream_subset)
+                    array_expr = cpp.cpp_offset_expr(dst_nodedesc, array_subset)
                     assert functools.reduce(lambda a, b: a * b, src_nodedesc.shape, 1) == 1
                     stream.write(
                         "{s}.pop(&{arr}[{aexpr}], {maxsize});".format(s=self.ptr(src_node.data, src_nodedesc, sdfg),
@@ -798,7 +797,7 @@ def _emit_copy(
             state_dfg: SDFGState = cfg.nodes()[state_id]
 
             copy_shape, src_strides, dst_strides, src_expr, dst_expr = cpp.memlet_copy_to_absolute_strides(
-                self._dispatcher, sdfg, state_dfg, edge, src_node, dst_node, codegen=self)
+                self._dispatcher, sdfg, state_dfg, edge, src_node, dst_node)
 
             # Which numbers to include in the variable argument part
             dynshape, dynsrc, dyndst = 1, 1, 1
@@ -1140,7 +1139,7 @@ def memlet_view_ctor(self, sdfg: SDFG, memlet: mmlt.Memlet, dtype, is_output: bo
             if isinstance(memlet.subset, subsets.Range):
 
                 dims = len(memlet.subset.ranges)
-                offset = cpp.cpp_offset_expr(sdfg.arrays[memlet.data], memlet.subset, codegen=self)
+                offset = cpp.cpp_offset_expr(sdfg.arrays[memlet.data], memlet.subset)
                 if offset == "0":
                     memlet_params.append(memlet_expr)
                 else:
@@ -1240,7 +1239,7 @@ def memlet_definition(self,
 
         result = ''
         expr = (cpp.cpp_array_expr(sdfg, memlet, with_brackets=False, codegen=self)
-                if var_type in [DefinedType.Pointer, DefinedType.StreamArray, DefinedType.ArrayInterface] else ptr)
+                if var_type in (DefinedType.Pointer, DefinedType.StreamArray) else ptr)
 
         if expr != ptr:
             expr = '%s[%s]' % (ptr, expr)
@@ -1249,11 +1248,9 @@ def memlet_definition(self,
 
         defined = None
 
-        if var_type in [DefinedType.Scalar, DefinedType.Pointer, DefinedType.ArrayInterface]:
+        if var_type in (DefinedType.Scalar, DefinedType.Pointer):
             if output:
-                if is_pointer and var_type == DefinedType.ArrayInterface:
-                    result += "{} {} = {};".format(memlet_type, local_name, expr)
-                elif not memlet.dynamic or (memlet.dynamic and memlet.wcr is not None):
+                if not memlet.dynamic or (memlet.dynamic and memlet.wcr is not None):
                     # Dynamic WCR memlets start uninitialized
                     result += "{} {};".format(memlet_type, local_name)
                     defined = DefinedType.Scalar
@@ -1283,7 +1280,7 @@ def memlet_definition(self,
             if not memlet.dynamic and memlet.num_accesses == 1:
                 if not output:
                     if isinstance(desc, data.Stream) and desc.is_stream_array():
-                        index = cpp.cpp_offset_expr(desc, memlet.subset, codegen=codegen)
+                        index = cpp.cpp_offset_expr(desc, memlet.subset)
                         expr = f"{memlet.data}[{index}]"
                     result += f'{memlet_type} {local_name} = ({expr}).pop();'
                     defined = DefinedType.Scalar
@@ -1302,7 +1299,7 @@ def memlet_definition(self,
 
     def memlet_stream_ctor(self, sdfg: SDFG, memlet: mmlt.Memlet) -> str:
         stream = sdfg.arrays[memlet.data]
-        return memlet.data + ("[{}]".format(cpp.cpp_offset_expr(stream, memlet.subset, codegen=self))
+        return memlet.data + ("[{}]".format(cpp.cpp_offset_expr(stream, memlet.subset))
                               if isinstance(stream, data.Stream) and stream.is_stream_array() else "")
 
     def memlet_ctor(self, sdfg: SDFG, memlet: mmlt.Memlet, dtype, is_output: bool) -> str:

dace/codegen/targets/cuda.py

@@ -183,13 +183,8 @@ def preprocess(self, sdfg: SDFG) -> None:
                     # NOTE: If possible `memlet_copy_to_absolute_strides()` will collapse a
                     #   ND copy into a 1D copy if the memory is contiguous. In that case
                     #   `copy_shape` will only have one element.
-                    copy_shape, src_strides, dst_strides, _, _ = memlet_copy_to_absolute_strides(None,
-                                                                                                 nsdfg,
-                                                                                                 state,
-                                                                                                 e,
-                                                                                                 e.src,
-                                                                                                 e.dst,
-                                                                                                 codegen=self)
+                    copy_shape, src_strides, dst_strides, _, _ = memlet_copy_to_absolute_strides(
+                        None, nsdfg, state, e, e.src, e.dst)
                     dims = len(copy_shape)
 
                     # Skip supported copy types
@@ -1030,7 +1025,7 @@ def _emit_copy(self, state_id: int, src_node: nodes.Node, src_storage: dtypes.St
 
             # Obtain copy information
             copy_shape, src_strides, dst_strides, src_expr, dst_expr = (memlet_copy_to_absolute_strides(
-                self._dispatcher, sdfg, state_dfg, edge, src_node, dst_node, codegen=self))
+                self._dispatcher, sdfg, state_dfg, edge, src_node, dst_node))
             dims = len(copy_shape)
             dtype = dst_node.desc(sdfg).dtype
 
@@ -1282,7 +1277,7 @@ def _emit_copy(self, state_id: int, src_node: nodes.Node, src_storage: dtypes.St
             if inner_schedule == dtypes.ScheduleType.GPU_Device:
                 # Obtain copy information
                 copy_shape, src_strides, dst_strides, src_expr, dst_expr = (memlet_copy_to_absolute_strides(
-                    self._dispatcher, sdfg, state, edge, src_node, dst_node, codegen=self))
+                    self._dispatcher, sdfg, state, edge, src_node, dst_node))
                 dims = len(copy_shape)
 
                 funcname = 'dace::%sTo%s%dD' % (_get_storagename(src_storage), _get_storagename(dst_storage), dims)

dace/codegen/targets/framecode.py

@@ -549,9 +549,7 @@ def _can_allocate(self, sdfg: SDFG, state: SDFGState, desc: data.Data, scope: Un
         cstate = scope if isinstance(scope, SDFGState) else state
         csdfg = scope if isinstance(scope, SDFG) else sdfg
 
-        if desc.storage in dtypes.FPGA_STORAGES:
-            return sdscope.is_devicelevel_fpga(csdfg, cstate, node)
-        elif desc.storage in dtypes.GPU_STORAGES:
+        if desc.storage in dtypes.GPU_STORAGES:
             return sdscope.is_devicelevel_gpu(csdfg, cstate, node)
 
         return False

dace/codegen/targets/snitch.py

@@ -612,7 +612,7 @@ def copy_memory(
 
             copy_shape, src_strides, dst_strides, src_expr, dst_expr = \
                 cpp.memlet_copy_to_absolute_strides(
-                    self.dispatcher, sdfg, state_dfg, edge, src_node, dst_node, codegen=self)
+                    self.dispatcher, sdfg, state_dfg, edge, src_node, dst_node)
             dbg(f'  copy_shape = "{copy_shape}", src_strides = "{src_strides}", dst_strides = "{dst_strides}", src_expr = "{src_expr}", dst_expr = "{dst_expr}"'
                 )