N1 full compute

.clang-tidy

@@ -0,0 +1,51 @@
+# Advisory only for now: see .github/workflows/clang-tidy.yml, which runs
+# this report-only (it does not fail the job on findings). The performance-*
+# family targets exactly the class of bug found in the Eigen unnecessary-copy
+# audit (by-value Eigen/STL params, const-ref-to-value copies, ...);
+# readability-const-return-type catches `const T foo()` return types that
+# block move semantics on the caller side. misc-const-correctness covers the
+# same ground as the manual const-correctness sweep (see the element_container
+# / LSGrid commit it landed alongside): local variables that are never
+# reassigned but aren't declared const. Runs in ~5 minutes over src/core as of
+# this writing (own measurement, GCC 13 / clang-tidy 18) -- noticeably slower
+# than the other checks here, but still well within the report-only job's
+# budget.
+#
+# modernize-use-override: this codebase used to keep the `virtual` keyword on
+# overrides alongside `override`/`final`, which this check flags as
+# redundant on every single one of them -- ~80% pure noise against that
+# style in an initial run. Rather than suppress the check, the redundant
+# `virtual` was dropped codebase-wide (virtual is implied by `override`, and
+# by `final` on an actual override) as part of the same final/override sweep,
+# and every destructor overriding a base's virtual destructor was annotated
+# `override` too, bringing this down to 2 residual warnings, both the same
+# explainable case: `override final` used together for defensive
+# compile-time checking (marks BOTH "this really overrides something" and
+# "no further overrides") on a method in a class that ISN'T itself `final`
+# (OneSideContainer::disconnect_if_not_in_main_component,
+# TwoSidesContainer::nb_line_end) -- the check prefers `final` alone since it
+# implies `override`, but the pair is intentional there and left as-is.
+# (Classes that are themselves `final` don't repeat `final` on their
+# methods -- redundant, since the class already can't be subclassed at all.)
+#
+# Known false-positive class: performance-unnecessary-value-param flags every
+# `Eigen::Ref<...>` parameter passed by value (the idiom used throughout this
+# codebase -- Ref is a thin pointer+size+stride wrapper, cheap to copy) as if
+# it were an expensive-to-copy type. Confirmed while validating this config;
+# left un-suppressed for now so the report-only phase shows the real noise
+# level before anyone spends time tuning NOLINT / config exclusions for it.
+Checks: >
+  -*,
+  performance-*,
+  readability-const-return-type,
+  misc-const-correctness,
+  modernize-use-override
+WarningsAsErrors: ''
+# Only report on our own headers (src/core, src/bindings) -- clang-tidy's
+# default (empty) header filter would otherwise only ever look at the
+# primary .cpp file and silently skip every inline-in-header function, which
+# is most of this codebase's element_container / powerflow_algorithm classes.
+# Vendored trees (eigen/, Catch2/, SuiteSparse/) live outside src/, so this
+# regex excludes them without needing a separate exclude list.
+HeaderFilterRegex: '.*/src/(core|bindings)/.*'
+FormatStyle: none

.github/workflows/clang-tidy.yml

@@ -0,0 +1,83 @@
+# Static analysis: runs clang-tidy's performance-* / readability-const-return-type
+# checks over src/core (the checks that would have caught the unnecessary Eigen
+# copies found and fixed across several PRs). Report-only for now (see the
+# "Summarize" step): findings are posted to the job summary and uploaded as an
+# artifact, but do not fail the job. Once the baseline noise level is known,
+# flip `continue-on-error` below (and drop the `|| true`) to make this a real
+# gate -- e.g. restricted to the master / tag triggers already below, so a
+# regression blocks a release without slowing down every topic-branch push.
+#
+# Triggers: on demand (Actions tab -> this workflow -> "Run workflow"), on
+# every push to master, and on every version tag -- not on topic branches,
+# since this is advisory / slower than the test suites that do run there.
+name: clang-tidy
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  clang-tidy:
+    name: performance / readability checks (src/core)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # eigen (transitive include of the core headers), Catch2 (needed to
+          # configure src/tests, even though test files are not analyzed) and
+          # SuiteSparse (KLU headers)
+          submodules: true
+
+      - name: Install clang-tidy
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y clang-tidy
+          clang-tidy --version
+
+      - name: Configure (generates compile_commands.json for src/core)
+        # standalone test project: no python / pybind11 involved, matching
+        # the C++ unit tests workflow. -DCMAKE_EXPORT_COMPILE_COMMANDS=ON is
+        # the only addition -- clang-tidy needs it to see the real include
+        # paths / defines each translation unit was configured with.
+        run: cmake -S src/tests -B build_tidy -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+
+      - name: Run clang-tidy over src/core
+        # Not built: clang-tidy re-parses each translation unit itself via
+        # libTooling and does not need object files or a link step.
+        # `|| true`: see the report-only note above -- warnings must not fail
+        # this job yet, only errors in clang-tidy's own invocation would
+        # (caught separately by checking the report is non-empty below).
+        run: |
+          find src/core -name '*.cpp' | sort > /tmp/tidy_files.txt
+          wc -l < /tmp/tidy_files.txt
+          clang-tidy -p build_tidy $(cat /tmp/tidy_files.txt) > clang-tidy-report.txt 2>&1 || true
+
+      - name: Summarize
+        run: |
+          {
+            echo "## clang-tidy (performance-*, readability-const-return-type)"
+            echo
+            if [ ! -s clang-tidy-report.txt ]; then
+              echo "clang-tidy produced no output -- something upstream (configure/invocation) likely failed silently. Check the previous step's log."
+            else
+              n_warnings=$(grep -c 'warning:' clang-tidy-report.txt || true)
+              echo "**${n_warnings} finding(s)** across $(wc -l < /tmp/tidy_files.txt) files in \`src/core\`."
+              echo
+              echo "This workflow is report-only: it does not fail the job. See \`.github/workflows/clang-tidy.yml\` for how to promote it to a gate."
+              echo
+              echo '```'
+              head -c 60000 clang-tidy-report.txt
+              echo '```'
+            fi
+          } >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Upload full report
+        uses: actions/upload-artifact@v4
+        with:
+          name: clang-tidy-report
+          path: clang-tidy-report.txt
+          retention-days: 30

.github/workflows/cpp_unit_tests.yml

@@ -0,0 +1,50 @@
+# C++ unit tests: builds the Catch2 suite under src/tests/ (the archive layer
+# compiled straight into a small test binary -- no python, no pip, no solver
+# deps) and runs it twice: once through ctest, once under valgrind. Being a
+# plain binary makes valgrind practical here (--error-exitcode=1 turns any
+# memory error into a CI failure), which it is not over the python test suite
+# (10-50x slowdown plus CPython suppressions). Complements the Sanitizers
+# workflow, which exercises the full python extension.
+
+name: C++ unit tests
+
+on:
+  push:
+    branches:
+      # '**' and not '*': a single '*' does not match '/' in GitHub Actions
+      # globs, so topic branches like 'foo/bar' would silently never run
+      - '**'
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  cpp_unit_tests:
+    name: Catch2 + valgrind
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # eigen (transitive include of the core headers) and Catch2
+          submodules: true
+
+      - name: Install valgrind
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y valgrind
+
+      - name: Configure
+        # standalone test project: no python, pybind11 or KLU involved.
+        # Debug keeps assert() live and gives valgrind full line info.
+        run: cmake -S src/tests -B build_tests -DCMAKE_BUILD_TYPE=Debug
+
+      - name: Build
+        run: cmake --build build_tests -j$(nproc)
+
+      - name: Run tests
+        run: ctest --test-dir build_tests --output-on-failure
+
+      - name: Run tests under valgrind
+        run: |
+          cd build_tests
+          valgrind --error-exitcode=1 --leak-check=full --track-origins=yes \
+            ./lightsim2grid_unit_tests

.github/workflows/main.yml

@@ -723,6 +723,20 @@ jobs:
       - name: Run plugin test
         run: python examples/external_algorithm/test_plugin.py
 
+      - name: Run plugin registration unittests (against the installed package)
+        shell: bash
+        # Run from the scratch dir so `import lightsim2grid` resolves to the
+        # pip-installed package, not the source tree (which has no built
+        # extension). LS2G_TEST_PLUGIN_DIR points the tests at the plugin built
+        # above; the finders pick the right per-platform file name themselves.
+        working-directory: _tmp_cmake_dir
+        env:
+          LS2G_TEST_PLUGIN_DIR: ${{ github.workspace }}/examples/external_algorithm/build
+        run: |
+          python -m unittest -v \
+            lightsim2grid.tests.test_solver_registry \
+            lightsim2grid.tests.test_plugin_registration
+
   test_klu_strategies:
     name: Test KLU detection strategies (Ubuntu)
     runs-on: ubuntu-latest
@@ -802,6 +816,56 @@ jobs:
           print('Strategy 1 OK: KLU available')
           "
 
+  test_march_native:
+    # -march=native is a supported opt-in build flag (see benchmarks/env_compile_all.sh)
+    # that release wheels do not use, so plain CI builds never exercise it. It changes
+    # which SIMD ISA Eigen sees enabled (__AVX__, __AVX2__, ...) in each translation
+    # unit; lightsim2grid_core and lightsim2grid_cpp (the pybind11 bindings) are two
+    # separate shared libraries, so both must see the identical flag -- otherwise an
+    # Eigen object allocated in one and freed in the other computes a different
+    # alignment offset, corrupting the heap ("double free or corruption") the first
+    # time a function's return value crosses the module boundary (e.g. any pandapower
+    # -> LightSimBackend conversion, or a forecast-backend copy). Regression test for
+    # that class of bug: env creation reliably crashed within seconds before the fix.
+    name: Test -march=native build (Ubuntu)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -r requirements_compile_ci.txt
+          python -m pip install grid2op pandapower lxml
+
+      - name: Build lightsim2grid with -march=native
+        run: __COMPILE_MARCHNATIVE=1 __O3_OPTIM=1 python -m pip install -v . --no-build-isolation
+
+      - name: Create + reset a LightSimBackend env (exercises the core<->bindings Eigen boundary)
+        run: |
+          mkdir -p _march_native_check
+          cd _march_native_check
+          python -c "
+          import warnings
+          from grid2op import make
+          from grid2op.Parameters import Parameters
+          from lightsim2grid import LightSimBackend
+
+          param = Parameters()
+          param.init_from_dict({'NO_OVERFLOW_DISCONNECTION': True, 'ENV_DC': True, 'FORECAST_DC': True})
+          with warnings.catch_warnings():
+              warnings.filterwarnings('ignore')
+              env = make('l2rpn_case14_sandbox', backend=LightSimBackend(), param=param, test=True)
+          env.reset()
+          print('OK: env created and reset under -march=native without crashing')
+          "
+
   package:
     name: Package wheels
     runs-on: ubuntu-latest

.github/workflows/sanitizers.yml

@@ -0,0 +1,106 @@
+# Memory-hardening CI: builds the C++ core + bindings with instrumentation
+# that the release wheels do not carry, and runs the test modules most likely
+# to surface memory issues (out-of-bounds, use-after-free, UB, silenced
+# assertions). Complements the functional suites on CircleCI, which run
+# against plain optimized builds.
+
+name: Sanitizers
+
+on:
+  push:
+    branches:
+      # '**' and not '*': a single '*' does not match '/' in GitHub Actions
+      # globs, so topic branches like 'foo/bar' would silently never run
+      - '**'
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  asan_ubsan:
+    # AddressSanitizer + UndefinedBehaviorSanitizer over the untrusted-input
+    # path (binary serialization) and the heaviest C++ compute paths (solver
+    # control, time series, contingency analysis).
+    name: ASan + UBSan tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -r requirements_compile_ci.txt
+          python -m pip install grid2op scipy pandapower
+
+      - name: Build lightsim2grid with ASan + UBSan
+        # __SANITIZE=1 is picked up by src/core/CMakeLists.txt and
+        # src/bindings/python/CMakeLists.txt: -fsanitize=address,undefined
+        # on both lightsim2grid_core and lightsim2grid_cpp
+        run: __SANITIZE=1 python -m pip install -v . --no-build-isolation
+
+      - name: Run tests under ASan + UBSan
+        # The sanitized code lives in a python extension, so the ASan runtime
+        # must be the first thing loaded into the (uninstrumented) python
+        # process: hence LD_PRELOAD. libstdc++ must be preloaded along with
+        # it: python itself does not link it, and without it ASan's
+        # __cxa_throw interceptor cannot resolve the real function and every
+        # C++ exception aborts the process. Leak detection stays off:
+        # CPython's allocator keeps interned objects alive by design and
+        # would drown real reports in noise.
+        env:
+          ASAN_OPTIONS: detect_leaks=0
+          UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1
+        run: |
+          export LD_PRELOAD="$(gcc -print-file-name=libasan.so) $(gcc -print-file-name=libstdc++.so.6)"
+          cd lightsim2grid/tests
+          python -W ignore -m unittest -v \
+            test_binary_serialization \
+            test_solver_control \
+            test_TimeSerie \
+            test_time_series_dc \
+            test_SecurityAnlysis \
+            test_DCSecurityAnlysis \
+            test_SecurityAnlysis_cpp \
+            test_ContingencyAnalysis_limit_violations \
+            test_ContingencyAnalysis_split \
+            test_check_grid \
+            test_LSGrid_out_of_bounds
+
+  debug_asserts:
+    # Release wheels are compiled with NDEBUG, which silences every Eigen
+    # bounds assertion: logically-wrong-but-in-bounds indexing is invisible
+    # to ASan. This build re-enables them (plus the ABI-safe libstdc++
+    # container checks) and runs the solver-heavy modules.
+    name: Eigen/libstdc++ assertions tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -r requirements_compile_ci.txt
+          python -m pip install grid2op scipy pandapower
+
+      - name: Build lightsim2grid with assertions re-enabled
+        # __DEBUG_ASSERTS=1 -> -UNDEBUG -D_GLIBCXX_ASSERTIONS on both targets
+        run: __DEBUG_ASSERTS=1 python -m pip install -v . --no-build-isolation
+
+      - name: Run solver tests with assertions active
+        run: |
+          cd lightsim2grid/tests
+          python -W ignore -m unittest -v \
+            test_ACPF \
+            test_DCPF \
+            test_solver_control

.gitignore

@@ -9,6 +9,7 @@ __pycache__/
 # Distribution / packaging
 .Python
 build/
+build_tests/
 develop-eggs/
 dist/
 downloads/

.gitmodules

@@ -6,3 +6,7 @@
 	path = eigen
 	url = https://gitlab.com/libeigen/eigen.git
 	ignore = dirty
+[submodule "Catch2"]
+	path = Catch2
+	url = https://github.com/catchorg/Catch2.git
+	ignore = dirty