[resumable] Deprecate resumable functions

Author: salkinium

src/modm/platform/spi/at90_tiny_mega/module.lb

@@ -15,7 +15,7 @@ def get_properties(env):
     device = env[":target"]
     driver = device.get_driver("spi:avr")
     properties = {}
-    properties["use_fiber"] = env.query(":processing:fiber:__enabled", False)
+    properties["use_fiber"] = env.get(":processing:use_fiber_shim", True)
     properties["target"] = device.identifier
     properties["partname"] = device.partname
     properties["driver"] = driver

src/modm/platform/spi/rp/module.lb

@@ -25,7 +25,7 @@ class Instance(Module):
     def build(self, env):
         env.substitutions = {
             "id": self.instance,
-            "use_fiber": env.query(":processing:fiber:__enabled", False)
+            "use_fiber": env.get(":processing:use_fiber_shim", True)
         }
         env.outbasepath = "modm/src/modm/platform/spi"
 

src/modm/platform/spi/sam/module.lb

@@ -14,7 +14,7 @@ def get_properties(env):
     device = env[":target"]
     driver = device.get_driver("spi")
     properties = {}
-    properties["use_fiber"] = env.query(":processing:fiber:__enabled", False)
+    properties["use_fiber"] = env.get(":processing:use_fiber_shim", True)
     properties["target"] = device.identifier
     properties["features"] = driver["feature"] if "feature" in driver else []
     return properties

src/modm/platform/spi/sam_x7x/module.lb

@@ -15,7 +15,7 @@
 def get_properties(env):
     device = env[":target"]
     properties = {}
-    properties["use_fiber"] = env.query(":processing:fiber:__enabled", False)
+    properties["use_fiber"] = env.get(":processing:use_fiber_shim", True)
     properties["target"] = device.identifier
     return properties
 

src/modm/platform/spi/stm32/module.lb

@@ -16,7 +16,7 @@ def get_properties(env):
     device = env[":target"]
     driver = device.get_driver("spi")
     properties = {}
-    properties["use_fiber"] = env.query(":processing:fiber:__enabled", False)
+    properties["use_fiber"] = env.get(":processing:use_fiber_shim", True)
     properties["target"] = device.identifier
     properties["features"] = driver["feature"] if "feature" in driver else []
     return properties

src/modm/platform/spi/stm32_uart/module.lb

@@ -17,7 +17,7 @@ def get_properties(env):
         "target": device.identifier,
         "driver": driver,
         "over8_sampling": ("feature" in driver) and ("over8" in driver["feature"]),
-        "use_fiber": env.query(":processing:fiber:__enabled", False)
+        "use_fiber": env.get(":processing:use_fiber_shim", True)
     }
     return properties
 

src/modm/platform/spi/stm32h7/module.lb

@@ -16,7 +16,7 @@ def get_properties(env):
     device = env[":target"]
     driver = device.get_driver("spi")
     properties = {}
-    properties["use_fiber"] = env.query(":processing:fiber:__enabled", False)
+    properties["use_fiber"] = env.get(":processing:use_fiber_shim", True)
     properties["target"] = device.identifier
 
     return properties

src/modm/processing/fiber.hpp

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2024, Niklas Hauser
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+%% if with_functions
+// includes the functions related to time
+#include "fiber/functions.hpp"
+%% endif
+%% if with_task
+// pulls in the fiber and scheduler implementation
+#include "fiber/task.hpp"
+%% else
+// polyfill implementation of an empty yield
+#include "fiber/no_yield.hpp"
+%% endif

src/modm/processing/fiber.hpp.in

@@ -16,15 +16,9 @@ def init(module):
     module.name = ":processing:fiber"
     module.description = FileReader("module.md")
 
-def is_enabled(env):
-    return env.get(":processing:protothread:use_fiber", False) or \
-        not env.has_module(":processing:protothread")
-
 def prepare(module, options):
-    module.depends(":architecture:clock", ":architecture:atomic", ":architecture:assert")
-
-    module.add_query(
-        EnvironmentQuery(name="__enabled", factory=is_enabled))
+    module.depends(":architecture:clock", ":architecture:atomic",
+                   ":architecture:assert", ":stdc++")
 
     core = options[":target"].get_driver("core")["type"]
     if core.startswith("cortex-m"): module.depends(":cmsis:device")
@@ -34,7 +28,11 @@ def prepare(module, options):
 
 def build(env):
     env.outbasepath = "modm/src/modm/processing/fiber"
-    env.copy("../fiber.hpp")
+    env.substitutions = {
+        "with_functions": True,
+        "with_task": True,
+    }
+    env.template("../fiber.hpp.in")
 
     core = env[":target"].get_driver("core")["type"]
     with_fpu = env.get(":platform:cortex-m:float-abi", "soft") != "soft"

src/modm/processing/fiber/module.lb

@@ -11,6 +11,8 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 # -----------------------------------------------------------------------------
 
+import os
+
 def init(module):
     module.name = ":processing"
     module.description = """\
@@ -21,18 +23,34 @@ and delegation.
 """
 
 def prepare(module, options):
+    module.depends(":architecture:clock", ":architecture:atomic")
+    module.add_option(
+        BooleanOption(
+            name="use_fiber_shim",
+            default=True,
+            description="Implement Protothreads and Resumable Functions via Fibers"))
     return True
 
 def build(env):
     env.outbasepath = "modm/src/modm/processing"
     env.copy("task.hpp")
+    has_protothread = env.has_module(":processing:protothread")
+    has_resumable = env.has_module(":processing:resumable")
+    has_timer = env.has_module(":processing:timer")
+    has_fiber = env.has_module(":processing:fiber")
 
-    if not env.has_module(":processing:fiber"):
+    if (has_protothread or has_resumable or has_timer) and not has_fiber:
         env.outbasepath = "modm/src/modm/processing/"
+        env.substitutions = {
+            "with_functions": env.has_module(":architecture:clock"),
+            "with_task": False,
+        }
         env.copy("fiber/functions.hpp")
         env.copy("fiber/no_yield.hpp")
-        env.copy("fiber.hpp")
+        env.template("fiber.hpp.in")
+        if has_resumable:
+            env.copy("fiber/mutex.hpp")
 
     env.outbasepath = "modm/src/modm"
-    headers = env.generated_local_files(filterfunc=lambda path: ".h" in path and not "_impl.h" in path)
+    headers = env.generated_local_files(filterfunc=lambda path: ".hpp" in path and path.count(os.path.sep) == 1)
     env.template("processing.hpp.in", substitutions={"headers": sorted(headers)})

src/modm/processing/module.lb

@@ -18,6 +18,4 @@
 #include "{{ header | modm.posixify }}"
 %% endfor
 
-#include "processing/task.hpp"
-
 #endif	// MODM_PROCESSING_HPP

src/modm/processing/processing.hpp.in

@@ -17,18 +17,17 @@ def init(module):
 
 def prepare(module, options):
     module.depends(":architecture")
-    module.add_option(
-        BooleanOption(
+    module.add_alias(
+        Alias(
             name="use_fiber",
-            default=False,
-            description="Implement via Fibers",
-            dependencies=lambda v: ":processing:fiber" if v else None))
+            destination=":processing:use_fiber_shim",
+            description="Moved for better dependency management"))
 
     return True
 
 def build(env):
     env.outbasepath = "modm/src/modm/processing/protothread"
-    if env["use_fiber"]:
+    if env[":processing:use_fiber_shim"]:
         env.copy("macros_fiber.hpp", "macros.hpp")
         env.copy("protothread_fiber.hpp", "protothread.hpp")
     else:

src/modm/processing/protothread/module.lb

@@ -27,9 +27,13 @@ def prepare(module, options):
 
     return True
 
+def validate(env):
+    if not env[":processing:use_fiber_shim"]:
+        env.log.warning(descr_deprecated)
+
 def build(env):
     env.outbasepath = "modm/src/modm/processing/resumable"
-    if env.query(":processing:fiber:__enabled", False):
+    if env[":processing:use_fiber_shim"]:
         env.copy("macros_fiber.hpp", "macros.hpp")
         env.copy("resumable_fiber.hpp", "resumable.hpp")
     else:
@@ -57,3 +61,14 @@ function polling and just continuing program execution.
     on function entry and not during every polling call, so the performance
     penalty is relatively small.
 """
+
+descr_deprecated = """
+
+        ####  Resumable Functions are deprecated!  ####
+
+Unfortunately GCC12 is the last version that supported the way we implemented
+Resumables. Since GCC13 the implementation does not compile anymore and cannot
+be fixed without significant breaking changes.
+
+Please port your code to use `modm:processing:fiber` instead.
+"""

src/modm/processing/resumable/module.lb

@@ -1,5 +1,12 @@
 # Resumable Functions
 
+!!! warning "Resumable Functions are deprecated!"
+    Unfortunately GCC12 is the last version that supported the way we implemented
+    Resumables. Since GCC13 the implementation does not compile anymore and cannot
+    be fixed without significant breaking changes.
+    Please port your code to use `modm:processing:fiber` instead.
+
+
 An implementation of lightweight resumable functions which allow for nested
 calling.
 
@@ -159,7 +166,7 @@ The given example is in `modm/examples/generic/resumable`.
 ## Using Fibers
 
 Resumable functions can be implemented using stackful fibers by setting the
-`modm:processing:protothreads:use_fiber` option, which replaces the
+`modm:processing:use_fiber_shim` option, which replaces the
 preprocessor macros and C++ implementations of this and the
 `modm:processing:protothreads` module with a fiber version.
 

src/modm/processing/resumable/module.md

@@ -12,8 +12,6 @@
 #pragma once
 
 #include "macros.hpp"
-#include <modm/processing/fiber.hpp>
-#include <modm/processing/fiber/mutex.hpp>
 #include <stdint.h>
 
 #define MODM_RESUMABLE_IS_FIBER

src/modm/processing/resumable/resumable_fiber.hpp

@@ -19,6 +19,7 @@ def prepare(module, options):
     module.depends(
         ":architecture:clock",
         ":architecture:assert",
+        # ":processing:fiber", managed manually in ../module.lb
         ":math:utils")
     return True