Fortran frontend

dace/codegen/targets/cpp.py

@@ -1063,7 +1063,12 @@ def _Name(self, t: ast.Name):
 
         # Replace values with their code-generated names (for example, persistent arrays)
         desc = self.sdfg.arrays[t.id]
-        self.write(ptr(t.id, desc, self.sdfg, self.codegen))
+        base_ptr = ptr(t.id, desc, self.sdfg, self.codegen)
+        if isinstance(desc, data.View):
+            # In the case of a view we obtain a pointer that needs to be dereferenced first.
+            self.write(f'(*{base_ptr})')
+        else:
+            self.write(base_ptr)
 
     def _Attribute(self, t: ast.Attribute):
         from dace.frontend.python.astutils import rname

dace/codegen/targets/cpu.py

@@ -398,7 +398,8 @@ def allocate_array(self, sdfg: SDFG, cfg: ControlFlowRegion, dfg: StateSubgraphV
             arrsize_bytes = arrsize * nodedesc.dtype.bytes
 
         if isinstance(nodedesc, data.Structure) and not isinstance(nodedesc, data.StructureView):
-            declaration_stream.write(f"{nodedesc.ctype} {name} = new {nodedesc.dtype.base_type};\n")
+            if not declared:
+                declaration_stream.write(f"{nodedesc.ctype} {name} = new {nodedesc.dtype.base_type};\n")
             define_var(name, DefinedType.Pointer, nodedesc.ctype)
             if allocate_nested_data:
                 for k, v in nodedesc.members.items():
@@ -476,21 +477,21 @@ def allocate_array(self, sdfg: SDFG, cfg: ControlFlowRegion, dfg: StateSubgraphV
             declaration_stream.write(definition, cfg, state_id, node)
             define_var(name, DefinedType.Stream, ctypedef)
 
-        elif (nodedesc.storage == dtypes.StorageType.CPU_Heap
-              or (nodedesc.storage == dtypes.StorageType.Register and
+        elif (top_storage == dtypes.StorageType.CPU_Heap
+              or (top_storage == dtypes.StorageType.Register and
                   ((symbolic.issymbolic(arrsize, sdfg.constants)) or
                    (arrsize_bytes and ((arrsize_bytes > Config.get("compiler", "max_stack_array_size")) == True))))):
 
-            if nodedesc.storage == dtypes.StorageType.Register:
+            if top_storage == dtypes.StorageType.Register:
 
                 if symbolic.issymbolic(arrsize, sdfg.constants):
                     warnings.warn('Variable-length array %s with size %s '
                                   'detected and was allocated on heap instead of '
-                                  '%s' % (name, cpp.sym2cpp(arrsize), nodedesc.storage))
+                                  '%s' % (name, cpp.sym2cpp(arrsize), top_storage))
                 elif (arrsize_bytes > Config.get("compiler", "max_stack_array_size")) == True:
                     warnings.warn("Array {} with size {} detected and was allocated on heap instead of "
                                   "{} since its size is greater than max_stack_array_size ({})".format(
-                                      name, cpp.sym2cpp(arrsize_bytes), nodedesc.storage,
+                                      name, cpp.sym2cpp(arrsize_bytes), top_storage,
                                       Config.get("compiler", "max_stack_array_size")))
 
             ctypedef = dtypes.pointer(nodedesc.dtype).ctype
@@ -510,7 +511,7 @@ def allocate_array(self, sdfg: SDFG, cfg: ControlFlowRegion, dfg: StateSubgraphV
                                         node)
 
             return
-        elif (nodedesc.storage == dtypes.StorageType.Register):
+        elif (top_storage == dtypes.StorageType.Register):
             ctypedef = dtypes.pointer(nodedesc.dtype).ctype
             if nodedesc.start_offset != 0:
                 raise NotImplementedError('Start offset unsupported for registers')
@@ -531,7 +532,7 @@ def allocate_array(self, sdfg: SDFG, cfg: ControlFlowRegion, dfg: StateSubgraphV
             )
             define_var(name, DefinedType.Pointer, ctypedef)
             return
-        elif nodedesc.storage is dtypes.StorageType.CPU_ThreadLocal:
+        elif top_storage is dtypes.StorageType.CPU_ThreadLocal:
             # Define pointer once
             # NOTE: OpenMP threadprivate storage MUST be declared globally.
             if not declared:
@@ -566,7 +567,7 @@ def allocate_array(self, sdfg: SDFG, cfg: ControlFlowRegion, dfg: StateSubgraphV
             allocation_stream.write('}')
             self._dispatcher.defined_vars.add_global(name, DefinedType.Pointer, '%s *' % nodedesc.dtype.ctype)
         else:
-            raise NotImplementedError("Unimplemented storage type " + str(nodedesc.storage))
+            raise NotImplementedError("Unimplemented storage type " + str(top_storage))
 
     def deallocate_array(self, sdfg: SDFG, cfg: ControlFlowRegion, dfg: StateSubgraphView, state_id: int,
                          node: nodes.AccessNode, nodedesc: data.Data, function_stream: CodeIOStream,

dace/codegen/targets/framecode.py

@@ -51,6 +51,11 @@ def __init__(self, sdfg: SDFG):
         self.fsyms: Dict[int, Set[str]] = {}
         self._symbols_and_constants: Dict[int, Set[str]] = {}
         fsyms = self.free_symbols(sdfg)
+        # TODO: Hack, remove!
+        fsyms = set(filter(lambda x: not (
+            str(x).startswith('__f2dace_SA') or str(x).startswith('__f2dace_SOA') or
+            str(x).startswith('tmp_struct_symbol')
+        ), fsyms))
         self.arglist = sdfg.arglist(scalars_only=False, free_symbols=fsyms)
 
         # resolve all symbols and constants
@@ -239,8 +244,11 @@ def generate_footer(self, sdfg: SDFG, global_stream: CodeIOStream, callsite_stre
         fname = sdfg.name
         params = sdfg.signature(arglist=self.arglist)
         paramnames = sdfg.signature(False, for_call=True, arglist=self.arglist)
-        initparams = sdfg.init_signature(free_symbols=self.free_symbols(sdfg))
-        initparamnames = sdfg.init_signature(for_call=True, free_symbols=self.free_symbols(sdfg))
+        # TODO: Hack, revert!
+        initparams = sdfg.signature(arglist=self.arglist)
+        initparamnames = sdfg.signature(False, for_call=True, arglist=self.arglist)
+        #initparams = sdfg.init_signature(free_symbols=self.free_symbols(sdfg))
+        #initparamnames = sdfg.init_signature(for_call=True, free_symbols=self.free_symbols(sdfg))
 
         # Invoke all instrumentation providers
         for instr in self._dispatcher.instrumentation.values():

dace/data.py

@@ -420,7 +420,7 @@ def __init__(self,
         #     else:
         #         fields_and_types[str(s)] = dtypes.int32
 
-        dtype = dtypes.pointer(dtypes.struct(name, **fields_and_types))
+        dtype = dtypes.pointer(dtypes.struct(name, fields_and_types))
         shape = (1, )
         super(Structure, self).__init__(dtype, shape, transient, storage, location, lifetime, debuginfo)
 

dace/dtypes.py

@@ -787,7 +787,8 @@ class struct(typeclass):
         Example use: `dace.struct(a=dace.int32, b=dace.float64)`.
     """
 
-    def __init__(self, name, **fields_and_types):
+    def __init__(self, name, fields_and_types=None, **fields):
+        fields_and_types = fields_and_types or fields
         # self._data = fields_and_types
         self.type = ctypes.Structure
         self.name = name