icebug 13.4__tar.gz → 13.5__tar.gz

{icebug-13.4/icebug.egg-info → icebug-13.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icebug
-Version: 13.4
+Version: 13.5
 Summary: High performance graph analytics backed by read-only memory
 Home-page: https://github.com/Ladybug-Memory/icebug
 Download-URL: https://pypi.python.org/pypi/icebug
@@ -87,9 +87,9 @@ Dynamic: platform
 
 <p align="center">
   <img width="60%" src="docs/logo/logo_color.jpg" alt="Icebug - Frozen Graph Analytics"><br>
-  <a href="https://github.com/Ladybug-Memory/icebug/actions"><img src="https://github.com/Ladybug-Memory/icebug/workflows/build/badge.svg"></a>
+  <a href="https://github.com/Ladybug-Memory/icebug/actions/workflows/ci-matrix.yml"><img src="https://github.com/Ladybug-Memory/icebug/actions/workflows/ci-matrix.yml/badge.svg?branch=main"></a>
   <a href="https://badge.fury.io/py/icebug"><img src="https://badge.fury.io/py/icebug.svg"></a>
-  <a href="https://coveralls.io/github/Ladybug-Memory/icebug?branch=master"><img src="https://coveralls.io/repos/github/Ladybug-Memory/icebug/badge.svg?branch=master"></a>
+  <a href="https://coveralls.io/github/Ladybug-Memory/icebug?branch=main"><img src="https://coveralls.io/repos/github/Ladybug-Memory/icebug/badge.svg?branch=main"></a>
   <a href="https://mybinder.org/v2/gh/networkit/networkit/master?urlpath=lab/tree/notebooks/User-Guide.ipynb"><img src="https://mybinder.org/badge_logo.svg"></a>
 </p>
 

{icebug-13.4 → icebug-13.5}/README.md

@@ -1,8 +1,8 @@
 <p align="center">
   <img width="60%" src="docs/logo/logo_color.jpg" alt="Icebug - Frozen Graph Analytics"><br>
-  <a href="https://github.com/Ladybug-Memory/icebug/actions"><img src="https://github.com/Ladybug-Memory/icebug/workflows/build/badge.svg"></a>
+  <a href="https://github.com/Ladybug-Memory/icebug/actions/workflows/ci-matrix.yml"><img src="https://github.com/Ladybug-Memory/icebug/actions/workflows/ci-matrix.yml/badge.svg?branch=main"></a>
   <a href="https://badge.fury.io/py/icebug"><img src="https://badge.fury.io/py/icebug.svg"></a>
-  <a href="https://coveralls.io/github/Ladybug-Memory/icebug?branch=master"><img src="https://coveralls.io/repos/github/Ladybug-Memory/icebug/badge.svg?branch=master"></a>
+  <a href="https://coveralls.io/github/Ladybug-Memory/icebug?branch=main"><img src="https://coveralls.io/repos/github/Ladybug-Memory/icebug/badge.svg?branch=main"></a>
   <a href="https://mybinder.org/v2/gh/networkit/networkit/master?urlpath=lab/tree/notebooks/User-Guide.ipynb"><img src="https://mybinder.org/badge_logo.svg"></a>
 </p>
 

{icebug-13.4 → icebug-13.5/icebug.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icebug
-Version: 13.4
+Version: 13.5
 Summary: High performance graph analytics backed by read-only memory
 Home-page: https://github.com/Ladybug-Memory/icebug
 Download-URL: https://pypi.python.org/pypi/icebug
@@ -87,9 +87,9 @@ Dynamic: platform
 
 <p align="center">
   <img width="60%" src="docs/logo/logo_color.jpg" alt="Icebug - Frozen Graph Analytics"><br>
-  <a href="https://github.com/Ladybug-Memory/icebug/actions"><img src="https://github.com/Ladybug-Memory/icebug/workflows/build/badge.svg"></a>
+  <a href="https://github.com/Ladybug-Memory/icebug/actions/workflows/ci-matrix.yml"><img src="https://github.com/Ladybug-Memory/icebug/actions/workflows/ci-matrix.yml/badge.svg?branch=main"></a>
   <a href="https://badge.fury.io/py/icebug"><img src="https://badge.fury.io/py/icebug.svg"></a>
-  <a href="https://coveralls.io/github/Ladybug-Memory/icebug?branch=master"><img src="https://coveralls.io/repos/github/Ladybug-Memory/icebug/badge.svg?branch=master"></a>
+  <a href="https://coveralls.io/github/Ladybug-Memory/icebug?branch=main"><img src="https://coveralls.io/repos/github/Ladybug-Memory/icebug/badge.svg?branch=main"></a>
   <a href="https://mybinder.org/v2/gh/networkit/networkit/master?urlpath=lab/tree/notebooks/User-Guide.ipynb"><img src="https://mybinder.org/badge_logo.svg"></a>
 </p>
 

{icebug-13.4 → icebug-13.5}/icebug.egg-info/SOURCES.txt

@@ -397,6 +397,7 @@ include/networkit/auxiliary/FlatMap.hpp
 include/networkit/auxiliary/FlatMap.tpp
 include/networkit/auxiliary/FunctionTraits.hpp
 include/networkit/auxiliary/HashUtils.hpp
+include/networkit/auxiliary/HierarchicalCoreBuckets.hpp
 include/networkit/auxiliary/IncrementalUniformRandomSelector.hpp
 include/networkit/auxiliary/Log.hpp
 include/networkit/auxiliary/MissingMath.hpp
@@ -456,6 +457,7 @@ include/networkit/centrality/LocalClusteringCoefficient.hpp
 include/networkit/centrality/LocalPartitionCoverage.hpp
 include/networkit/centrality/LocalSquareClusteringCoefficient.hpp
 include/networkit/centrality/PageRank.hpp
+include/networkit/centrality/ParallelCoreDecomposition.hpp
 include/networkit/centrality/PermanenceCentrality.hpp
 include/networkit/centrality/Sfigality.hpp
 include/networkit/centrality/SpanningEdgeCentrality.hpp
@@ -920,6 +922,7 @@ networkit/cpp/centrality/Centrality.cpp
 networkit/cpp/centrality/Closeness.cpp
 networkit/cpp/centrality/ComplexPaths.cpp
 networkit/cpp/centrality/CoreDecomposition.cpp
+networkit/cpp/centrality/CoreSampler.hpp
 networkit/cpp/centrality/DegreeCentrality.cpp
 networkit/cpp/centrality/DynApproxBetweenness.cpp
 networkit/cpp/centrality/DynBetweenness.cpp
@@ -947,6 +950,8 @@ networkit/cpp/centrality/LocalClusteringCoefficient.cpp
 networkit/cpp/centrality/LocalPartitionCoverage.cpp
 networkit/cpp/centrality/LocalSquareClusteringCoefficient.cpp
 networkit/cpp/centrality/PageRank.cpp
+networkit/cpp/centrality/ParallelCoreDecomposition.cpp
+networkit/cpp/centrality/ParallelCoreDecompositionInternal.hpp
 networkit/cpp/centrality/PermanenceCentrality.cpp
 networkit/cpp/centrality/Sfigality.cpp
 networkit/cpp/centrality/SpanningEdgeCentrality.cpp

icebug-13.5/include/networkit/auxiliary/HierarchicalCoreBuckets.hpp

@@ -0,0 +1,72 @@
+#ifndef NETWORKIT_AUXILIARY_HIERARCHICAL_CORE_BUCKETS_HPP_
+#define NETWORKIT_AUXILIARY_HIERARCHICAL_CORE_BUCKETS_HPP_
+
+#include <array>
+#include <vector>
+#include <networkit/Globals.hpp>
+
+namespace Aux {
+namespace CoreBuckets {
+/**
+ * @ingroup auxiliary
+ * Bucket routing for online core peeling: eight exact levels and logarithmic intervals.
+ * Callers own synchronization, stale-entry filtering and intermediate redistribution.
+ * Base levels are multiples of eight; routed degrees must belong to the same aligned
+ * 512-level window as the base. The peeling engine advances that window separately.
+ */
+constexpr NetworKit::count kLog2SingleBuckets = 3;
+constexpr NetworKit::count kNumSingleBuckets = NetworKit::count{1} << kLog2SingleBuckets;
+constexpr NetworKit::count kNumIntermediateBuckets = 6;
+constexpr NetworKit::count kNumBuckets = kNumSingleBuckets + kNumIntermediateBuckets;
+constexpr NetworKit::count kBucketMask = kNumSingleBuckets - 1;
+constexpr NetworKit::count kBucketStride = kNumSingleBuckets << kNumIntermediateBuckets;
+
+using Storage = std::array<std::vector<NetworKit::node>, kNumBuckets>;
+inline NetworKit::count mostSignificantBit(NetworKit::count value) {
+    NetworKit::count result = 0;
+    while (value >>= 1) {
+        ++result;
+    }
+    return result;
+}
+
+template <typename Buckets>
+/** Insert a candidate at its current degree; candidates outside the window are ignored. */
+void add(Buckets &target, NetworKit::node u, NetworKit::count degree, NetworKit::count baseLevel) {
+    if (degree < baseLevel || degree >= baseLevel + kBucketStride) {
+        return;
+    }
+
+    if (degree < baseLevel + kNumSingleBuckets) {
+        target[degree & kBucketMask].push_back(u);
+        return;
+    }
+
+    const NetworKit::count differingBit = mostSignificantBit(degree ^ baseLevel);
+    const NetworKit::count bucket = kNumSingleBuckets + differingBit - kLog2SingleBuckets;
+    target[bucket].push_back(u);
+}
+
+template <typename Buckets>
+/** Record a decrement only when it crosses a bucket boundary (or reaches an exact bucket). */
+void move(Buckets &target, NetworKit::node u, NetworKit::count degree, NetworKit::count baseLevel) {
+    if (degree < baseLevel || degree >= baseLevel + kBucketStride) {
+        return;
+    }
+
+    if (degree < baseLevel + kNumSingleBuckets) {
+        target[degree & kBucketMask].push_back(u);
+        return;
+    }
+
+    const NetworKit::count differingBit = mostSignificantBit(degree ^ baseLevel);
+    const NetworKit::count previousDifferingBit = mostSignificantBit((degree + 1) ^ baseLevel);
+    if (differingBit != previousDifferingBit) {
+        const NetworKit::count bucket = kNumSingleBuckets + differingBit - kLog2SingleBuckets;
+        target[bucket].push_back(u);
+    }
+}
+
+} // namespace CoreBuckets
+} // namespace Aux
+#endif // NETWORKIT_AUXILIARY_HIERARCHICAL_CORE_BUCKETS_HPP_

icebug-13.5/include/networkit/centrality/ParallelCoreDecomposition.hpp

@@ -0,0 +1,92 @@
+/*
+ * ParallelCoreDecomposition.hpp
+ *
+ * Exact shared-memory k-core decomposition based on the SIGMOD 2025 algorithm.
+ */
+
+#ifndef NETWORKIT_CENTRALITY_PARALLEL_CORE_DECOMPOSITION_HPP_
+#define NETWORKIT_CENTRALITY_PARALLEL_CORE_DECOMPOSITION_HPP_
+
+#include <vector>
+#include <networkit/centrality/Centrality.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Cover.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ * Computes an exact k-core decomposition in parallel.
+ *
+ * The implementation is based on the online peeling framework, hierarchical bucketing structure,
+ * probabilistic high-degree sampling, and vertical granularity control described by Liu et al. in
+ * "Parallel k-Core Decomposition: Theory and Practice" (Proc. ACM Manag. Data 3, 3, SIGMOD
+ * 2025). Sampling errors are detected and cause a restart without sampling, making the
+ * implementation Las Vegas rather than Monte Carlo.
+ * Low-average-degree graphs with maximum degree below the edge-parallelism threshold use
+ * the existing ParK peeling implementation to avoid sampling/bucketing overhead. Selection
+ * is automatic and preserves exact core numbers and normalization semantics.
+ *
+ * The input graph must be undirected, must not contain self-loops, and must have continuous node
+ * ids. Both GraphW and zero-copy CSR-backed GraphR inputs are supported.
+ */
+class ParallelCoreDecomposition final : public Centrality {
+public:
+    /**
+     * Create a parallel core decomposition for @a G.
+     *
+     * @param G The undirected input graph.
+     * @param normalized If @c true, divide scores by the maximum degree. Partitions and
+     * covers always use the original integer core numbers.
+     * @param useSampling If @c true, use the paper's high-degree sampling optimization.
+     */
+    ParallelCoreDecomposition(const Graph &G, bool normalized = false, bool useSampling = true);
+
+    /** Compute the core number of every node. */
+    void run() override;
+
+    /**
+     * Get the nested k-cores as a cover.
+     *
+     * @return The k-cores as a Cover.
+     */
+    Cover getCover() const;
+
+    /**
+     * Get the k-shells as a partition.
+     *
+     * @return The k-shells as a Partition.
+     */
+    Partition getPartition() const;
+
+    /** @return The maximum core number. */
+    index maxCoreNumber() const;
+
+    /**
+     * Get the number of sampling-error recovery restarts performed by the last run.
+     *
+     * @return Zero unless a sampling validation failed and the algorithm restarted without
+     * sampling.
+     */
+    count numberOfRestarts() const;
+
+    /**
+     * @return The theoretical maximum score: 1 for normalized scores, n - 1 otherwise.
+     * Empty and single-node graphs return 0.
+     */
+    double maximum() override;
+
+private:
+    index coreNumber(node u) const;
+
+    // Preserve integer membership only when scoreData is normalized.
+    std::vector<index> coreNumbers_;
+    index maxCore{0};
+    bool useSampling;
+    count restarts{0};
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_PARALLEL_CORE_DECOMPOSITION_HPP_

{icebug-13.4 → icebug-13.5}/include/networkit/coarsening/CoarsenedGraphView.hpp

@@ -7,6 +7,7 @@
 #ifndef NETWORKIT_COARSENING_COARSENED_GRAPH_VIEW_HPP_
 #define NETWORKIT_COARSENING_COARSENED_GRAPH_VIEW_HPP_
 
+#include <mutex>
 #include <utility>
 #include <vector>
 
@@ -258,6 +259,36 @@ public:
      */
     const std::vector<node> &getOriginalNodes(node supernode) const;
 
+    /**
+     * Release the calling thread's computeNeighbors() scratch buffer (capacity included).
+     * Call at the end of a move/refine phase so a giant-supernode high-water mark from one
+     * level cannot leak into the next.
+     */
+    static void releaseThreadScratch();
+
+    /**
+     * Adaptive eager neighbor cache (InducedSubgraphView-style eager-vs-lazy tradeoff).
+     *
+     * The view itself is immutable, so a cached aggregation never invalidates within the
+     * view's lifetime. Aggregation work for a supernode scales with the sum of its members'
+     * base degrees; recomputing that on every visit (lazy) is wasteful for hot supernodes
+     * but cheaper than storing it for cold ones. ensureEagerCache() materializes entries
+     * whose estimated work exceeds eagerNeighborThreshold (in staged edge-endpoints),
+     * while computeNeighbors() promotes any other supernode to the cache once its observed
+     * work crosses the same threshold. Supernodes below the threshold stay lazy.
+     *
+     * Set to 0 to cache everything (a full materialization, ~ParallelLeiden's memory
+     * profile) or to none to disable caching entirely (pure lazy, status quo ante).
+     * Tune via the NETWORKIT_LEIDEN_EAGER_THRESHOLD environment variable.
+     */
+    void ensureEagerCache();
+
+    /// Aggregate work threshold for eager caching / lazy promotion (staged edge-endpoints).
+    size_t eagerNeighborThreshold = 2048;
+
+    /// Number of cached supernode neighborhoods (for observability / tests).
+    count numberOfCachedNeighborhoods() const;
+
 private:
     const Graph &originalGraph;
     std::vector<node> nodeMapping;                      // original_node -> supernode
@@ -265,9 +296,23 @@ private:
     count numSupernodes;
 
     /**
-     * Compute the aggregated neighbors of a supernode (on demand, no caching)
+     * Compute the aggregated neighbors of a supernode, consulting / populating the
+     * adaptive cache as described at ensureEagerCache(). Thread-safe.
      */
     std::vector<std::pair<node, edgeweight>> computeNeighbors(node supernode) const;
+
+    // Estimated aggregation work for @a supernode: sum of its members' base degrees.
+    size_t aggregationWork(node supernode) const;
+
+    // Aggregate without consulting the cache; stores the staged pair count in @a workOut.
+    std::vector<std::pair<node, edgeweight>> aggregateNeighbors(node supernode,
+                                                                size_t &workOut) const;
+
+    mutable std::vector<std::vector<std::pair<node, edgeweight>>> neighborCache_;
+    mutable std::vector<char> neighborCached_;
+    mutable std::vector<std::mutex> cacheMutexes_;
+
+    void initCache();
 };
 
 static_assert(GraphLike<CoarsenedGraphView>,

{icebug-13.4 → icebug-13.5}/networkit/__init__.py

@@ -30,7 +30,7 @@ __credits__ = ["Eugenio Angriman", "Lukas Barth", "Miriam Beddig", "Elisabetta B
     "Moritz v. Looz", "Yassine Marrakchi", "Henning Meyerhenke", "Manuel Penschuck", "Lucas Archimedes Gregorio Henr Petersen", "Marcel Radermacher", "Klara Reichard", \
 	"Marvin Ritter", "Aleksejs Sazonovs", "Arun Sharma", "Hung Tran", "Alexander van der Grinten", "Florian Weber", "Michael Wegner", "Jörg Weisbarth"]
 __license__ = "MIT"
-__version__ = "13.4"
+__version__ = "13.5"
 
 # standard library modules
 import csv