Merge branch 'main' into fix-settings-after-ruff

Author: egparedes

src/gt4py/cartesian/frontend/gtscript_frontend.py

@@ -690,6 +690,25 @@ class ParsingContext(enum.Enum):
     COMPUTATION = 2
 
 
+_DATADIMS_INDEXER = "A"
+
+
+def _is_datadims_indexing_name(name: str):
+    return name.endswith(f".{_DATADIMS_INDEXER}")
+
+
+def _trim_indexing_symbol(name: str):
+    return name[: -1 * (len(_DATADIMS_INDEXER) + 1)]
+
+
+def _is_datadims_indexing_node(node):
+    return (
+        isinstance(node.value, ast.Attribute)
+        and node.value.attr == _DATADIMS_INDEXER
+        and isinstance(node.value.value, ast.Name)
+    )
+
+
 class IRMaker(ast.NodeVisitor):
     def __init__(
         self,
@@ -1037,6 +1056,10 @@ def visit_Name(self, node: ast.Name) -> nodes.Ref:
             result = nodes.VarRef(name=symbol, loc=nodes.Location.from_ast_node(node))
         elif self._is_local_symbol(symbol):
             raise AssertionError("Logic error")
+        elif _is_datadims_indexing_name(symbol):
+            result = nodes.FieldRef.datadims_index(
+                name=_trim_indexing_symbol(symbol), loc=nodes.Location.from_ast_node(node)
+            )
         else:
             raise AssertionError(f"Missing '{symbol}' symbol definition")
 
@@ -1145,12 +1168,16 @@ def visit_Subscript(self, node: ast.Subscript):
                 field_axes = self.fields[result.name].axes
                 if index is not None:
                     if len(field_axes) != len(index):
+                        ro_field_message = ""
+                        if len(field_axes) == 0:
+                            ro_field_message = f"Did you mean .A{index}?"
                         raise GTScriptSyntaxError(
                             f"Incorrect offset specification detected. Found {index}, "
-                            f"but the field has dimensions ({', '.join(field_axes)})"
+                            f"but the field has dimensions ({', '.join(field_axes)}). "
+                            f"{ro_field_message}"
                         )
                     result.offset = {axis: value for axis, value in zip(field_axes, index)}
-            elif isinstance(node.value, ast.Subscript):
+            elif isinstance(node.value, ast.Subscript) or _is_datadims_indexing_node(node):
                 result.data_index = [
                     (
                         nodes.ScalarLiteral(value=value, data_type=nodes.DataType.INT32)
@@ -1601,6 +1628,11 @@ def visit_Assign(self, node: ast.Assign):
                 elif isinstance(t, ast.Subscript):
                     if isinstance(t.value, ast.Name):
                         name_node = t.value
+                    elif _is_datadims_indexing_node(t):
+                        raise GTScriptSyntaxError(
+                            message="writing to an GlobalTable ('A' global indexation) is forbidden",
+                            loc=nodes.Location.from_ast_node(node),
+                        )
                     elif isinstance(t.value, ast.Subscript) and isinstance(t.value.value, ast.Name):
                         name_node = t.value.value
                     else:

src/gt4py/cartesian/frontend/nodes.py

@@ -354,6 +354,10 @@ def at_center(
             name=name, offset={axis: 0 for axis in axes}, data_index=data_index or [], loc=loc
         )
 
+    @classmethod
+    def datadims_index(cls, name: str, loc=None):
+        return cls(name=name, offset={}, data_index=[], loc=loc)
+
 
 @attribclass
 class Cast(Expr):

src/gt4py/cartesian/gtscript.py

@@ -694,10 +694,23 @@ def __getitem__(self, field_spec):
         return _FieldDescriptor(dtype, axes, data_dims)
 
 
+class _GlobalTableDescriptorMaker(_FieldDescriptorMaker):
+    def __getitem__(self, field_spec):
+        if not isinstance(field_spec, collections.abc.Collection) and not len(field_spec) == 2:
+            raise ValueError("GlobalTable is defined by a tuple (type, [axes_size..])")
+
+        dtype, data_dims = field_spec
+
+        return _FieldDescriptor(dtype, [], data_dims)
+
+
 # GTScript builtins: variable annotations
 Field = _FieldDescriptorMaker()
 """Field descriptor."""
 
+GlobalTable = _GlobalTableDescriptorMaker()
+"""Data array with no spatial dimension descriptor."""
+
 
 class _SequenceDescriptor:
     def __init__(self, dtype, length):

src/gt4py/next/otf/languages.py

@@ -57,6 +57,11 @@ class Python(LanguageTag):
     ...
 
 
+class SDFG(LanguageTag):
+    settings_class = LanguageSettings
+    ...
+
+
 class NanobindSrcL(LanguageTag): ...
 
 

src/gt4py/next/program_processors/runners/dace.py

@@ -0,0 +1,88 @@
+# GT4Py - GridTools Framework
+#
+# Copyright (c) 2014-2023, ETH Zurich
+# All rights reserved.
+#
+# This file is part of the GT4Py project and the GridTools framework.
+# GT4Py is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or any later
+# version. See the LICENSE.txt file at the top-level directory of this
+# distribution for a copy of the license or check <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import functools
+
+import factory
+
+import gt4py._core.definitions as core_defs
+from gt4py.next import config
+from gt4py.next.otf import recipes, stages
+from gt4py.next.program_processors.runners.dace_iterator.workflow import (
+    DaCeCompilationStepFactory,
+    DaCeTranslationStepFactory,
+    convert_args,
+)
+from gt4py.next.program_processors.runners.gtfn import GTFNBackendFactory
+
+
+def _no_bindings(inp: stages.ProgramSource) -> stages.CompilableSource:
+    return stages.CompilableSource(program_source=inp, binding_source=None)
+
+
+class DaCeWorkflowFactory(factory.Factory):
+    class Meta:
+        model = recipes.OTFCompileWorkflow
+
+    class Params:
+        device_type: core_defs.DeviceType = core_defs.DeviceType.CPU
+        cmake_build_type: config.CMakeBuildType = factory.LazyFunction(
+            lambda: config.CMAKE_BUILD_TYPE
+        )
+        use_field_canonical_representation: bool = False
+
+    translation = factory.SubFactory(
+        DaCeTranslationStepFactory,
+        device_type=factory.SelfAttribute("..device_type"),
+        use_field_canonical_representation=factory.SelfAttribute(
+            "..use_field_canonical_representation"
+        ),
+    )
+    bindings = _no_bindings
+    compilation = factory.SubFactory(
+        DaCeCompilationStepFactory,
+        cache_lifetime=factory.LazyFunction(lambda: config.BUILD_CACHE_LIFETIME),
+        cmake_build_type=factory.SelfAttribute("..cmake_build_type"),
+    )
+    decoration = factory.LazyAttribute(
+        lambda o: functools.partial(
+            convert_args,
+            device=o.device_type,
+            use_field_canonical_representation=o.use_field_canonical_representation,
+        )
+    )
+
+
+class DaCeBackendFactory(GTFNBackendFactory):
+    class Params:
+        otf_workflow = factory.SubFactory(
+            DaCeWorkflowFactory,
+            device_type=factory.SelfAttribute("..device_type"),
+            use_field_canonical_representation=factory.SelfAttribute(
+                "..use_field_canonical_representation"
+            ),
+        )
+        name = factory.LazyAttribute(
+            lambda o: f"run_dace_{o.name_device}{o.name_temps}{o.name_cached}{o.name_postfix}"
+        )
+        auto_optimize = factory.Trait(
+            otf_workflow__translation__auto_optimize=True,
+            name_temps="_opt",
+        )
+        use_field_canonical_representation: bool = False
+
+
+run_dace_cpu = DaCeBackendFactory(cached=True, auto_optimize=True)
+
+run_dace_gpu = DaCeBackendFactory(gpu=True, cached=True, auto_optimize=True)