feat: Add no-heap static allocation PAL backend for lockstep mode

.github/workflows/host.yml

@@ -171,6 +171,69 @@ jobs:
           path: ${{ github.workspace }}/gtest_results/
           retention-days: 14
 
+  build-static:
+    name: Static allocation (no-heap)
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install ccache
+        run: sudo apt-get update -qq && sudo apt-get install -y ccache
+
+      - name: Cache ccache
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/ccache
+          key: ccache-${{ runner.os }}-static-alloc-${{ github.sha }}
+          restore-keys: |
+            ccache-${{ runner.os }}-static-alloc-
+
+      - name: Cache CMake FetchContent
+        uses: actions/cache@v4
+        with:
+          path: build/_deps
+          key: fetchcontent-${{ runner.os }}-static-alloc-${{ hashFiles('CMakeLists.txt') }}
+          restore-keys: |
+            fetchcontent-${{ runner.os }}-static-alloc-
+
+      - name: Configure CMake (static allocation)
+        run: >
+          cmake -B build
+          -DCMAKE_CXX_COMPILER=g++
+          -DCMAKE_C_COMPILER=gcc
+          -DCMAKE_C_COMPILER_LAUNCHER=ccache
+          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+          -DCMAKE_BUILD_TYPE=Release
+          -DSOMEIP_USE_STATIC_ALLOC=ON
+          -DENABLE_WERROR=ON
+
+      - name: Build
+        run: cmake --build build --config Release
+
+      - name: Test
+        working-directory: build
+        run: |
+          mkdir -p "$GITHUB_WORKSPACE/gtest_results"
+          export GTEST_OUTPUT="xml:$GITHUB_WORKSPACE/gtest_results/"
+          ctest --build-config Release --output-on-failure --timeout 30 --no-tests=error --output-junit junit_results.xml
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: test-results-host-static-alloc
+          path: build/junit_results.xml
+          retention-days: 14
+
+      - name: Upload GTest detailed results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: gtest-results-host-static-alloc
+          path: ${{ github.workspace }}/gtest_results/
+          retention-days: 14
+
   coverage:
     runs-on: ubuntu-latest
     needs: build
@@ -360,7 +423,7 @@ jobs:
   publish-test-results:
     name: Publish Test Results
     runs-on: ubuntu-latest
-    needs: [build, build-fedora, coverage, sanitizers]
+    needs: [build, build-fedora, build-static, coverage, sanitizers]
     if: always()
     permissions:
       checks: write

.github/workflows/preset-validation.yml

@@ -29,6 +29,7 @@ jobs:
         preset:
           - host-linux
           - host-linux-tests
+          - static-alloc-linux-tests
           - freertos-compile-check
           - threadx-compile-check
     steps:

CMakeLists.txt

@@ -67,6 +67,7 @@ option(ENABLE_WERROR "Treat compiler warnings as errors (recommended for CI)" OF
 option(SOMEIP_USE_FREERTOS "Use FreeRTOS for threading primitives" OFF)
 option(SOMEIP_USE_THREADX  "Use ThreadX for threading primitives" OFF)
 option(SOMEIP_USE_LWIP     "Use lwIP for network sockets" OFF)
+option(SOMEIP_USE_STATIC_ALLOC "Use static allocation (no heap)" OFF)
 
 # RTOS linux/POSIX port runtime tests (Linux only)
 option(SOMEIP_FREERTOS_LINUX_TESTS "Build and run FreeRTOS runtime tests using FreeRTOS POSIX port" OFF)
@@ -196,6 +197,19 @@ if(SOMEIP_USE_LWIP)
     )
 endif()
 
+# --- ETL (Embedded Template Library) for static-allocation containers ---
+if(SOMEIP_USE_STATIC_ALLOC)
+    set(BUILD_TESTS_SAVED ${BUILD_TESTS})
+    set(BUILD_TESTS OFF)
+    FetchContent_Declare(etl
+        GIT_REPOSITORY https://github.com/ETLCPP/etl.git
+        GIT_TAG        20.47.1
+        GIT_SHALLOW    TRUE
+    )
+    FetchContent_MakeAvailable(etl)
+    set(BUILD_TESTS ${BUILD_TESTS_SAVED})
+endif()
+
 # Set policy for FetchContent timestamp handling (CMake 3.24+)
 if(POLICY CMP0135)
     cmake_policy(SET CMP0135 NEW)
@@ -251,6 +265,15 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 # Include directories
 include_directories(include)
 
+# Allocation backend (selects containers_impl.h, buffer_pool_impl.h, memory_impl.h)
+# SOMEIP_STATIC_ALLOC is set via target_compile_definitions on opensomeip (PUBLIC),
+# so it propagates to dependents but NOT to PAL mock tests that compile sources directly.
+if(SOMEIP_USE_STATIC_ALLOC)
+    include_directories(include/platform/static)
+else()
+    include_directories(include/platform/dynamic)
+endif()
+
 # Platform backend include directories (selects which *_impl.h files are found)
 if(SOMEIP_USE_FREERTOS)
     include_directories(include/platform/freertos)
@@ -611,6 +634,11 @@ elseif(WIN32)
 else()
     message(STATUS "    Networking ............ BSD sockets")
 endif()
+if(SOMEIP_USE_STATIC_ALLOC)
+    message(STATUS "    Allocation ............ Static (ETL, no heap)")
+else()
+    message(STATUS "    Allocation ............ Dynamic (STL)")
+endif()
 message(STATUS "  Build tests ............. ${BUILD_TESTS}")
 message(STATUS "  Build examples .......... ${BUILD_EXAMPLES}")
 message(STATUS "  Dev tools ............... ${SOMEIP_DEV_TOOLS}")

CMakePresets.json

@@ -170,6 +170,17 @@
         "SOMEIP_THREADX_RENODE_TESTS": "ON",
         "ARM_FLOAT_ABI": "soft"
       }
+    },
+    {
+      "name": "static-alloc-linux-tests",
+      "displayName": "Static Allocation (No-Heap) with Tests",
+      "description": "Host build with static allocation backend and unit tests. Exercises slab pools, ETL containers, malloc trap, and PAL conformance for no-heap lockstep mode.",
+      "inherits": "base",
+      "cacheVariables": {
+        "SOMEIP_USE_STATIC_ALLOC": "ON",
+        "BUILD_TESTS": "ON",
+        "BUILD_EXAMPLES": "OFF"
+      }
     }
   ],
   "buildPresets": [
@@ -232,6 +243,10 @@
     {
       "name": "threadx-cortexm4-renode",
       "configurePreset": "threadx-cortexm4-renode"
+    },
+    {
+      "name": "static-alloc-linux-tests",
+      "configurePreset": "static-alloc-linux-tests"
     }
   ],
   "testPresets": [
@@ -289,6 +304,17 @@
         "timeout": 30,
         "noTestsAction": "error"
       }
+    },
+    {
+      "name": "static-alloc-linux-tests",
+      "configurePreset": "static-alloc-linux-tests",
+      "output": {
+        "outputOnFailure": true
+      },
+      "execution": {
+        "timeout": 30,
+        "noTestsAction": "error"
+      }
     }
   ]
 }

docs/requirements/implementation/architecture.rst

@@ -190,6 +190,27 @@ Testing Infrastructure
 
    **Code Location**: ``tests/``
 
+Static Allocation
+-----------------
+
+.. requirement:: Static Allocation Policy
+   :id: REQ_ARCH_008
+   :satisfies: REQ_ARCH_003
+   :status: implemented
+   :priority: high
+   :category: happy_path
+   :verification: Build with ``SOMEIP_USE_STATIC_ALLOC=ON`` and run unit tests with heap-interception enabled (``REQ_PAL_NOOP_HEAP_VERIFY``). Verify no ``malloc``, ``free``, ``new``, or ``delete`` calls occur during protocol operation. Inspect container and pool types for compile-time capacity bounds.
+
+   When ``SOMEIP_USE_STATIC_ALLOC`` is enabled, the stack shall not perform
+   dynamic memory allocation (heap) at runtime. All buffers, containers, and
+   object pools shall use compile-time-sized static storage.
+
+   **Rationale**: Freedom from interference per ISO 26262 Part 6 clause 7.4.6;
+   WCET determinism per clause 7.4.11.
+
+   **Code Location**: ``CMakeLists.txt``, ``include/platform/static/``,
+   ``src/platform/static/``
+
 Traceability
 ============