Merge pull request networkit#1283 from fabratu/20250116_ci_coverage_leak

fabratu · web-flow · commit dfd76a68c93c · 2025-02-07T14:00:14.000+01:00
CI: Split coverage and leak build, fix leaks, remove aarch64 wheel build
diff --git a/.github/workflows/build_wheels.yml b/.github/workflows/build_wheels.yml
@@ -54,45 +54,48 @@ jobs:
           path: ./wheelhouse/*cp313*.whl
           retention-days: ${{ env.ARTIFACT_RETENTION }}
 
-  cpython-linux-aarch64:
-    name: 'Linux CPython (${{ matrix.cibw_archs }}, ${{ matrix.manylinux_image }})'
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-20.04]
-        cibw_archs: ["aarch64"]
-        manylinux_image: ["manylinux2014"]
-    steps:
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-        with:
-          platforms: all
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - uses: actions/setup-python@v5
-        name: Install Python
-        with:
-          python-version: '3.12'
-      - name: Build wheels
-        uses: pypa/cibuildwheel@v2.21.1
-        env:
-          CIBW_BEFORE_BUILD: pip install cython
-          CIBW_MANYLINUX_X86_64_IMAGE: ${{ matrix.manylinux_image }}
-          CIBW_ARCHS_LINUX: ${{ matrix.cibw_archs }}
-          CIBW_BUILD: ${{ github.ref == 'refs/heads/master' && 'cp312-* cp313-*' || 'cp312-*' }}
-          CIBW_SKIP: "pp* *-musllinux_*"
-      - uses: actions/upload-artifact@v4
-        with:
-          name: 'linux-${{ matrix.cibw_archs }}-cp312-${{ github.run_id }}'
-          path: ./wheelhouse/*cp312*.whl
-          retention-days: ${{ env.ARTIFACT_RETENTION }}
-      - uses: actions/upload-artifact@v4
-        if: github.ref == 'refs/heads/master'
-        with:
-          name: 'linux-${{ matrix.cibw_archs }}-cp313-${{ github.run_id }}'
-          path: ./wheelhouse/*cp313*.whl
-          retention-days: ${{ env.ARTIFACT_RETENTION }}
+  # THIS ACTION IS DISABLED DUE TO SEGMENTATION FAULT IN GCC COMPILER
+  # Additional note: continue-on-error does not work currently for cibuildwheel: 
+  # https://github.com/pypa/cibuildwheel/issues/1062
+  # cpython-linux-aarch64:
+  #   name: 'Linux CPython (${{ matrix.cibw_archs }}, ${{ matrix.manylinux_image }})'
+  #   runs-on: ${{ matrix.os }}
+  #   strategy:
+  #     matrix:
+  #       os: [ubuntu-20.04]
+  #       cibw_archs: ["aarch64"]
+  #       manylinux_image: ["manylinux2014"]
+  #   steps:
+  #     - name: Set up QEMU
+  #       uses: docker/setup-qemu-action@v3
+  #       with:
+  #         platforms: all
+  #     - uses: actions/checkout@v4
+  #       with:
+  #         submodules: true
+  #     - uses: actions/setup-python@v5
+  #       name: Install Python
+  #       with:
+  #         python-version: '3.12'
+  #     - name: Build wheels
+  #       uses: pypa/cibuildwheel@v2.21.1
+  #       env:
+  #         CIBW_BEFORE_BUILD: pip install cython
+  #         CIBW_MANYLINUX_X86_64_IMAGE: ${{ matrix.manylinux_image }}
+  #         CIBW_ARCHS_LINUX: ${{ matrix.cibw_archs }}
+  #         CIBW_BUILD: ${{ github.ref == 'refs/heads/master' && 'cp312-* cp313-*' || 'cp312-*' }}
+  #         CIBW_SKIP: "pp* *-musllinux_*"
+  #     - uses: actions/upload-artifact@v4
+  #       with:
+  #         name: 'linux-${{ matrix.cibw_archs }}-cp312-${{ github.run_id }}'
+  #         path: ./wheelhouse/*cp312*.whl
+  #         retention-days: ${{ env.ARTIFACT_RETENTION }}
+  #     - uses: actions/upload-artifact@v4
+  #       if: github.ref == 'refs/heads/master'
+  #       with:
+  #         name: 'linux-${{ matrix.cibw_archs }}-cp313-${{ github.run_id }}'
+  #         path: ./wheelhouse/*cp313*.whl
+  #         retention-days: ${{ env.ARTIFACT_RETENTION }}
 
   cpython-macos:
     name: 'macOS CPython  (${{ matrix.buildplat[1] }})'
@@ -235,7 +238,7 @@ jobs:
     if: needs.check-release-tag.outputs.is-release == 'true' && github.repository == 'networkit/networkit'
     name: 'PyPi release upload'
     runs-on: ubuntu-22.04
-    needs: [cpython-macos, cpython-linux-aarch64, cpython-linux-x86_64, cpython-windows, source-distribution, check-release-tag]
+    needs: [cpython-macos, cpython-linux-x86_64, cpython-windows, source-distribution, check-release-tag]
     steps:
       - uses: actions/download-artifact@v4
         with:
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -306,7 +306,7 @@ jobs:
         run:  ${{ github.workspace }}/.github/workflows/scripts/clang_tidy.sh
         shell: bash
 
-  linux-build-core-sanitizers-coverage:
+  linux-build-coverage:
     name: "Linux (gcc-10, CPython 3.12): coverage"
     runs-on: ubuntu-22.04
     env:
@@ -330,7 +330,7 @@ jobs:
         with:
           submodules: true
       - name: Prepare environment and run checks
-        run:  ${{ github.workspace }}/.github/workflows/scripts/core_sanitizers_coverage.sh
+        run:  ${{ github.workspace }}/.github/workflows/scripts/coverage.sh
         shell: bash
         timeout-minutes: 180
       - name: Create C++ coverage
@@ -354,6 +354,31 @@ jobs:
           . pyenv/bin/activate
           python3 ${{ github.workspace }}/.github/workflows/scripts/upload_coverage.py
 
+  linux-build-leak:
+    name: "Linux (gcc-10, CPython 3.12): leak checks"
+    runs-on: ubuntu-22.04
+    env:
+      UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1:report_error_type=1:suppressions=../UBSAN.filter
+    steps:
+      - name: Install prerequisites
+        run:  |
+          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc
+          echo "deb http://apt.llvm.org/jammy llvm-toolchain-jammy-17 main" | sudo tee /etc/apt/sources.list.d/llvm17.list
+          sudo apt-get update
+          sudo apt-get install libomp-17-dev clang-17 clang-tidy-17 ninja-build
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+      - name: Prepare environment and run checks
+        run:  |
+          mkdir build && cd build
+          cmake -GNinja -DNETWORKIT_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug -DNETWORKIT_CXX_STANDARD=${{ env.CXX_STANDARD }} -DNETWORKIT_WITH_SANITIZERS=leak  -DCMAKE_CXX_COMPILER=/usr/bin/clang++-17 ..
+          ninja
+          ctest -V -C Debug
+        shell: bash
+        timeout-minutes: 180
+
   windows-build-msvc:
     name: "Windows (msvc 14.X): ${{ matrix.build-configuration }}"
     runs-on: windows-2022
diff --git a/.github/workflows/scripts/coverage.sh b/.github/workflows/scripts/coverage.sh
@@ -2,16 +2,16 @@
 
 python3 -m venv pyenv && . pyenv/bin/activate
 pip3 install --upgrade pip
-pip3 install coveralls cython gcovr matplotlib requests setuptools tabulate numpy networkx ipycytoscape seaborn plotly
+pip3 install coveralls cython gcovr matplotlib requests setuptools tabulate numpy networkx ipycytoscape seaborn plotly anywidget
 
 mkdir core_build && cd "$_"
 export CPU_COUNT=$(python3 $GITHUB_WORKSPACE/.github/workflows/scripts/get_core_count.py)
-cmake -DNETWORKIT_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug -DNETWORKIT_WITH_SANITIZERS=leak -DNETWORKIT_COVERAGE=ON ..
+cmake -DNETWORKIT_BUILD_TESTS=ON -DCMAKE_BUILD_TYPE=Debug -DNETWORKIT_COVERAGE=ON ..
 make -j$CPU_COUNT
 
-ctest -V
-
 cd ..
+./core_build/networkit_tests -t
+
 export CMAKE_LIBRARY_PATH=${CMAKE_LIBRARY_PATH:+$CMAKE_LIBRARY_PATH:}$(pwd)/core_build
 export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}$(pwd)/core_build
 
diff --git a/UBSAN.filter b/UBSAN.filter
@@ -0,0 +1 @@
+bounds:random.tcc
diff --git a/include/networkit/community/LouvainMapEquation.hpp b/include/networkit/community/LouvainMapEquation.hpp
@@ -17,7 +17,7 @@
 namespace NetworKit {
 
 class LouvainMapEquation : public CommunityDetectionAlgorithm {
-private:
+public:
     enum class ParallelizationType : uint8_t {
         NONE,
         RELAX_MAP,
@@ -27,6 +27,7 @@ class LouvainMapEquation : public CommunityDetectionAlgorithm {
         Synchronous = SYNCHRONOUS
     };
 
+public:
     /**
      * @param[in] G input graph
      * @param[in] hierarchical use recursive coarsening
@@ -37,10 +38,9 @@ class LouvainMapEquation : public CommunityDetectionAlgorithm {
      *            synchronous -> work on stale cuts and volumes, update in second step
      *
      */
-    explicit LouvainMapEquation(const Graph &graph, bool hierarchical, count maxIterations,
-                                ParallelizationType parallelizationType);
-
-public:
+    explicit LouvainMapEquation(const Graph &graph, bool hierarchical = false,
+                                count maxIterations = 32,
+                                std::string_view parallelizationStrategy = "relaxmap");
     /**
      * @param[in] G input graph
      * @param[in] hierarchical use recursive coarsening
@@ -51,11 +51,8 @@ class LouvainMapEquation : public CommunityDetectionAlgorithm {
      *            synchronous -> work on stale cuts and volumes, update in second step
      *
      */
-    explicit LouvainMapEquation(const Graph &graph, bool hierarchical = false,
-                                count maxIterations = 32,
-                                std::string_view parallelizationStrategy = "relaxmap")
-        : LouvainMapEquation(graph, hierarchical, maxIterations,
-                             convertStringToParallelizationType(parallelizationStrategy)) {}
+    explicit LouvainMapEquation(const Graph &graph, bool hierarchical, count maxIterations,
+                                ParallelizationType parallelizationType);
 
     void run() override;
 
@@ -74,8 +71,8 @@ class LouvainMapEquation : public CommunityDetectionAlgorithm {
     static_assert(std::is_trivially_destructible<Move>::value,
                   "LouvainMapEquation::Move struct is not trivially destructible");
 
-    const bool parallel;
     ParallelizationType parallelizationType;
+    bool parallel;
 
     bool hierarchical;
     count maxIterations;
@@ -122,19 +119,6 @@ class LouvainMapEquation : public CommunityDetectionAlgorithm {
         return std::make_pair(i * chunkSize, std::min(n, (i + 1) * chunkSize));
     }
 
-    ParallelizationType
-    convertStringToParallelizationType(std::string_view parallelizationStrategy) const {
-        if (parallelizationStrategy == "none")
-            return ParallelizationType::NONE;
-        else if (parallelizationStrategy == "relaxmap")
-            return ParallelizationType::RELAX_MAP;
-        else if (parallelizationStrategy == "synchronous")
-            return ParallelizationType::SYNCHRONOUS;
-        else
-            throw std::runtime_error("Invalid parallelization type for map equation Louvain: "
-                                     + std::string(parallelizationStrategy));
-    }
-
 #ifndef NDEBUG
     long double sumPLogPwAlpha = 0;
     long double sumPLogPClusterCut = 0;
diff --git a/include/networkit/graph/GraphTools.hpp b/include/networkit/graph/GraphTools.hpp
@@ -409,6 +409,19 @@ std::pair<Graph, node> createAugmentedGraph(const Graph &G);
  */
 void sortEdgesByWeight(Graph &G, bool decreasing = false);
 
+/**
+ * Given a directed graph G, the topology sort algorithm creates one valid topology order of nodes.
+ * Undirected graphs are not accepted as input, since a topology sort is a linear ordering of
+ * vertices such that for every edge u -> v, node u comes before v in the ordering.
+ * Node ids must either be continuous or you must provide a continuous node id mapping.
+ *
+ * This is a helper function. Instead of calling it via GraphTools, it is also possible to create a
+ * TopologicalSort-object from the base-class.
+ * @param   G               Directed input graph
+ * @return                  A vector of node-ids sorted according to their topology.
+ */
+std::vector<node> topologicalSort(const Graph &G);
+
 /**
  * Given a directed graph G, the topology sort algorithm creates one valid topology order of nodes.
  * Undirected graphs are not accepted as input, since a topology sort is a linear ordering of
@@ -419,10 +432,11 @@ void sortEdgesByWeight(Graph &G, bool decreasing = false);
  * TopologicalSort-object from the base-class.
  * @param   G               Directed input graph
  * @param   nodeIdMapping   Optional continuous node id mapping
+ * @param   checkMapping    Check whether the given node id map is continuous.
  * @return                  A vector of node-ids sorted according to their topology.
  */
 std::vector<node> topologicalSort(const Graph &G,
-                                  const std::unordered_map<node, node> &nodeIdMapping = {},
+                                  const std::unordered_map<node, node> &nodeIdMapping,
                                   bool checkMapping = false);
 
 /**
diff --git a/include/networkit/graph/TopologicalSort.hpp b/include/networkit/graph/TopologicalSort.hpp
@@ -22,12 +22,22 @@ namespace NetworKit {
 class TopologicalSort final : public Algorithm {
 public:
     /**
-     * Initialize the topological sort algorithm by passing an input graph. Note that topological
-     * sort is defined for directed graphs only. The node id mapping must be a continuous.
+     * Initialize the topological sort algorithm by passing an input graph.
      *
      * @param G The input graph.
      */
-    TopologicalSort(const Graph &G, const std::unordered_map<node, node> &nodeIdMapping = {},
+    TopologicalSort(const Graph &G);
+
+    /**
+     * Initialize the topological sort algorithm by passing an input graph and an node id map.
+     * The node id mapping must be a continuous. This can be checked by setting checkMapping to
+     * true.
+     *
+     * @param G The input graph.
+     * @param nodeIdMapping Node id mapping from non-continuous to continuous ids.
+     * @param checkMapping Check whether the given node id map is continuous.
+     */
+    TopologicalSort(const Graph &G, const std::unordered_map<node, node> &nodeIdMapping,
                     bool checkMapping = false);
 
     /**
@@ -52,7 +62,7 @@ class TopologicalSort final : public Algorithm {
 
     std::optional<std::unordered_map<node, node>> computedNodeIdMap;
 
-    const std::unordered_map<node, node> &nodeIdMap;
+    const std::unordered_map<node, node> *nodeIdMap = nullptr;
 
     // Used to mark the status of each node, one vector per thread
     std::vector<NodeMark> topSortMark;
diff --git a/networkit/cpp/centrality/test/CentralityGTest.cpp b/networkit/cpp/centrality/test/CentralityGTest.cpp
@@ -1961,21 +1961,22 @@ TEST_F(CentralityGTest, testApproxElectricalCloseness) {
     }
 }
 
-TEST_P(CentralityGTest, testGroupClosenessGrowShrink) {
-    if (isDirected()) { // directed graphs are not supported
-        Graph G(10, isWeighted(), true);
-        std::array<node, 1> group = {{0}};
-        EXPECT_THROW(GroupClosenessGrowShrink(G, group.begin(), group.end()), std::runtime_error);
-        return;
-    }
+TEST_F(CentralityGTest, testGroupClosenessDirected) {
+    // directed graphs are not supported
+    Graph G(10, false, true);
+    std::array<node, 1> group = {{0}};
+    EXPECT_THROW(GroupClosenessGrowShrink(G, group.begin(), group.end()), std::runtime_error);
+}
 
-    { // Empty input groups are not supported
-        Graph G(10, isWeighted(), false);
-        std::vector<node> emptyGroup;
-        EXPECT_THROW(GroupClosenessGrowShrink(G, emptyGroup.begin(), emptyGroup.end()),
-                     std::runtime_error);
-    }
+TEST_F(CentralityGTest, testGroupClosenessEmptyGroups) {
+    // Empty input groups are not supported
+    Graph G(10);
+    std::vector<node> emptyGroup;
+    EXPECT_THROW(GroupClosenessGrowShrink(G, emptyGroup.begin(), emptyGroup.end()),
+                 std::runtime_error);
+}
 
+TEST_P(CentralityGTest, testGroupClosenessGrowShrink) {
     const count k = 5;
     auto G = EdgeListReader{'\t', 0, "#", false, false}.read("input/MIT8.edgelist");
     G = ConnectedComponents::extractLargestConnectedComponent(G);
diff --git a/networkit/cpp/community/LouvainMapEquation.cpp b/networkit/cpp/community/LouvainMapEquation.cpp
@@ -21,10 +21,37 @@
 
 namespace NetworKit {
 
+LouvainMapEquation::ParallelizationType
+convertStringToParallelizationType(std::string_view parallelizationStrategy) {
+    if (parallelizationStrategy == "none")
+        return LouvainMapEquation::ParallelizationType::NONE;
+    else if (parallelizationStrategy == "relaxmap")
+        return LouvainMapEquation::ParallelizationType::RELAX_MAP;
+    else if (parallelizationStrategy == "synchronous")
+        return LouvainMapEquation::ParallelizationType::SYNCHRONOUS;
+    else
+        throw std::runtime_error("Invalid parallelization type for map equation Louvain: "
+                                 + std::string(parallelizationStrategy));
+}
+
 LouvainMapEquation::LouvainMapEquation(const Graph &graph, bool hierarchical, count maxIterations,
                                        ParallelizationType parallelizationType)
-    : CommunityDetectionAlgorithm(graph), parallel(parallelizationType > ParallelizationType::NONE),
-      parallelizationType(parallelizationType), hierarchical(hierarchical),
+    : CommunityDetectionAlgorithm(graph), parallelizationType(parallelizationType),
+      parallel(parallelizationType > ParallelizationType::NONE), hierarchical(hierarchical),
+      maxIterations(maxIterations), clusterCut(graph.upperNodeIdBound()),
+      clusterVolume(graph.upperNodeIdBound()),
+      locks(parallelizationType == ParallelizationType::RELAX_MAP ? graph.upperNodeIdBound() : 0),
+      nextPartition(
+          parallelizationType == ParallelizationType::SYNCHRONOUS ? graph.upperNodeIdBound() : 0),
+      ets_neighborClusterWeights(parallel ? Aux::getMaxNumberOfThreads() : 1) {
+    result = Partition(graph.upperNodeIdBound());
+}
+
+LouvainMapEquation::LouvainMapEquation(const Graph &graph, bool hierarchical, count maxIterations,
+                                       std::string_view parallelizationStrategy)
+    : CommunityDetectionAlgorithm(graph),
+      parallelizationType(convertStringToParallelizationType(parallelizationStrategy)),
+      parallel(parallelizationType != ParallelizationType::NONE), hierarchical(hierarchical),
       maxIterations(maxIterations), clusterCut(graph.upperNodeIdBound()),
       clusterVolume(graph.upperNodeIdBound()),
       locks(parallelizationType == ParallelizationType::RELAX_MAP ? graph.upperNodeIdBound() : 0),
diff --git a/networkit/cpp/generators/ChungLuGeneratorAlamEtAl.cpp b/networkit/cpp/generators/ChungLuGeneratorAlamEtAl.cpp
diff --git a/networkit/cpp/graph/GraphTools.cpp b/networkit/cpp/graph/GraphTools.cpp
diff --git a/networkit/cpp/graph/TopologicalSort.cpp b/networkit/cpp/graph/TopologicalSort.cpp
