Typical Usage Examples

This chapter demonstrates the most common workflows when using the Scalionix System Benchmark.

Rather than describing individual command-line flags, the following examples illustrate complete benchmark workflows from initial installation to benchmark comparison.

These examples are intended as practical starting points for everyday benchmark usage.

First-Time Installation

Before executing the benchmark for the first time, verify that the compilation environment is correctly installed.

scalionix-system-benchmark \
    --setup-compilation-environment

The benchmark verifies all required software components.

Typical verification includes:

• Rust toolchain
• Cargo
• Rustup
• C++ compiler
• Build tools
• Operating system support

If any required component is missing, installation recommendations are displayed.

No benchmark execution begins.

Verify Hardware Detection

Before executing the benchmark, hardware detection may be verified independently.

scalionix-system-benchmark \
    --check-hardware

Typical output includes:

• Processor
• Physical cores
• Logical processors
• Installed memory
• Storage devices
• Benchmark storage device
• Operating system
• Hardware fingerprint

This command is useful for validating benchmark configuration before long benchmark executions.

Execute Complete Benchmark

Executing the complete benchmark requires only a single command.

scalionix-system-benchmark

The benchmark automatically performs:

• Hardware detection
• Benchmark preparation
• Benchmark execution
• Score calculation
• Report generation
• Benchmark summary

Typical execution time depends on hardware performance and benchmark configuration.

Store Reports in a Custom Directory

Benchmark reports may be written to a custom directory.

scalionix-system-benchmark \
    --output ./benchmarks

All generated reports are written to the specified directory.

Existing benchmark execution remains unchanged.

Assign Report Identity

Benchmark executions may be assigned explicit identifiers.

scalionix-system-benchmark \
    --report-id workstation-linux \
    --user-id john-doe

Both identifiers become part of every generated report.

This simplifies historical benchmark tracking.

Execute Benchmark on a Specific Storage Device

Storage benchmarks evaluate the filesystem containing the benchmark working directory.

To benchmark another storage device, specify a working directory located on that device.

scalionix-system-benchmark \
    --benchmark-work-dir /mnt/nvme1/scalionix-benchmark

Storage Score now reflects the selected storage device.

This workflow is commonly used when comparing multiple SSDs installed in the same workstation.

Compare Two Benchmark Reports

Previously generated benchmark reports may be compared without executing the benchmark again.

scalionix-system-benchmark \
    --compare-score \
    --baseline workstation-before.json \
    --candidate workstation-after.json

The comparison engine verifies report compatibility before calculating:

• Compute Score difference
• Storage Score difference
• Category differences
• Percentage improvements

Benchmark execution is skipped entirely.

Hardware Upgrade Validation

A common workflow consists of executing the benchmark before and after upgrading hardware.

Step 1

Execute the benchmark before the upgrade.

scalionix-system-benchmark \
    --report-id before-upgrade

Step 2

Upgrade hardware.

Examples include:

• Processor
• Memory
• Storage

Step 3

Execute the benchmark again.

scalionix-system-benchmark \
    --report-id after-upgrade

Step 4

Compare both reports.

scalionix-system-benchmark \
    --compare-score \
    --baseline before-upgrade-global-score.json \
    --candidate after-upgrade-global-score.json

This workflow provides an objective measurement of hardware improvements.

Operating System Comparison

The benchmark may be executed on multiple operating systems installed on the same hardware.

Typical workflow:

Linux
  │
  ▼
Generate Global Score Report
  │
  ▼
Windows
  │
  ▼
Generate Global Score Report
  │
  ▼
Compare Reports

This allows operating system performance to be evaluated independently from hardware differences.

Benchmark Archival

Generated reports should be preserved after benchmark execution.

Recommended files include:

• Full Benchmark Report
• Scoring Report
• Global Score Report

Keeping these reports allows future benchmark comparison without repeating benchmark execution.

Historical benchmark archives become increasingly valuable as hardware evolves.

Continuous Integration

The benchmark is designed for automated execution.

Typical CI workflow:

Checkout Source
       │
       ▼
Build Benchmark
       │
       ▼
Verify Environment
       │
       ▼
Execute Benchmark
       │
       ▼
Generate Reports
       │
       ▼
Archive Reports
       │
       ▼
Compare Against Previous Run

This workflow enables automatic detection of performance regressions.

Public Benchmark Submission

The recommended workflow for public benchmark submission is:

Execute Benchmark
        │
        ▼
Verify Benchmark Completion
        │
        ▼
Review Generated Reports
        │
        ▼
Preserve Full Benchmark Report
        │
        ▼
Submit Global Score Report

The Global Score Report contains all information required for public benchmark comparison while remaining compact and portable.

Recommended Workflow

The following workflow is recommended for most users.

Verify Compilation Environment
             │
             ▼
      Check Hardware
             │
             ▼
     Execute Benchmark
             │
             ▼
    Review Benchmark Summary
             │
             ▼
     Preserve Generated Reports
             │
             ▼
Compare With Previous Results
             │
             ▼
 Upload Global Score Report

Following this workflow ensures reproducible benchmark execution while preserving all information required for future comparison and analysis.

Design Summary

The Scalionix System Benchmark has been designed around simple, deterministic workflows requiring minimal user interaction.

Whether executed interactively, integrated into automated infrastructure, or used for long-term hardware validation, the benchmark follows the same predictable execution model while producing identical report structures and scoring behavior.