v0.7.0 per changelog

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Andrey Golovanov

CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2026-03-26
+
+### Changed
+
+- Relicensed from BSD-3-Clause to MIT
+- Parallelized sensitivity analysis across candidate edges using `std::async`; thread count controlled by `NGRAPH_CORE_SENSITIVITY_THREADS` env or hardware concurrency
+- Thread-local profiling stats to remove global mutex from the hot `record()` path; public API unchanged
+
 ## [0.6.0] - 2026-02-26
 
 ### Changed

LICENSE

@@ -1,29 +1,21 @@
-BSD 3-Clause License
+MIT License
 
-Copyright (c) 2025-2026, Andrey Golovanov
-All rights reserved.
+Copyright (c) 2025-2026 Andrey Golovanov
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
+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:
 
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+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.

README.md

@@ -103,4 +103,4 @@ make cov        # Combined coverage report (C++ + Python)
 
 ## License
 
-BSD-3-Clause
+[MIT License](LICENSE)

include/netgraph/core/profiling.hpp

@@ -22,12 +22,15 @@ From Python:
 */
 #pragma once
 
+#include <algorithm>
 #include <chrono>
 #include <cstdint>
 #include <iostream>
 #include <mutex>
+#include <ostream>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace netgraph::core {
 
@@ -41,47 +44,44 @@ class ProfilingStats {
     // Defined in profiling.cpp to avoid ODR violations with static library linking.
     static ProfilingStats& instance();
 
-    void record(const char* name, double micros) {
-        std::lock_guard<std::mutex> lock(mutex_);
-        auto& e = stats_[name];
-        e.total_us += micros;
-        e.count++;
-        if (micros < e.min_us) e.min_us = micros;
-        if (micros > e.max_us) e.max_us = micros;
-    }
-
-    void dump() {
-        std::lock_guard<std::mutex> lock(mutex_);
-        std::cerr << "\n=== NetGraph-Core Profiling Stats ===\n";
-        for (const auto& [name, e] : stats_) {
-            double avg = e.count > 0 ? e.total_us / e.count : 0.0;
-            std::cerr << name << ":\n"
-                      << "  calls: " << e.count << "\n"
-                      << "  total: " << e.total_us / 1000.0 << " ms\n"
-                      << "  avg:   " << avg << " us\n"
-                      << "  min:   " << e.min_us << " us\n"
-                      << "  max:   " << e.max_us << " us\n";
-        }
-        std::cerr << "=====================================\n";
-    }
-
-    void reset() {
-        std::lock_guard<std::mutex> lock(mutex_);
-        stats_.clear();
-    }
+    void record(const char* name, double micros);
+    void dump() const { dump(std::cerr); }
+    void dump(std::ostream& out) const;
+    void reset();
 
 private:
     ProfilingStats() = default;
-
     struct Entry {
         double total_us = 0;
         int64_t count = 0;
         double min_us = 1e18;
         double max_us = 0;
     };
 
-    std::mutex mutex_;
-    std::unordered_map<std::string, Entry> stats_;
+    class LocalStats {
+    public:
+        explicit LocalStats(ProfilingStats& owner);
+        ~LocalStats();
+
+        void record(const char* name, double micros);
+        void append_to(std::unordered_map<std::string, Entry>& out) const;
+        void clear();
+
+    private:
+        ProfilingStats& owner_;
+        mutable std::mutex mutex_;
+        std::unordered_map<std::string, Entry> stats_;
+    };
+
+    LocalStats& local_stats();
+    void register_local(LocalStats* local);
+    void finalize_local(LocalStats* local);
+    static void merge_entry(Entry& dst, const Entry& src);
+    std::unordered_map<std::string, Entry> snapshot_unlocked() const;
+
+    mutable std::mutex mutex_;
+    std::vector<LocalStats*> active_locals_;
+    std::unordered_map<std::string, Entry> finished_stats_;
 };
 
 // RAII timer. Does nothing if name is nullptr.

pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "netgraph-core"
-version = "0.6.0"
+version = "0.7.0"
 description = "C++ implementation of graph algorithms for network flow analysis and traffic engineering with Python bindings"
 readme = "README.md"
 requires-python = ">=3.11"
-license = "BSD-3-Clause"
+license = "MIT"
 authors = [{ name = "Project Contributors" }]
 classifiers = [
     "Development Status :: 3 - Alpha",

src/flow_state.cpp

@@ -225,7 +225,8 @@ Flow FlowState::place_on_dag(NodeId src, NodeId dst, const PredDAG& dag,
   if (placement == FlowPlacement::Proportional) {
     // Proportional placement: use Dinic-like augmentation on reversed DAG.
     // We reverse the DAG (dst -> src) so flow propagates topologically from dst.
-    FlowWorkspace ws; build_reversed_residual(ws, N, groups);
+    FlowWorkspace ws;
+    build_reversed_residual(ws, N, groups);
     while (remaining > kMinFlow && ws.bfs(dst, src)) {
       std::fill(ws.it.begin(), ws.it.end(), 0);
       Flow pushed_layer = static_cast<Flow>(0.0);

src/max_flow.cpp

@@ -16,16 +16,77 @@
 #include <algorithm>
 #include <cmath>
 #include <cstdint>
+#include <cstdlib>
+#include <future>
 #include <limits>
 #include <memory>
 #include <optional>
 #include <queue>
+#include <thread>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 namespace netgraph::core {
 
+namespace {
+
+std::size_t sensitivity_thread_budget(std::size_t candidate_count) {
+  if (candidate_count <= 1) {
+    return 1;
+  }
+
+  const char* env = std::getenv("NGRAPH_CORE_SENSITIVITY_THREADS");
+  if (env != nullptr && env[0] != '\0') {
+    char* end = nullptr;
+    unsigned long parsed = std::strtoul(env, &end, 10);
+    if (end != env) {
+      if (parsed == 0ul) {
+        return 1;
+      }
+      return std::min<std::size_t>(static_cast<std::size_t>(parsed), candidate_count);
+    }
+  }
+
+  const auto hw = std::thread::hardware_concurrency();
+  const auto budget = hw > 0 ? static_cast<std::size_t>(hw) : 1u;
+  return std::min<std::size_t>(budget, candidate_count);
+}
+
+std::optional<std::pair<EdgeId, Flow>>
+evaluate_sensitivity_candidate(const StrictMultiDiGraph& g,
+                               NodeId src,
+                               NodeId dst,
+                               FlowPlacement placement,
+                               bool shortest_path,
+                               bool require_capacity,
+                               Flow baseline_flow,
+                               std::span<const bool> node_mask,
+                               EdgeId eid,
+                               bool* local_mask,
+                               std::size_t mask_size) {
+  local_mask[static_cast<std::size_t>(eid)] = false;
+
+  auto [new_flow, _] = calc_max_flow(
+      g, src, dst, placement,
+      shortest_path,
+      require_capacity,
+      /*with_edge_flows=*/false,
+      /*with_reachable=*/false,
+      /*with_residuals=*/false,
+      node_mask, std::span<const bool>(local_mask, mask_size));
+
+  local_mask[static_cast<std::size_t>(eid)] = true;
+
+  double delta = baseline_flow - new_flow;
+  if (delta > kMinFlow) {
+    return std::pair<EdgeId, Flow>{eid, delta};
+  }
+  return std::nullopt;
+}
+
+} // namespace
+
 std::pair<Flow, FlowSummary>
 calc_max_flow(const StrictMultiDiGraph& g, NodeId src, NodeId dst,
               FlowPlacement placement, bool shortest_path,
@@ -247,33 +308,58 @@ sensitivity_analysis(const StrictMultiDiGraph& g, NodeId src, NodeId dst,
   } else {
     std::copy(edge_mask.begin(), edge_mask.end(), test_mask_buf.get());
   }
-  // View for passing to calc_max_flow
-  std::span<const bool> test_mask_span(test_mask_buf.get(), N);
-
   std::vector<std::pair<EdgeId, Flow>> results;
   results.reserve(candidates.size());
 
   // Step 2: Iterate candidates, testing flow reduction when each is removed
-  for (EdgeId eid : candidates) {
-    // Mask out the edge
-    test_mask_buf[eid] = false;
-
-    auto [new_flow, _] = calc_max_flow(
-        g, src, dst, placement,
-        shortest_path,
-        require_capacity,
-        /*with_edge_flows=*/false,
-        /*with_reachable=*/false,
-        /*with_residuals=*/false,
-        node_mask, test_mask_span);
-
-    double delta = baseline_flow - new_flow;
-    if (delta > kMinFlow) {
-      results.emplace_back(eid, delta);
+  const auto thread_budget = sensitivity_thread_budget(candidates.size());
+  if (thread_budget <= 1) {
+    for (EdgeId eid : candidates) {
+      auto maybe_result = evaluate_sensitivity_candidate(
+          g, src, dst, placement,
+          shortest_path, require_capacity,
+          baseline_flow, node_mask,
+          eid, test_mask_buf.get(), N);
+      if (maybe_result.has_value()) {
+        results.push_back(*maybe_result);
+      }
     }
+    return results;
+  }
+
+  const auto chunk_size = (candidates.size() + thread_budget - 1) / thread_budget;
+  std::vector<std::future<std::vector<std::pair<EdgeId, Flow>>>> futures;
+  futures.reserve(thread_budget);
+
+  for (std::size_t begin = 0; begin < candidates.size(); begin += chunk_size) {
+    const std::size_t end = std::min<std::size_t>(begin + chunk_size, candidates.size());
+    futures.emplace_back(std::async(std::launch::async, [&, begin, end]() {
+      std::unique_ptr<bool[]> local_mask_buf(new bool[N]);
+      if (!edge_mask.empty()) {
+        std::copy(edge_mask.begin(), edge_mask.end(), local_mask_buf.get());
+      } else {
+        std::fill(local_mask_buf.get(), local_mask_buf.get() + N, true);
+      }
+
+      std::vector<std::pair<EdgeId, Flow>> local_results;
+      local_results.reserve(end - begin);
+      for (std::size_t idx = begin; idx < end; ++idx) {
+        auto maybe_result = evaluate_sensitivity_candidate(
+            g, src, dst, placement,
+            shortest_path, require_capacity,
+            baseline_flow, node_mask,
+            candidates[idx], local_mask_buf.get(), N);
+        if (maybe_result.has_value()) {
+          local_results.push_back(*maybe_result);
+        }
+      }
+      return local_results;
+    }));
+  }
 
-    // Restore mask
-    test_mask_buf[eid] = true;
+  for (auto& future : futures) {
+    auto local_results = future.get();
+    results.insert(results.end(), local_results.begin(), local_results.end());
   }
 
   return results;