Removes unused benchmark infra: rapids-pytest-benchmark and asvdb (#4865

)

This PR removes `rapids-pytest-benchmark` and references to one of its dependencies, `asvdb`.

These packages were used for adding GPU memory usage to pytest-benchmark output and for updating ASV output files with pytest-benchmark results so the ASV front end can be used on pytest-benchmark suites.

Since we're not using the ASV frontend anymore, and the GPU memory usage mechanism used by rapids-pytest-benchmark is outdated and unmaintained (and slower than other tools available), we're removing references to these packages.

cc @vyasr @robertmaynard

Authors:
  - Rick Ratzel (https://github.com/rlratzel)
  - Ralph Liu (https://github.com/nv-rliu)

Approvers:
  - Don Acosta (https://github.com/acostadon)
  - Alex Barghi (https://github.com/alexbarghi-nv)

URL: #4865

benchmarks/cugraph-dgl/pytest-based/bench_cugraph_dgl_uniform_neighbor_sample.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2025, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -22,10 +22,6 @@
 import numpy as np
 import cupy as cp
 
-# Facing issues with rapids-pytest-benchmark plugin
-# pytest-benchmark.
-import pytest_benchmark
-
 from cugraph.generators import rmat
 from cugraph.experimental import datasets
 from cugraph_benchmarking import params

benchmarks/cugraph-service/pytest-based/bench_cgs_uniform_neighbor_sample.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2025, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -18,18 +18,6 @@
 import pytest
 import numpy as np
 
-# If the rapids-pytest-benchmark plugin is installed, the "gpubenchmark"
-# fixture will be available automatically. Check that this fixture is available
-# by trying to import rapids_pytest_benchmark, and if that fails, set
-# "gpubenchmark" to the standard "benchmark" fixture provided by
-# pytest-benchmark.
-try:
-    import rapids_pytest_benchmark  # noqa: F401
-except ImportError:
-    import pytest_benchmark
-
-    gpubenchmark = pytest_benchmark.plugin.benchmark
-
 from cugraph_service_client import CugraphServiceClient
 from cugraph_service_client.exceptions import CugraphServiceError
 from cugraph_service_client import RemoteGraph
@@ -178,7 +166,7 @@ def remote_graph_objs(request):
     "with_replacement", [False], ids=lambda v: f"with_replacement={v}"
 )
 def bench_cgs_uniform_neighbor_sample(
-    gpubenchmark, remote_graph_objs, batch_size, fanout, with_replacement
+    benchmark, remote_graph_objs, batch_size, fanout, with_replacement
 ):
     (G, num_verts, uniform_neighbor_sample_func) = remote_graph_objs
 
@@ -188,7 +176,7 @@ def bench_cgs_uniform_neighbor_sample(
         )
     # print(f"\n{uns_args}")
     # FIXME: uniform_neighbor_sample cannot take a np.ndarray for start_list
-    result = gpubenchmark(
+    result = benchmark(
         uniform_neighbor_sample_func,
         G,
         start_list=uns_args["start_list"],

benchmarks/cugraph/pytest-based/README.md

@@ -13,9 +13,6 @@ directory under the root of the `cuGraph` source tree.
 * cugraph built and installed (or `cugraph` sources and built C++ extensions
   available on `PYTHONPATH`)
 
-* rapids-pytest-benchmark pytest plugin (`conda install -c rapidsai
-  rapids-pytest-benchmark`)
-
 * The benchmark datasets downloaded and installed in <cugraph>/datasets. Run the
 script below from the <cugraph>/datasets directory:
 ```
@@ -25,8 +22,7 @@ cd <cugraph>/datasets
 
 ## Usage (Python)
 ### Python
-* Run `pytest --help` (with the rapids-pytest-benchmark plugin installed) for
-  the full list of options
+* Run `pytest --help` for the full list of options
 
 * See also the `pytest.ini` file in this directory for examples of how to enable
   options by default and define marks
@@ -44,9 +40,9 @@ _**NOTE: these commands must be run from the `<cugraph_root>/benchmarks` directo
 (rapids) user@machine:/cugraph/benchmarks> pytest -x
 ```
 
-* Run all the benchmarks but do not reinit RMM with different configurations
+* Run all the benchmarks and allow RMM to reinit with different configurations
 ```
-(rapids) user@machine:/cugraph/benchmarks> pytest --no-rmm-reinit
+(rapids) user@machine:/cugraph/benchmarks> pytest --allow-rmm-reinit
 ```
 
 * Show what benchmarks would be run with the given options, but do not run them

benchmarks/cugraph/pytest-based/bench_algos.py

@@ -13,25 +13,6 @@
 
 import pytest
 import numpy as np
-import pytest_benchmark
-
-# FIXME: Remove this when rapids_pytest_benchmark.gpubenchmark is available
-# everywhere
-try:
-    from rapids_pytest_benchmark import setFixtureParamNames
-except ImportError:
-    print(
-        "\n\nWARNING: rapids_pytest_benchmark is not installed, "
-        "falling back to pytest_benchmark fixtures.\n"
-    )
-
-    # if rapids_pytest_benchmark is not available, just perfrom time-only
-    # benchmarking and replace the util functions with nops
-    gpubenchmark = pytest_benchmark.plugin.benchmark
-
-    def setFixtureParamNames(*args, **kwargs):
-        pass
-
 
 import rmm
 import dask_cudf
@@ -50,6 +31,7 @@ def setFixtureParamNames(*args, **kwargs):
     pool_allocator,
 )
 
+
 # duck-type compatible Dataset for RMAT data
 class RmatDataset:
     def __init__(self, scale=4, edgefactor=2, mg=False):
@@ -198,11 +180,6 @@ def reinitRMM(managed_mem, pool_alloc):
 
 @pytest.fixture(scope="module", params=rmm_fixture_params)
 def rmm_config(request):
-    # Since parameterized fixtures do not assign param names to param values,
-    # manually call the helper to do so. Ensure the order of the name list
-    # passed to it matches if there are >1 params.
-    # If the request only contains n params, only the first n names are set.
-    setFixtureParamNames(request, ["managed_mem", "pool_allocator"])
     reinitRMM(request.param[0], request.param[1])
 
 
@@ -215,7 +192,6 @@ def dataset(request, rmm_config):
     tests/fixtures are done with the Dataset, it has the Dask cluster and
     client torn down (if MG) and all data loaded is freed.
     """
-    setFixtureParamNames(request, ["dataset"])
     dataset = request.param[0]
     client = cluster = None
     # For now, only RmatDataset instanaces support MG and have a "mg" attr.
@@ -283,8 +259,8 @@ def get_vertex_pairs(G, num_vertices=10):
 
 ###############################################################################
 # Benchmarks
-def bench_create_graph(gpubenchmark, edgelist):
-    gpubenchmark(
+def bench_create_graph(benchmark, edgelist):
+    benchmark(
         cugraph.from_cudf_edgelist,
         edgelist,
         source="src",
@@ -298,8 +274,8 @@ def bench_create_graph(gpubenchmark, edgelist):
 # results in thousands of rounds before the default threshold is met, so lower
 # the max_time for this benchmark.
 @pytest.mark.benchmark(warmup=True, warmup_iterations=10, max_time=0.005)
-def bench_create_digraph(gpubenchmark, edgelist):
-    gpubenchmark(
+def bench_create_digraph(benchmark, edgelist):
+    benchmark(
         cugraph.from_cudf_edgelist,
         edgelist,
         source="src",
@@ -309,26 +285,26 @@ def bench_create_digraph(gpubenchmark, edgelist):
     )
 
 
-def bench_renumber(gpubenchmark, edgelist):
-    gpubenchmark(NumberMap.renumber, edgelist, "src", "dst")
+def bench_renumber(benchmark, edgelist):
+    benchmark(NumberMap.renumber, edgelist, "src", "dst")
 
 
-def bench_pagerank(gpubenchmark, transposed_graph):
+def bench_pagerank(benchmark, transposed_graph):
     pagerank = (
         dask_cugraph.pagerank
         if is_graph_distributed(transposed_graph)
         else cugraph.pagerank
     )
-    gpubenchmark(pagerank, transposed_graph)
+    benchmark(pagerank, transposed_graph)
 
 
-def bench_bfs(gpubenchmark, graph):
+def bench_bfs(benchmark, graph):
     bfs = dask_cugraph.bfs if is_graph_distributed(graph) else cugraph.bfs
     start = graph.edgelist.edgelist_df["src"][0]
-    gpubenchmark(bfs, graph, start)
+    benchmark(bfs, graph, start)
 
 
-def bench_sssp(gpubenchmark, graph):
+def bench_sssp(benchmark, graph):
     if not graph.is_weighted():
         pytest.skip("Skipping: Unweighted Graphs are not supported by SSSP")
 
@@ -340,102 +316,102 @@ def bench_sssp(gpubenchmark, graph):
 
     start = start_col.to_arrow().to_pylist()[0]
 
-    gpubenchmark(sssp, graph, start)
+    benchmark(sssp, graph, start)
 
 
-def bench_jaccard(gpubenchmark, unweighted_graph):
+def bench_jaccard(benchmark, unweighted_graph):
     G = unweighted_graph
     # algo cannot compute neighbors on all nodes without running into OOM
     # this is why we will call jaccard on a subset of nodes
     vert_pairs = get_vertex_pairs(G)
     jaccard = dask_cugraph.jaccard if is_graph_distributed(G) else cugraph.jaccard
-    gpubenchmark(jaccard, G, vert_pairs)
+    benchmark(jaccard, G, vert_pairs)
 
 
-def bench_sorensen(gpubenchmark, unweighted_graph):
+def bench_sorensen(benchmark, unweighted_graph):
     G = unweighted_graph
     # algo cannot compute neighbors on all nodes without running into OOM
     # this is why we will call sorensen on a subset of nodes
     vert_pairs = get_vertex_pairs(G)
     sorensen = dask_cugraph.sorensen if is_graph_distributed(G) else cugraph.sorensen
-    gpubenchmark(sorensen, G, vert_pairs)
+    benchmark(sorensen, G, vert_pairs)
 
 
-def bench_louvain(gpubenchmark, graph):
+def bench_louvain(benchmark, graph):
     louvain = dask_cugraph.louvain if is_graph_distributed(graph) else cugraph.louvain
-    gpubenchmark(louvain, graph)
+    benchmark(louvain, graph)
 
 
-def bench_weakly_connected_components(gpubenchmark, graph):
+def bench_weakly_connected_components(benchmark, graph):
     if is_graph_distributed(graph):
         pytest.skip("distributed graphs are not supported")
     if graph.is_directed():
         G = graph.to_undirected()
     else:
         G = graph
-    gpubenchmark(cugraph.weakly_connected_components, G)
+    benchmark(cugraph.weakly_connected_components, G)
 
 
-def bench_overlap(gpubenchmark, unweighted_graph):
+def bench_overlap(benchmark, unweighted_graph):
     G = unweighted_graph
     # algo cannot compute neighbors on all nodes without running into OOM
     # this is why we will call sorensen on a subset of nodes
     vertex_pairs = get_vertex_pairs(G)
     overlap = dask_cugraph.overlap if is_graph_distributed(G) else cugraph.overlap
-    gpubenchmark(overlap, G, vertex_pairs)
+    benchmark(overlap, G, vertex_pairs)
 
 
-def bench_triangle_count(gpubenchmark, graph):
+def bench_triangle_count(benchmark, graph):
     tc = (
         dask_cugraph.triangle_count
         if is_graph_distributed(graph)
         else cugraph.triangle_count
     )
-    gpubenchmark(tc, graph)
+    benchmark(tc, graph)
 
 
-def bench_spectralBalancedCutClustering(gpubenchmark, graph):
+def bench_spectralBalancedCutClustering(benchmark, graph):
     if is_graph_distributed(graph):
         pytest.skip("distributed graphs are not supported")
-    gpubenchmark(cugraph.spectralBalancedCutClustering, graph, 2)
+    benchmark(cugraph.spectralBalancedCutClustering, graph, 2)
 
 
 @pytest.mark.skip(reason="Need to guarantee graph has weights, " "not doing that yet")
-def bench_spectralModularityMaximizationClustering(gpubenchmark, graph):
+def bench_spectralModularityMaximizationClustering(benchmark, graph):
     smmc = (
         dask_cugraph.spectralModularityMaximizationClustering
         if is_graph_distributed(graph)
         else cugraph.spectralModularityMaximizationClustering
     )
-    gpubenchmark(smmc, graph, 2)
+    benchmark(smmc, graph, 2)
 
 
-def bench_graph_degree(gpubenchmark, graph):
-    gpubenchmark(graph.degree)
+def bench_graph_degree(benchmark, graph):
+    benchmark(graph.degree)
 
 
-def bench_graph_degrees(gpubenchmark, graph):
+def bench_graph_degrees(benchmark, graph):
     if is_graph_distributed(graph):
         pytest.skip("distributed graphs are not supported")
-    gpubenchmark(graph.degrees)
+    benchmark(graph.degrees)
 
 
-def bench_betweenness_centrality(gpubenchmark, graph):
+def bench_betweenness_centrality(benchmark, graph):
     bc = (
         dask_cugraph.betweenness_centrality
         if is_graph_distributed(graph)
         else cugraph.betweenness_centrality
     )
-    gpubenchmark(bc, graph, k=10, random_state=123)
+    benchmark(bc, graph, k=10, random_state=123)
 
 
-def bench_edge_betweenness_centrality(gpubenchmark, graph):
+def bench_edge_betweenness_centrality(benchmark, graph):
     if is_graph_distributed(graph):
         pytest.skip("distributed graphs are not supported")
-    gpubenchmark(cugraph.edge_betweenness_centrality, graph, k=10, seed=123)
+    benchmark(cugraph.edge_betweenness_centrality, graph, k=10, seed=123)
 
 
-def bench_uniform_neighbor_sample(gpubenchmark, graph):
+def bench_uniform_neighbor_sample(benchmark, graph):
     uns = (
         dask_cugraph.uniform_neighbor_sample
         if is_graph_distributed(graph)
@@ -455,13 +431,13 @@ def bench_uniform_neighbor_sample(gpubenchmark, graph):
         start_list = start_list.compute()
 
     fanout_vals = [5, 5, 5]
-    gpubenchmark(uns, graph, start_list=start_list, fanout_vals=fanout_vals)
+    benchmark(uns, graph, start_list=start_list, fanout_vals=fanout_vals)
 
 
-def bench_egonet(gpubenchmark, graph):
+def bench_egonet(benchmark, graph):
     egonet = (
         dask_cugraph.ego_graph if is_graph_distributed(graph) else cugraph.ego_graph
     )
     n = 1
     radius = 2
-    gpubenchmark(egonet, graph, n, radius=radius)
+    benchmark(egonet, graph, n, radius=radius)

benchmarks/cugraph/pytest-based/bench_cugraph_uniform_neighbor_sample.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2024, NVIDIA CORPORATION.
+# Copyright (c) 2022-2025, NVIDIA CORPORATION.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -22,18 +22,6 @@
 import dask_cudf
 import rmm
 
-# If the rapids-pytest-benchmark plugin is installed, the "gpubenchmark"
-# fixture will be available automatically. Check that this fixture is available
-# by trying to import rapids_pytest_benchmark, and if that fails, set
-# "gpubenchmark" to the standard "benchmark" fixture provided by
-# pytest-benchmark.
-try:
-    import rapids_pytest_benchmark  # noqa: F401
-except ImportError:
-    import pytest_benchmark
-
-    gpubenchmark = pytest_benchmark.plugin.benchmark
-
 from cugraph import (
     MultiGraph,
     uniform_neighbor_sample,
@@ -271,7 +259,7 @@ def uns_func(*args, **kwargs):
     "with_replacement", [False], ids=lambda v: f"with_replacement={v}"
 )
 def bench_cugraph_uniform_neighbor_sample(
-    gpubenchmark, graph_objs, batch_size, fanout, with_replacement
+    benchmark, graph_objs, batch_size, fanout, with_replacement
 ):
     (G, num_verts, uniform_neighbor_sample_func) = graph_objs
 
@@ -281,7 +269,7 @@ def bench_cugraph_uniform_neighbor_sample(
         )
     # print(f"\n{uns_args}")
     # FIXME: uniform_neighbor_sample cannot take a np.ndarray for start_list
-    result = gpubenchmark(
+    result = benchmark(
         uniform_neighbor_sample_func,
         G,
         start_list=uns_args["start_list"],