edsger 0.1.3__tar.gz → 0.1.4__tar.gz

{edsger-0.1.3 → edsger-0.1.4}/.github/workflows/docs.yml

@@ -1,10 +1,8 @@
 name: Documentation
 
 on:
-  push:
-    branches: [ release ]
-  pull_request:
-    branches: [ release ]
+  release:
+    types: [created]
 
 jobs:
   build-docs:
@@ -34,8 +32,8 @@ jobs:
         name: documentation-html
         path: docs/build/html/
     
-    - name: Deploy to GitHub Pages (on release branch)
-      if: github.ref == 'refs/heads/release' && github.event_name == 'push'
+    - name: Deploy to GitHub Pages
+      if: github.event_name == 'release'
       uses: peaceiris/actions-gh-pages@v4
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}

{edsger-0.1.3 → edsger-0.1.4}/.github/workflows/publish.yml

@@ -1,9 +1,8 @@
 name: ci-publish  # Publish Python distribution to PyPI
 
 on:
-  push:
-    tags:
-      - 'v[0-9]+.[0-9]+.[0-9]+'
+  release:
+    types: [created]
 
 jobs:
 
@@ -49,7 +48,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-2019, macos-13, macos-14]
+        os: [ubuntu-latest, windows-2022, macos-13, macos-14]
 
     steps:
       - uses: actions/checkout@v4

{edsger-0.1.3 → edsger-0.1.4}/.github/workflows/tests.yml

@@ -1,9 +1,8 @@
 name: Run tests and upload coverage
 
 on:
-  push:
-    branches: 
-      - release
+  release:
+    types: [created]
 
 jobs:
   test:
@@ -27,16 +26,27 @@ jobs:
         python -m pip install --upgrade pip
         pip install -r requirements-dev.txt
         pip install .
+    - name: Reinstall package with coverage support
+      if: matrix.os == 'ubuntu-22.04' && matrix.python-version == '3.11'
+      run: |
+        pip uninstall -y edsger
+        CYTHON_TRACE=1 pip install -e .
     - name: Format Python code with black
       run: |
         black --check --diff .
     - name: Lint Cython code
       run: |
         cython-lint src/edsger/commons.pyx src/edsger/dijkstra.pyx src/edsger/path_tracking.pyx src/edsger/pq_4ary_dec_0b.pyx src/edsger/spiess_florian.pyx src/edsger/star.pyx src/edsger/commons.pxd src/edsger/pq_4ary_dec_0b.pxd
-    - name: Run tests
+    - name: Run tests with coverage
+      if: matrix.os == 'ubuntu-22.04' && matrix.python-version == '3.11'
       run: |
         pytest --cov=src/edsger --cov-branch --cov-report=xml tests/
+    - name: Run tests without coverage
+      if: matrix.os != 'ubuntu-22.04' || matrix.python-version != '3.11'
+      run: |
+        pytest tests/
     - name: Upload results to Codecov
+      if: matrix.os == 'ubuntu-22.04' && matrix.python-version == '3.11'
       uses: codecov/codecov-action@v5
       with:
         token: ${{ secrets.CODECOV_TOKEN }}

{edsger-0.1.3 → edsger-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edsger
-Version: 0.1.3
+Version: 0.1.4
 Summary: Graph algorithms in Cython.
 Author-email: François Pacull <francois.pacull@architecture-performance.fr>
 Maintainer-email: François Pacull <francois.pacull@architecture-performance.fr>
@@ -42,6 +42,7 @@ Dynamic: license-file
 
 ![Tests Status](https://github.com/aetperf/edsger/actions/workflows/tests.yml/badge.svg?branch=release)
 [![codecov](https://codecov.io/gh/aetperf/edsger/branch/release/graph/badge.svg)](https://codecov.io/gh/aetperf/edsger)
+[![Documentation Status](https://readthedocs.org/projects/edsger/badge/?version=latest)](https://edsger.readthedocs.io/en/latest/?badge=latest)
 [![PyPI version](https://img.shields.io/pypi/v/edsger.svg?refresh=1)](https://pypi.org/project/edsger/)
 [![Downloads](https://static.pepy.tech/badge/edsger)](https://pepy.tech/project/edsger)
 [![Python 3.9 | 3.10 | 3.11 | 3.12 | 3.13](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://pypi.org/project/edsger/)
@@ -97,14 +98,20 @@ print("Shortest paths:", shortest_paths)
 
 We get the shortest paths from the source node 0 to all other nodes in the graph. The output is an array with the shortest path length to each node. A path length is the sum of the weights of the edges in the path.
 
+## Installation
+
+### Standard Installation
+
+```bash
+pip install edsger
+```
+
 ## Why Use Edsger?
 
-Edsger is designed to be **dataframe-friendly**, providing seamless integration with pandas workflows for graph algorithms. Also it is rather efficient. Our benchmarks on the USA road network (23.9M vertices, 57.7M edges) demonstrate nice performance:
+Edsger is designed to be **dataframe-friendly**, providing seamless integration with pandas workflows for graph algorithms. Also it is rather efficient on Linux. Our benchmarks on the USA road network (23.9M vertices, 57.7M edges) demonstrate nice performance:
 
 <img src="https://raw.githubusercontent.com/aetperf/edsger/release/docs/source/assets/dijkstra_benchmark_comparison.png" alt="Dijkstra Performance Comparison" width="700">
 
-*Benchmark performed on Intel i9-12900H Linux laptop.*
-
 ## Contributing
 
 We welcome contributions to the Edsger library. If you have any suggestions, bug reports, or feature requests, please open an issue on our [GitHub repository](https://github.com/aetperf/Edsger).

{edsger-0.1.3 → edsger-0.1.4}/README.md

@@ -1,6 +1,7 @@
 
 ![Tests Status](https://github.com/aetperf/edsger/actions/workflows/tests.yml/badge.svg?branch=release)
 [![codecov](https://codecov.io/gh/aetperf/edsger/branch/release/graph/badge.svg)](https://codecov.io/gh/aetperf/edsger)
+[![Documentation Status](https://readthedocs.org/projects/edsger/badge/?version=latest)](https://edsger.readthedocs.io/en/latest/?badge=latest)
 [![PyPI version](https://img.shields.io/pypi/v/edsger.svg?refresh=1)](https://pypi.org/project/edsger/)
 [![Downloads](https://static.pepy.tech/badge/edsger)](https://pepy.tech/project/edsger)
 [![Python 3.9 | 3.10 | 3.11 | 3.12 | 3.13](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://pypi.org/project/edsger/)
@@ -56,14 +57,20 @@ print("Shortest paths:", shortest_paths)
 
 We get the shortest paths from the source node 0 to all other nodes in the graph. The output is an array with the shortest path length to each node. A path length is the sum of the weights of the edges in the path.
 
+## Installation
+
+### Standard Installation
+
+```bash
+pip install edsger
+```
+
 ## Why Use Edsger?
 
-Edsger is designed to be **dataframe-friendly**, providing seamless integration with pandas workflows for graph algorithms. Also it is rather efficient. Our benchmarks on the USA road network (23.9M vertices, 57.7M edges) demonstrate nice performance:
+Edsger is designed to be **dataframe-friendly**, providing seamless integration with pandas workflows for graph algorithms. Also it is rather efficient on Linux. Our benchmarks on the USA road network (23.9M vertices, 57.7M edges) demonstrate nice performance:
 
 <img src="https://raw.githubusercontent.com/aetperf/edsger/release/docs/source/assets/dijkstra_benchmark_comparison.png" alt="Dijkstra Performance Comparison" width="700">
 
-*Benchmark performed on Intel i9-12900H Linux laptop.*
-
 ## Contributing
 
 We welcome contributions to the Edsger library. If you have any suggestions, bug reports, or feature requests, please open an issue on our [GitHub repository](https://github.com/aetperf/Edsger).

{edsger-0.1.3 → edsger-0.1.4}/docs/source/index.md

@@ -10,12 +10,10 @@ Welcome to the Edsger documentation! Edsger is a Python library for efficient gr
 
 ## Why Use Edsger?
 
-Edsger is designed to be **dataframe-friendly**, providing seamless integration with pandas workflows for graph algorithms. Also it is rather efficient. Our benchmarks on the USA road network (23.9M vertices, 57.7M edges) demonstrate nice performance:
+Edsger is designed to be **dataframe-friendly**, providing seamless integration with pandas workflows for graph algorithms. Also it is rather efficient on Linux. Our benchmarks on the USA road network (23.9M vertices, 57.7M edges) demonstrate nice performance:
 
 <img src="assets/dijkstra_benchmark_comparison.png" alt="Dijkstra Performance Comparison" width="700">
 
-*Benchmark performed on Intel i9-12900H Linux laptop.*
-
 ### Pandas Integration Made Simple
 
 ```python

edsger-0.1.4/scripts/README_benchmark_os.md

@@ -0,0 +1,72 @@
+# OS-Specific Benchmarking Scripts
+
+These scripts allow you to run benchmarks on different operating systems and combine the results into comparison plots.
+
+## Scripts
+
+1. **benchmark_comparison_os.py** - Runs benchmarks and creates OS-specific JSON files
+2. **plot_benchmark_comparison.py** - Creates comparison plots from the JSON files
+
+## Usage
+
+### Step 1: Run benchmarks on each OS
+
+On Linux:
+```bash
+cd scripts/
+python benchmark_comparison_os.py [-d DATA_DIR] [-n NETWORK] [-r REPEAT]
+```
+This creates: `benchmark_dimacs_USA_linux.json` (or with different network name)
+
+On Windows:
+```bash
+cd scripts/
+python benchmark_comparison_os.py [-d DATA_DIR] [-n NETWORK] [-r REPEAT]
+```
+This creates: `benchmark_dimacs_USA_windows.json` (or with different network name)
+
+On macOS:
+```bash
+cd scripts/
+python benchmark_comparison_os.py [-d DATA_DIR] [-n NETWORK] [-r REPEAT]
+```
+This creates: `benchmark_dimacs_USA_darwin.json` (or with different network name)
+
+#### Arguments:
+- `-d, --dir`: Data folder with network sub-folders (default: from DIMACS_DATA_DIR env var or `/home/francois/Data/DIMACS_road_networks/`)
+- `-n, --network`: Network name - 'NY', 'BAY', 'COL', 'FLA', 'NW', 'NE', 'CAL', 'LKS', 'E', 'W', 'CTR', 'USA' (default: USA)
+- `-r, --repeat`: Number of benchmark iterations per library (default: 5)
+
+### Step 2: Create comparison plots
+
+After collecting results from one or more operating systems:
+```bash
+python plot_benchmark_comparison.py
+```
+
+This will create:
+- Combined comparison plot: `dijkstra_benchmark_comparison.png`
+
+## Features
+
+- **Graceful handling of missing packages**: Graph-tool is automatically skipped on Windows
+- **OS detection**: Automatically names output files based on the operating system
+- **Multi-OS comparison**: Can compare results across Linux, Windows, and macOS
+- **Version tracking**: Records package versions for each benchmark run
+
+## Output Files
+
+### JSON files
+- `benchmark_dimacs_{NETWORK}_{OS}.json` - Benchmark results for specific network and OS
+  - Examples: `benchmark_dimacs_USA_linux.json`, `benchmark_dimacs_COL_windows.json`
+
+### Plot files
+- `dijkstra_benchmark_comparison.png` - Comparison plot (shows all available OS results)
+
+## Notes
+
+- **Graph-tool**: Not available on Windows and will be automatically skipped
+- **SciPy benchmarking**: Runs `dijkstra_dimacs.py` with Edsger + comparison (`-c` flag) multiple times to collect SciPy timing statistics, since SciPy only runs once per call in comparison mode
+- **Package detection**: Scripts detect available packages before running benchmarks
+- **Metadata**: Results include system information, Python version, and package versions
+- **Statistical reliability**: Benchmarks run 5 iterations by default for each library

edsger-0.1.4/scripts/benchmark_comparison_os.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""
+Comprehensive benchmarking script for Dijkstra implementations with OS-specific output.
+
+Runs dijkstra_dimacs.py for Edsger, NetworKit, Graph-tool, and SciPy,
+then saves results to OS-specific JSON files for later comparison.
+"""
+
+import os
+import sys
+import subprocess
+import time
+import platform
+import numpy as np
+from datetime import datetime
+import json
+from argparse import ArgumentParser
+
+
+def get_system_info():
+    """Collect system and package version information."""
+    info = {}
+
+    # Python version
+    info["python_version"] = platform.python_version()
+
+    # Platform info
+    info["platform"] = platform.platform()
+    info["processor"] = platform.processor()
+    info["os_name"] = platform.system()  # Linux, Windows, Darwin
+
+    # Anaconda/Conda version
+    try:
+        result = subprocess.run(["conda", "--version"], capture_output=True, text=True)
+        if result.returncode == 0:
+            info["conda_version"] = result.stdout.strip()
+        else:
+            info["conda_version"] = "Not available"
+    except FileNotFoundError:
+        info["conda_version"] = "Not installed"
+
+    # Package versions - check availability first
+    packages = ["edsger", "networkit", "graph-tool", "scipy", "numpy", "pandas"]
+    available_packages = []
+
+    for package in packages:
+        try:
+            if package == "edsger":
+                import edsger
+
+                info[f"{package}_version"] = getattr(edsger, "__version__", "dev")
+                available_packages.append(package)
+            elif package == "networkit":
+                import networkit as nk
+
+                info[f"{package}_version"] = nk.__version__
+                available_packages.append(package)
+            elif package == "graph-tool":
+                # Graph-tool is not available on Windows
+                if platform.system() == "Windows":
+                    info[f"{package}_version"] = "Not available on Windows"
+                else:
+                    import graph_tool as gt
+
+                    info[f"{package}_version"] = gt.__version__
+                    available_packages.append(package)
+            elif package == "scipy":
+                import scipy
+
+                info[f"{package}_version"] = scipy.__version__
+                available_packages.append(package)
+            elif package == "numpy":
+                import numpy as np
+
+                info[f"{package}_version"] = np.__version__
+                available_packages.append(package)
+            elif package == "pandas":
+                import pandas as pd
+
+                info[f"{package}_version"] = pd.__version__
+                available_packages.append(package)
+        except ImportError:
+            info[f"{package}_version"] = "Not installed"
+        except Exception as e:
+            info[f"{package}_version"] = f"Error: {str(e)}"
+
+    info["available_packages"] = available_packages
+    return info
+
+
+def run_benchmark(library, repeat=5, data_dir=None, network_name="USA"):
+    """Run dijkstra_dimacs.py for a specific library."""
+    print(f"\n[BENCHMARK] Running {library} benchmark ({repeat} iterations)...")
+
+    # Get the project root directory (parent of scripts)
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(script_dir)
+
+    # For SciPy, we need to run Edsger with -c flag multiple times to get SciPy timing
+    # (SciPy only runs once per dijkstra_dimacs.py call when using -c)
+    if library == "SciPy":
+        cmd = [
+            sys.executable,
+            "dijkstra_dimacs.py",
+            "-n",
+            network_name,
+            "-l",
+            "E",  # Run Edsger but with -c to get SciPy comparison
+            "-r",
+            "1",  # Run only 1 iteration of Edsger per call
+            "-c",
+        ]
+    else:
+        cmd = [
+            sys.executable,
+            "dijkstra_dimacs.py",
+            "-n",
+            network_name,
+            "-l",
+            library,
+            "-r",
+            str(repeat),
+        ]
+
+    # Add data directory argument if provided
+    if data_dir:
+        cmd.extend(["-d", data_dir])
+
+    # Set environment to include project root in Python path
+    env = os.environ.copy()
+    env["PYTHONPATH"] = project_root + ":" + env.get("PYTHONPATH", "")
+
+    try:
+        print(f"[DEBUG] Running command: {' '.join(cmd)}")
+        print(f"[DEBUG] Working directory: {os.getcwd()}")
+        print(f"[DEBUG] Project root: {project_root}")
+
+        times = []
+        total_start_time = time.time()
+
+        # For SciPy, we need to run the command multiple times since SciPy only runs once per call
+        iterations = repeat if library == "SciPy" else 1
+
+        for iteration in range(iterations):
+            if library == "SciPy":
+                print(f"[DEBUG] SciPy iteration {iteration + 1}/{iterations}")
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, timeout=600, env=env
+            )
+
+            print(f"[DEBUG] Return code: {result.returncode}")
+            if iteration == 0:  # Only print lengths for first iteration to avoid spam
+                print(f"[DEBUG] Stdout length: {len(result.stdout)}")
+                print(f"[DEBUG] Stderr length: {len(result.stderr)}")
+
+            if result.returncode != 0:
+                print(f"[ERROR] {library} benchmark failed!")
+                print(f"[ERROR] stderr: {result.stderr}")
+                print(f"[DEBUG] stdout: {result.stdout}")
+                return None
+
+            # Parse output to extract timing information
+            # The output might be in stderr due to logging configuration
+            output_text = result.stdout + result.stderr
+            lines = output_text.strip().split("\n")
+
+            # Map library codes to full names used in output
+            library_names = {
+                "E": "Edsger",
+                "NK": "NetworKit",
+                "GT": "graph-tool",
+                "SciPy": "SciPy",
+            }
+
+            expected_name = library_names.get(library, library)
+
+            for line in lines:
+                if library == "SciPy":
+                    # For SciPy, look for the pattern from the check_result section
+                    # "SciPy Dijkstra - Elapsed time: 1.2345 s" (no trial number)
+                    if "SciPy Dijkstra - Elapsed time:" in line:
+                        parts = line.split("Elapsed time:")
+                        if len(parts) > 1:
+                            time_str = parts[1].strip().split()[0]
+                            try:
+                                elapsed_time = float(time_str)
+                                times.append(elapsed_time)
+                                break  # Only one SciPy timing per run
+                            except ValueError:
+                                continue
+                else:
+                    # For other libraries, look for the pattern with trial numbers
+                    # "Edsger Dijkstra 1/5 - Elapsed time:   2.5410 s"
+                    if (
+                        f"{expected_name} Dijkstra" in line
+                        and "Elapsed time:" in line
+                        and "/" in line
+                    ):
+                        parts = line.split("Elapsed time:")
+                        if len(parts) > 1:
+                            time_str = parts[1].strip().split()[0]
+                            try:
+                                elapsed_time = float(time_str)
+                                times.append(elapsed_time)
+                            except ValueError:
+                                continue
+
+        total_end_time = time.time()
+
+        if not times:
+            print(f"[WARNING] Could not parse timing data for {library}")
+            print(f"[DEBUG] Expected pattern: '{expected_name} Dijkstra'")
+            return None
+
+        min_time = min(times)
+        avg_time = np.mean(times)
+        std_time = np.std(times)
+
+        print(
+            f"[BENCHMARK] {library} completed: min={min_time:.4f}s, avg={avg_time:.4f}s, std={std_time:.4f}s"
+        )
+
+        return {
+            "library": library,
+            "times": times,
+            "min_time": min_time,
+            "avg_time": avg_time,
+            "std_time": std_time,
+            "total_duration": total_end_time - total_start_time,
+        }
+
+    except subprocess.TimeoutExpired:
+        print(f"[ERROR] {library} benchmark timed out!")
+        return None
+    except Exception as e:
+        print(f"[ERROR] {library} benchmark failed with exception: {e}")
+        return None
+
+
+def save_results_json(results, system_info, network_name="USA"):
+    """Save detailed results to OS-specific JSON file."""
+    os_name = platform.system().lower()  # linux, windows, darwin
+    output_file = f"benchmark_dimacs_{network_name}_{os_name}.json"
+
+    data = {
+        "timestamp": datetime.now().isoformat(),
+        "os": os_name,
+        "network": network_name,
+        "system_info": system_info,
+        "benchmark_results": [r for r in results if r is not None],
+    }
+
+    with open(output_file, "w") as f:
+        json.dump(data, f, indent=2)
+
+    print(f"\n[DATA] Saved detailed results to: {output_file}")
+    return output_file
+
+
+def main():
+    """Main benchmarking function."""
+    # Determine default data directory based on OS
+    if platform.system() == "Windows":
+        # Check common Windows paths
+        if os.path.exists(
+            r"C:\Users\fpacu\Documents\Workspace\Edsger\data\DIMACS_road_networks"
+        ):
+            default_data_dir = (
+                r"C:\Users\fpacu\Documents\Workspace\Edsger\data\DIMACS_road_networks"
+            )
+        else:
+            default_data_dir = os.path.join(
+                os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+                "data",
+                "DIMACS_road_networks",
+            )
+    else:
+        default_data_dir = "/home/francois/Data/DIMACS_road_networks/"
+
+    # Use environment variable if set, otherwise use OS-specific default
+    default_data_dir = os.getenv("DIMACS_DATA_DIR", default_data_dir)
+
+    # Parse command line arguments
+    parser = ArgumentParser(
+        description="OS-specific benchmark comparison for Dijkstra implementations"
+    )
+    parser.add_argument(
+        "-d",
+        "--dir",
+        dest="data_dir",
+        help="Data folder with network sub-folders",
+        metavar="TXT",
+        type=str,
+        required=False,
+        default=default_data_dir,
+    )
+    parser.add_argument(
+        "-n",
+        "--network",
+        dest="network_name",
+        help="network name, must be 'NY', 'BAY', 'COL', 'FLA', 'NW', "
+        + "'NE', 'CAL', 'LKS', 'E', 'W', 'CTR', 'USA' (default: USA)",
+        metavar="TXT",
+        type=str,
+        required=False,
+        default="USA",
+    )
+    parser.add_argument(
+        "-r",
+        "--repeat",
+        dest="repeat",
+        help="Number of benchmark iterations per library (default: 5)",
+        metavar="INT",
+        type=int,
+        required=False,
+        default=5,
+    )
+
+    args = parser.parse_args()
+
+    print("=" * 80)
+    print("DIJKSTRA ALGORITHM PERFORMANCE BENCHMARK")
+    print(f"OS: {platform.system()}")
+    print(f"Network: {args.network_name}")
+    print(f"Data directory: {args.data_dir}")
+    print(f"Iterations per library: {args.repeat}")
+    print("=" * 80)
+
+    # Check if we're in the right directory
+    if not os.path.exists("dijkstra_dimacs.py"):
+        print(
+            "[ERROR] dijkstra_dimacs.py not found. Run this script from the scripts/ directory."
+        )
+        sys.exit(1)
+
+    # Collect system information
+    print("\n[INFO] Collecting system and package information...")
+    system_info = get_system_info()
+
+    print(f"[INFO] Python: {system_info['python_version']}")
+    print(f"[INFO] Platform: {system_info['platform']}")
+    print(f"[INFO] OS: {system_info['os_name']}")
+    print(f"[INFO] Conda: {system_info['conda_version']}")
+
+    # Define libraries to benchmark based on what's available
+    all_libraries = ["E", "NK", "GT", "SciPy"]
+    libraries = []
+
+    # Check which libraries are available
+    for lib in all_libraries:
+        lib_name = {
+            "E": "edsger",
+            "NK": "networkit",
+            "GT": "graph-tool",
+            "SciPy": "scipy",
+        }[lib]
+        if lib_name in system_info["available_packages"]:
+            libraries.append(lib)
+        else:
+            print(f"[INFO] Skipping {lib} - {lib_name} not available")
+
+    if not libraries:
+        print("[ERROR] No libraries available for benchmarking!")
+        sys.exit(1)
+
+    print(f"\n[INFO] Running benchmarks with {args.repeat} iterations each...")
+    print(f"[INFO] Libraries to benchmark: {', '.join(libraries)}")
+
+    # Run benchmarks
+    results = []
+    for lib in libraries:
+        result = run_benchmark(lib, args.repeat, args.data_dir, args.network_name)
+        results.append(result)
+
+        # Small delay between benchmarks to let system cool down
+        if result:
+            time.sleep(2)
+
+    # Filter successful results
+    successful_results = [r for r in results if r is not None]
+
+    if not successful_results:
+        print("[ERROR] No benchmarks completed successfully!")
+        sys.exit(1)
+
+    # Print summary
+    print("\n" + "=" * 80)
+    print("BENCHMARK SUMMARY")
+    print("=" * 80)
+
+    for result in successful_results:
+        print(
+            f"{result['library']:>10}: {result['min_time']:7.4f}s (min), {result['avg_time']:7.4f}s (avg) ± {result['std_time']:6.4f}s"
+        )
+
+    # Save detailed results
+    json_file = save_results_json(successful_results, system_info, args.network_name)
+
+    print("\n" + "=" * 80)
+    print("BENCHMARK COMPLETED SUCCESSFULLY")
+    print("=" * 80)
+    print(f"Results saved to: {json_file}")
+    print("\nTo create comparison plots, run:")
+    print("  python plot_benchmark_comparison.py")
+
+
+if __name__ == "__main__":
+    main()