feat[cartesian] Debug Backend

src/gt4py/cartesian/backend/__init__.py

@@ -19,6 +19,7 @@
     register,
 )
 from .cuda_backend import CudaBackend
+from .debug_backend import DebugBackend
 from .gtcpp_backend import GTCpuIfirstBackend, GTCpuKfirstBackend, GTGpuBackend
 from .module_generator import BaseModuleGenerator
 from .numpy_backend import NumpyBackend
@@ -32,6 +33,7 @@
     "BasePyExtBackend",
     "CLIBackendMixin",
     "CudaBackend",
+    "DebugBackend",
     "GTCpuIfirstBackend",
     "GTCpuKfirstBackend",
     "GTGpuBackend",

src/gt4py/cartesian/backend/base.py

@@ -317,6 +317,15 @@ def make_module_source(self, *, args_data: Optional[ModuleData] = None, **kwargs
         source = self.MODULE_GENERATOR_CLASS()(args_data, self.builder, **kwargs)
         return source
 
+    def recursive_write(self, root_path: pathlib.Path, tree: dict[str, Union[str, dict]]):
+        root_path.mkdir(parents=True, exist_ok=True)
+        for key, value in tree.items():
+            if isinstance(value, dict):
+                self.recursive_write(root_path / key, value)
+            else:
+                src_path = root_path / key
+                src_path.write_text(value)
+
 
 class MakeModuleSourceCallable(Protocol):
     def __call__(self, *, args_data: Optional[ModuleData] = None, **kwargs: Any) -> str: ...

src/gt4py/cartesian/backend/debug_backend.py

@@ -0,0 +1,68 @@
+# GT4Py - GridTools Framework
+#
+# Copyright (c) 2014-2024, ETH Zurich
+# All rights reserved.
+#
+# Please, refer to the LICENSE file in the root directory.
+# SPDX-License-Identifier: BSD-3-Clause
+
+
+from typing import TYPE_CHECKING, Any, ClassVar, Type, Union
+
+from gt4py import storage
+from gt4py.cartesian.backend.base import BaseBackend, CLIBackendMixin, register
+from gt4py.cartesian.backend.numpy_backend import ModuleGenerator
+from gt4py.cartesian.gtc.debug.debug_codegen import DebugCodeGen
+from gt4py.cartesian.gtc.gtir_to_oir import GTIRToOIR
+from gt4py.cartesian.gtc.passes.oir_optimizations.horizontal_execution_merging import (
+    HorizontalExecutionMerging,
+)
+from gt4py.cartesian.gtc.passes.oir_optimizations.temporaries import LocalTemporariesToScalars
+from gt4py.cartesian.gtc.passes.oir_pipeline import OirPipeline
+from gt4py.eve.codegen import format_source
+
+
+if TYPE_CHECKING:
+    from gt4py.cartesian.stencil_object import StencilObject
+
+
+@register
+class DebugBackend(BaseBackend, CLIBackendMixin):
+    """Debug backend using plain python loops."""
+
+    name = "debug"
+    options: ClassVar[dict[str, Any]] = {
+        "oir_pipeline": {"versioning": True, "type": OirPipeline},
+        "ignore_np_errstate": {"versioning": True, "type": bool},
+    }
+    storage_info = storage.layout.NaiveCPULayout
+    languages = {"computation": "python", "bindings": ["python"]}
+    MODULE_GENERATOR_CLASS = ModuleGenerator
+
+    def generate_computation(self) -> dict[str, Union[str, dict]]:
+        computation_name = (
+            f"{self.builder.caching.module_prefix}"
+            + f"computation{self.builder.caching.module_postfix}.py"
+        )
+
+        oir = GTIRToOIR().visit(self.builder.gtir)
+        oir = HorizontalExecutionMerging().visit(oir)
+        oir = LocalTemporariesToScalars().visit(oir)
+        source_code = DebugCodeGen().visit(oir)
+
+        if self.builder.options.format_source:
+            source_code = format_source("python", source_code)
+
+        return {computation_name: source_code}
+
+    def generate_bindings(self, language_name: str) -> dict[str, Union[str, dict]]:
+        super().generate_bindings(language_name)
+        return {self.builder.module_path.name: self.make_module_source()}
+
+    def generate(self) -> Type["StencilObject"]:
+        self.check_options(self.builder.options)
+        src_dir = self.builder.module_path.parent
+        if not self.builder.options._impl_opts.get("disable-code-generation", False):
+            src_dir.mkdir(parents=True, exist_ok=True)
+            self.recursive_write(src_dir, self.generate_computation())
+        return self.make_module()

src/gt4py/cartesian/backend/numpy_backend.py

@@ -8,7 +8,6 @@
 
 from __future__ import annotations
 
-import pathlib
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Type, Union, cast
 
 from gt4py import storage as gt_storage
@@ -57,16 +56,6 @@ def backend(self) -> NumpyBackend:
         return cast(NumpyBackend, self.builder.backend)
 
 
-def recursive_write(root_path: pathlib.Path, tree: Dict[str, Union[str, dict]]):
-    root_path.mkdir(parents=True, exist_ok=True)
-    for key, value in tree.items():
-        if isinstance(value, dict):
-            recursive_write(root_path / key, value)
-        else:
-            src_path = root_path / key
-            src_path.write_text(value)
-
-
 @register
 class NumpyBackend(BaseBackend, CLIBackendMixin):
     """NumPy backend using gtc."""
@@ -105,7 +94,7 @@ def generate(self) -> Type[StencilObject]:
         src_dir = self.builder.module_path.parent
         if not self.builder.options._impl_opts.get("disable-code-generation", False):
             src_dir.mkdir(parents=True, exist_ok=True)
-            recursive_write(src_dir, self.generate_computation())
+            self.recursive_write(src_dir, self.generate_computation())
         return self.make_module()
 
     def _make_npir(self) -> npir.Computation:

src/gt4py/cartesian/gtc/debug/__init__.py

@@ -0,0 +1,7 @@
+# GT4Py - GridTools Framework
+#
+# Copyright (c) 2014-2024, ETH Zurich
+# All rights reserved.
+#
+# Please, refer to the LICENSE file in the root directory.
+# SPDX-License-Identifier: BSD-3-Clause