Magus Uncore Freq Eval

magus-uncore-freq-eval

Exploring Uncore Frequency Scaling for Heterogeneous Computing — Zhong Zheng et al. (2025) (arXiv:2502.03796, 2025)

What this evaluates

Evaluates a model-free runtime system for dynamically scaling uncore frequencies in heterogeneous CPU-GPU architectures. It probes the system's ability to balance energy efficiency and performance across diverse HPC, molecular dynamics, and deep learning workloads.

Datasets

• Altis — total ?; splits: test (-1)
• ECP proxy applications — total ?; splits: test (-1)
• AI-enabled applications — total ?; splits: test (-1)
• MLPerf benchmarks — total ?; splits: test (-1)
• Altis-SYCL — total ?; splits: test (-1)

Metrics

• Performance Loss — range: percent
  • Percentage increase in execution time compared to the baseline: (T_method - T_baseline) / T_baseline × 100%.
• Package Power Saving — range: percent
  • Average reduction in CPU package power consumption relative to the baseline: (P_baseline - P_method) / P_baseline × 100%.
• Energy Saving — range: percent
  • Total reduction in system energy consumption (CPU package + GPU core and memory) compared to the baseline: (E_baseline - E_method) / E_baseline × 100%.
• Energy Delay Product (EDP) (primary) — range: other
  • Composite metric capturing energy efficiency and performance impact, calculated as Energy × Execution Time. Lower values indicate better overall system efficiency.

Input / output format

Input: Heterogeneous CPU-GPU system configurations running specific HPC, molecular dynamics, and deep learning benchmark applications under varying uncore frequency scaling strategies.

Output: Execution time, CPU package power, GPU energy, and total system energy per benchmark run, which are aggregated to compute the four evaluation metrics.

Scoring recipe

def compute_metrics(baseline, method):
    perf_loss = (method['time'] - baseline['time']) / baseline['time'] * 100
    pkg_power_saving = (baseline['pkg_power'] - method['pkg_power']) / baseline['pkg_power'] * 100
    energy_saving = (baseline['energy'] - method['energy']) / baseline['energy'] * 100
    edp = method['energy'] * method['time']
    return perf_loss, pkg_power_saving, energy_saving, edp

Common pitfalls

• The baseline uses default hardware frequency scaling, which keeps uncore at maximum frequency because CPU power rarely reaches TDP, making it a potentially suboptimal reference point.
• The UPS comparator was custom-implemented from the paper's methodology due to lack of open-source code, introducing potential implementation variance.
• Different hardware platforms require different programming models (CUDA vs SYCL), which may confound direct performance comparisons across systems.

Evidence (verbatim from paper)

We evaluate each method using four key metrics: Performance Loss: Percentage increase in execution time compared to the baseline, measuring the runtime impact of uncore frequency scaling. Package Power Saving: Average reduction in CPU package power consumption relative to the baseline. Energy Saving: Total reduction in system energy consumption, including both CPU package and GPU (core and memory) energy, compared to the baseline. Energy Delay Product (EDP): A composite metric that captures both energy efficiency and performance impact.

Citation

@misc{zheng2025exploring,
  title={Exploring Uncore Frequency Scaling for Heterogeneous Computing},
  author={Zhong Zheng et al. (2025)},
  year={2025},
  note={arXiv:2502.03796}
}

• arXiv: 2502.03796