Improve how thread priority is applied

.github/workflows/gcc.yaml

@@ -40,7 +40,9 @@ jobs:
     continue-on-error: true
 
     # Use the container for this specific version of gcc
-    container: ${{ matrix.toolchain.container }}
+    container:
+      image: ${{ matrix.toolchain.container }}
+      options: --privileged
 
     steps:
       - name: Checkout Code
@@ -49,7 +51,7 @@ jobs:
       # Update for all the actions that need to install stuff
       - run: |
           apt-get update
-          apt-get install -y software-properties-common unzip
+          apt-get install -y software-properties-common unzip sudo
 
       - name: Install GCC
         run: |
@@ -90,6 +92,9 @@ jobs:
       - name: CCache Stats
         run: ccache --show-stats
 
+      - name: Add capabilities for scheduler
+        run: find build/tests -type f -executable -exec sudo setcap cap_sys_nice=eip {} \; || true
+
       - name: Test
         timeout-minutes: 2
         working-directory: build

.github/workflows/sonarcloud.yaml

@@ -67,6 +67,9 @@ jobs:
         timeout-minutes: 30
         run: cmake --build build/ --config Release
 
+      - name: Add capabilities for scheduler
+        run: find build/tests -type f -executable -exec sudo setcap cap_sys_nice=eip {} \; || true
+
       - name: Run tests to generate coverage statistics
         timeout-minutes: 10
         working-directory: build

src/LogLevel.hpp

@@ -110,7 +110,7 @@ class LogLevel {
      *
      * @param value The value to construct the LogLevel from
      */
-    constexpr LogLevel(const Value& value = Value::UNKNOWN) : value(value) {};
+    constexpr LogLevel(const Value& value = Value::UNKNOWN) noexcept : value(value) {}
 
     /**
      * Construct a LogLevel from a string
@@ -168,7 +168,7 @@ class LogLevel {
      *
      * @return The ostream that was passed in
      */
-    friend std::ostream& operator<<(std::ostream& os, LogLevel level) {
+    friend std::ostream& operator<<(std::ostream& os, const LogLevel& level) {
         return os << static_cast<std::string>(level);
     }
 
@@ -208,11 +208,11 @@ class LogLevel {
     friend  bool operator!=(const std::string& lhs, const LogLevel& rhs) { return lhs != static_cast<std::string>(rhs); }
     // clang-format on
 
-
 private:
     /// The stored enum value
     Value value;
 };
+
 }  // namespace NUClear
 
 #endif  // NUCLEAR_LOGLEVEL_HPP

src/PriorityLevel.hpp

@@ -0,0 +1,156 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2024 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef NUCLEAR_PRIORITY_LEVEL_HPP
+#define NUCLEAR_PRIORITY_LEVEL_HPP
+
+#include <cstdint>
+#include <string>
+
+namespace NUClear {
+
+class PriorityLevel {
+public:
+    enum Value : uint8_t {
+        UNKNOWN  = 0,
+        IDLE     = 1,
+        LOWEST   = 2,
+        LOW      = 3,
+        NORMAL   = 4,
+        HIGH     = 5,
+        HIGHEST  = 6,
+        REALTIME = 7
+    };
+
+    /**
+     * Construct a PriorityLevel from a Value
+     *
+     * @param value The value to construct the PriorityLevel from
+     */
+    constexpr PriorityLevel(const Value& value = Value::NORMAL) noexcept : value(value) {}
+
+    /**
+     * Construct a PriorityLevel from a string
+     *
+     * @param level The string to construct the PriorityLevel from
+     */
+    PriorityLevel(const std::string& level)
+        : value(level == "IDLE"       ? Value::IDLE
+                : level == "LOWEST"   ? Value::LOWEST
+                : level == "LOW"      ? Value::LOW
+                : level == "NORMAL"   ? Value::NORMAL
+                : level == "HIGH"     ? Value::HIGH
+                : level == "HIGHEST"  ? Value::HIGHEST
+                : level == "REALTIME" ? Value::REALTIME
+                                      : Value::NORMAL) {}
+
+    /**
+     * A call operator which will return the value of the PriorityLevel
+     * This can be useful in situations where the implicit conversion operators are ambiguous.
+     *
+     * @return The value of the PriorityLevel
+     */
+    constexpr Value operator()() const {
+        return value;
+    }
+
+    /**
+     * A conversion operator which will return the value of the PriorityLevel
+     *
+     * @return The value of the PriorityLevel
+     */
+    constexpr operator Value() const {
+        return value;
+    }
+
+    /**
+     * A conversion operator which will return the string representation of the PriorityLevel
+     *
+     * @return The string representation of the PriorityLevel
+     */
+    operator std::string() const {
+        return value == Value::IDLE       ? "IDLE"
+               : value == Value::LOWEST   ? "LOWEST"
+               : value == Value::LOW      ? "LOW"
+               : value == Value::NORMAL   ? "NORMAL"
+               : value == Value::HIGH     ? "HIGH"
+               : value == Value::HIGHEST  ? "HIGHEST"
+               : value == Value::REALTIME ? "REALTIME"
+                                          : "UNKNOWN";
+    }
+
+    /**
+     * Stream the PriorityLevel to an ostream, it will output the string representation of the PriorityLevel
+     *
+     * @param os The ostream to output to
+     * @param level The PriorityLevel to output
+     *
+     * @return The ostream that was passed in
+     */
+    friend std::ostream& operator<<(std::ostream& os, const PriorityLevel& level) {
+        return os << static_cast<std::string>(level);
+    }
+
+    // Operators to compare PriorityLevel values and PriorityLevel to Value
+    // clang-format off
+    friend constexpr bool operator<(const PriorityLevel& lhs, const PriorityLevel& rhs) { return lhs.value < rhs.value; }
+    friend constexpr bool operator>(const PriorityLevel& lhs, const PriorityLevel& rhs) { return lhs.value > rhs.value; }
+    friend constexpr bool operator<=(const PriorityLevel& lhs, const PriorityLevel& rhs) { return lhs.value <= rhs.value; }
+    friend constexpr bool operator>=(const PriorityLevel& lhs, const PriorityLevel& rhs) { return lhs.value >= rhs.value; }
+    friend constexpr bool operator==(const PriorityLevel& lhs, const PriorityLevel& rhs) { return lhs.value == rhs.value; }
+    friend constexpr bool operator!=(const PriorityLevel& lhs, const PriorityLevel& rhs) { return lhs.value != rhs.value; }
+
+    friend constexpr bool operator<(const PriorityLevel& lhs, const Value& rhs) { return lhs.value < rhs; }
+    friend constexpr bool operator>(const PriorityLevel& lhs, const Value& rhs) { return lhs.value > rhs; }
+    friend constexpr bool operator<=(const PriorityLevel& lhs, const Value& rhs) { return lhs.value <= rhs; }
+    friend constexpr bool operator>=(const PriorityLevel& lhs, const Value& rhs) { return lhs.value >= rhs; }
+    friend constexpr bool operator==(const PriorityLevel& lhs, const Value& rhs) { return lhs.value == rhs; }
+    friend constexpr bool operator!=(const PriorityLevel& lhs, const Value& rhs) { return lhs.value != rhs; }
+    friend constexpr bool operator<(const Value& lhs, const PriorityLevel& rhs) { return lhs < rhs.value; }
+    friend constexpr bool operator>(const Value& lhs, const PriorityLevel& rhs) { return lhs > rhs.value; }
+    friend constexpr bool operator<=(const Value& lhs, const PriorityLevel& rhs) { return lhs <= rhs.value; }
+    friend constexpr bool operator>=(const Value& lhs, const PriorityLevel& rhs) { return lhs >= rhs.value; }
+    friend constexpr bool operator==(const Value& lhs, const PriorityLevel& rhs) { return lhs == rhs.value; }
+    friend constexpr bool operator!=(const Value& lhs, const PriorityLevel& rhs) { return lhs != rhs.value; }
+
+    friend  bool operator<(const PriorityLevel& lhs, const std::string& rhs) { return static_cast<std::string>(lhs) < rhs; }
+    friend  bool operator>(const PriorityLevel& lhs, const std::string& rhs) { return static_cast<std::string>(lhs) > rhs; }
+    friend  bool operator<=(const PriorityLevel& lhs, const std::string& rhs) { return static_cast<std::string>(lhs) <= rhs; }
+    friend  bool operator>=(const PriorityLevel& lhs, const std::string& rhs) { return static_cast<std::string>(lhs) >= rhs; }
+    friend  bool operator==(const PriorityLevel& lhs, const std::string& rhs) { return static_cast<std::string>(lhs) == rhs; }
+    friend  bool operator!=(const PriorityLevel& lhs, const std::string& rhs) { return static_cast<std::string>(lhs) != rhs; }
+    friend  bool operator<(const std::string& lhs, const PriorityLevel& rhs) { return lhs < static_cast<std::string>(rhs); }
+    friend  bool operator>(const std::string& lhs, const PriorityLevel& rhs) { return lhs > static_cast<std::string>(rhs); }
+    friend  bool operator<=(const std::string& lhs, const PriorityLevel& rhs) { return lhs <= static_cast<std::string>(rhs); }
+    friend  bool operator>=(const std::string& lhs, const PriorityLevel& rhs) { return lhs >= static_cast<std::string>(rhs); }
+    friend  bool operator==(const std::string& lhs, const PriorityLevel& rhs) { return lhs == static_cast<std::string>(rhs); }
+    friend  bool operator!=(const std::string& lhs, const PriorityLevel& rhs) { return lhs != static_cast<std::string>(rhs); }
+    // clang-format on
+
+private:
+    /// The stored enum value
+    Value value;
+};
+
+}  // namespace NUClear
+
+#endif  // NUCLEAR_PRIORITY_LEVEL_HPP

src/dsl/Parse.hpp

@@ -76,16 +76,16 @@ namespace dsl {
                 Parse<Sentence...>>(task);
         }
 
-        static int priority(threading::ReactionTask& task) {
+        static PriorityLevel priority(threading::ReactionTask& task) {
             return std::conditional_t<fusion::has_priority<DSL>::value, DSL, fusion::NoOp>::template priority<
                 Parse<Sentence...>>(task);
         }
 
         static auto scope(threading::ReactionTask& task)
             -> decltype(std::conditional_t<fusion::has_scope<DSL>::value, DSL, fusion::NoOp>::template scope<
                         Parse<Sentence...>>(task)) {
-            return std::conditional_t<fusion::has_scope<DSL>::value, DSL, fusion::NoOp>::template scope<Parse<Sentence...>>(
-                task);
+            return std::conditional_t<fusion::has_scope<DSL>::value, DSL, fusion::NoOp>::template scope<
+                Parse<Sentence...>>(task);
         }
     };
 

src/dsl/fusion/NoOp.hpp

@@ -80,8 +80,8 @@ namespace dsl {
             }
 
             template <typename DSL>
-            static int priority(const threading::ReactionTask& /*task*/) {
-                return word::Priority::NORMAL::value;
+            static PriorityLevel priority(const threading::ReactionTask& /*task*/) {
+                return PriorityLevel::NORMAL;
             }
 
             template <typename DSL>

src/dsl/fusion/PriorityFusion.hpp

@@ -44,7 +44,7 @@ namespace dsl {
         struct PriorityFuser<std::tuple<Word>> {
 
             template <typename DSL>
-            static int priority(threading::ReactionTask& task) {
+            static PriorityLevel priority(threading::ReactionTask& task) {
 
                 // Return our priority
                 return Word::template priority<DSL>(task);
@@ -56,7 +56,7 @@ namespace dsl {
         struct PriorityFuser<std::tuple<Word1, Word2, WordN...>> {
 
             template <typename DSL>
-            static int priority(threading::ReactionTask& task) {
+            static PriorityLevel priority(threading::ReactionTask& task) {
 
                 // Choose our maximum priority
                 return std::max(Word1::template priority<DSL>(task),

src/dsl/word/Always.hpp

@@ -128,13 +128,16 @@ namespace dsl {
             static std::unique_ptr<threading::ReactionTask> make_idle_task(
                 const std::shared_ptr<threading::Reaction>& reaction) {
 
-                auto idle_task = std::make_unique<threading::ReactionTask>(
-                    reaction,
-                    false,
-                    [](threading::ReactionTask& task) { return DSL::priority(task) - 1; },
-                    DSL::run_inline,
-                    DSL::pool,
-                    DSL::group);
+                auto idle_task = std::make_unique<threading::ReactionTask>(reaction,
+                                                                           false,
+                                                                           DSL::priority,
+                                                                           DSL::run_inline,
+                                                                           DSL::pool,
+                                                                           DSL::group);
+
+
+                // Manipulate the id so it always runs after the always task
+                idle_task->id = std::numeric_limits<NUClear::id_t>::max();
 
                 idle_task->callback = [](threading::ReactionTask& task) {
                     // Submit the always and idle tasks to the scheduler