Pith. sign in

REVIEW 4 major objections 4 minor 51 references

DEFT: Joint Task Placement and DVFS for Energy-Efficient Multi-GPU Runtimes

T0 review · 4 major / 4 minor · reviewed 2026-08-04 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Choosing both the GPU and the DVFS clock speed for each task cuts multi-GPU energy use by 14.8% while staying within 1.5% of the fastest baseline.

desk verdict Solid runtime-level DVFS+placement scheduler with honest measurement, but the model-generalization evidence is thinner than the headline implies. read the letter →

arxiv 2608.02122 v1 pith:FBTP4QIL submitted 2026-08-03 cs.DC

Jing Chen , Miquel Pericas This is my paper
classification cs.DC
keywords energyefficiencyDVFSmulti-GPUschedulingtask-basedruntimetaskplacementpowermodelingperformancepredictioncostmodel
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

DEFT claims that multi-GPU runtimes waste energy because they make task placement and DVFS decisions separately, and it proposes a scheduler that decides both together at task granularity. The scheduler first assigns each ready task to the GPU with the earliest feasible start time, then picks a core/memory frequency on that GPU by optimizing a user-chosen energy–delay objective, subject to task slack and contention constraints and explicit costs for data transfer and frequency transitions. The cost model is fed by lightweight one-time profiling: a single run at default frequency yields utilization vectors from which an XGBoost model predicts runtime and an analytical model predicts power across all frequencies. In experiments on NVIDIA L40S and L4 systems with four benchmarks, DEFT reports average energy reductions of 14.8% and 4.8%, EDP reductions of 9.9% and 3.7%, and performance within 1.5% of the fastest baseline. The significance is that these savings require no application changes and no exhaustive per-kernel profiling.

What carries the argument

The two-phase scheduling algorithm with its cost model: Phase 1 selects the device minimizing earliest start time (computed from device availability and data-readiness, independent of frequency), and Phase 2 evaluates all DVFS configurations on that device, choosing the one minimizing E x T^beta subject to slack feasibility and a contention cap. The cost model integrates predicted execution time, predicted power, inter-GPU transfer energy, and an empirical piecewise DVFS transition latency model. Supporting predictors are an XGBoost performance model and a fitted analytical power model, both keyed on hardware utilization vectors from a single Nsight Compute profiling run, plus an MSI-style c

What would settle it

Take an application with input-dependent kernels, profile it once at default frequency, run DEFT at a lower frequency, and compare predicted vs. measured speedup; if the prediction error exceeds the paper's reported 4–8% MAPE and the multi-GPU energy savings disappear or turn negative relative to the fastest baseline, the generalization claim is falsified.

Watch

Extended reading notes

Core claim

DEFT's core claim is that energy-efficient multi-GPU execution requires joint, task-granular coordination of placement and DVFS, and that this joint problem can be solved cheaply by a two-phase decomposition: device selection based on frequency-independent earliest start time, followed by frequency optimization on the chosen device subject to slack and throughput bounds. The paper argues that naive per-task DVFS (HEFT-PT) and uniform global frequency scaling (HEFT-G) both lose energy or performance because they ignore the coupling: frequency changes cost time and energy, and slowing a task on one GPU can idle other GPUs and extend the makespan. DEFT's cost model makes these trade-offs explic

Load-bearing premise

The models assume that hardware utilization measured at the default frequency predicts execution time and power at every frequency, so any kernel whose behavior changes with input data or runtime state could break the cost model's ranking.

Editorial extensions

If this is right

  • Multi-GPU runtimes can deliver energy reductions of roughly 5–15% without changing application code, by exposing an energy-delay objective to the scheduler.
  • The two-phase decomposition reduces the joint placement-DVFS problem to linear-time online decisions, so task-granular energy optimization is feasible even for large task graphs.
  • Slack and contention awareness are the difference between profitable and counterproductive DVFS: per-task frequency tuning without these bounds inflates makespan, while DEFT preserves makespan.
  • Proactive DVFS can beat hardware default power management even for memory-bound work, by suppressing frequency oscillations that waste energy and cause time variability.
  • The methodology transfers to other task-based runtimes, since it builds on standard DAG scheduling, DVFS APIs, and per-kernel hardware counters.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Editorial inference: the same cost-model structure could be extended to CPU-GPU heterogeneous nodes or power-capped data centers, where DVFS decisions interact with power limits; the paper's own boundary condition (power-bound workloads overridden by hardware boost) suggests such coordination is the next test.
  • Editorial inference: the single-profile generalization assumption is the main risk; input-dependent kernels or dynamic task graphs would require online re-profiling or delta-model updates, and the paper explicitly defers these cases.
  • Editorial inference: the geometric-mean savings over four applications may not hold for communication-dominated or extremely fine-grained workloads, where transfer and transition costs dominate; a useful extension would measure DEFT on such graphs.
  • Editorial inference: the empirical transition-latency model is device-specific; re-fitting it for other GPU families via the probe-kernel methodology is straightforward and could make DEFT a portable calibration-based runtime feature.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. The paper presents DEFT, a scheduling framework for multi-GPU task-based runtimes that jointly decides task-to-GPU placement and per-GPU DVFS settings at task granularity. The scheduler uses a two-phase algorithm: first choose the device with the earliest feasible start time, then select a DVFS configuration by minimizing an E^β·T-style cost subject to slack and throughput constraints. Supporting this are three predictive models: an analytical power model based on hardware utilization and voltage-frequency relations, an XGBoost performance model that maps utilization vectors and frequency ratios to speedup, and an empirical piecewise DVFS transition-latency model. The framework is implemented on top of CUDASTF and evaluated on NVIDIA L4 and L40S nodes using Cholesky, CG, FDTD, and miniWeather, across five optimization objectives. The headline claims are average energy reductions of 14.8% (L40S) and 4.8% (L4), EDP reductions of 9.9% and 3.7%, and performance within 1.5% of the fastest baseline.

Significance. If the results hold, DEFT would be a useful contribution: it is the first runtime framework, to my knowledge from the related work, to integrate placement and DVFS at task granularity in multi-GPU task-based systems, and it does so without requiring application changes. The design is sensible and the decomposition into placement (frequency-independent) and frequency selection (conditional on placement) is clean. The paper also reports measured energy from NVML counters rather than predicting the headline savings from its own models, which avoids circularity in the main evaluation. The model validation, though limited, is an explicit step that many scheduling papers omit. The main risk is generalizability: the predictive engine extrapolates from a default-frequency utilization signature to the full DVFS space, and this extrapolation is asserted rather than tested. If that premise fails, the measured savings may not reproduce on other workloads. The evaluation also lacks error bars, so the claimed precision (e.g., 'within 1.5%') is not statistically supported. The central idea is worth publishing, but the load-bearing generalization claim and the quantitative evaluation need strength

major comments (4)
  1. [§4.1, §4.3, Eq. (11)] The paper's core generalization premise is that the NCU-collected utilization vector U is 'a hardware utilization signature independent of frequency scaling' (§4.1). This premise is never tested. The XGBoost model in §4.3 is trained on (U, f_gpu, f_mem, S) tuples in which U is always profiled at the default frequency, and then used to predict speedups at every DVFS state. For memory-bound kernels in particular, lowering f_mem can change achieved DRAM utilization and stall behavior, so U may shift. Section 3.4 explicitly defers input-dependent tasks, but even for the four evaluated applications no experiment shows that U remains stable across frequencies. I request a direct test: profile the evaluated kernels at several (f_gpu, f_mem) points, quantify the drift in U, and report the resulting prediction error and scheduling misranking rate. Without such evidence, the model accuracy in Tabl
  2. [§6.1, Figures 4–5] All headline numbers are point estimates with no error bars, no confidence intervals, and no statement of the number of experimental repetitions. Energy is sampled from NVML counters that update at roughly 100 ms granularity, and makespan and energy are both subject to run-to-run variation. The claim that DEFT remains 'within 1.5% of HEFT' is, as reported, not statistically distinguishable from 'equal to HEFT' or even 'slower than HEFT'. Similarly, the 14.8%/4.8% energy reductions could be within noise for some benchmarks. Please report means with standard deviations (or confidence intervals) over at least, say, 5–10 runs, and state the run count in the experimental setup.
  3. [Eqs. (3), (5), (6), (9)] The energy model appears to double-count idle power when a DVFS transition overlaps with an inter-GPU data transfer. Equation (6) uses max(T_avail + T_trans, T_data) to determine the actual start time, which correctly models the transition and transfer as concurrent. However, Eq. (9) then adds E_trans (Eq. 5) and E_transfer (Eq. 3) as if they were sequential. If the transition completes before the data arrives, the GPU idles from T_avail to T_data, but E_trans already charges idle power for the transition interval; adding E_transfer charges that same interval a second time. If the data arrives before the transition completes, E_transfer charges the gap and E_trans charges the overlapping transition. The correct incremental energy should integrate idle power over max(T_trans, T_data - T_avail), not sum the two terms. This overcounting biases DEFT against reconfiguration in situations wher
  4. [§3.2.2, Eq. (8), §6.1.2] The throughput-awareness parameter kappa is set to a fixed 2% and is described as selected via 'preliminary sensitivity testing', but no sensitivity analysis is shown. The miniWeather 4-GPU result demonstrates that disabling the throughput constraint degrades performance by 9.6%, so kappa materially influences the energy-performance trade-off. A reader cannot assess how robust the reported savings are to this choice. Please report a sensitivity sweep over kappa (e.g., 0%, 1%, 2%, 5%, 10%) for at least one contention-bound configuration, ideally miniWeather on 4 GPUs, showing energy, makespan, and EDP.
minor comments (4)
  1. [Figure 3] The piecewise fit equations contain a box character ('□') where a minus sign is intended (e.g., '3.17 Δf □ 3097.66' and '7.44 Δf □ 13361.85'). Please fix the rendering.
  2. [Table 2] The MAPE values are 'averaged across L4 and L40S'. Since the two GPUs have different DVFS ranges and power characteristics, report per-platform MAPE as well, or state why the average is the appropriate presentation.
  3. [§3.4] Profiling overhead is described as 'on the order of minutes' but no concrete measurement is given. A short paragraph or table with the actual profiling time per benchmark would make the claimed lightweightness verifiable.
  4. [Figure 5 caption] The caption already explains that fixed-frequency schedulers have identical Min Time and Min Energy coordinates, but the markers still overlap visually. Consider using a small jitter or a separate symbol legend to improve readability.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: DEFT's reported energy savings are measured with hardware counters, and all fitted models are calibrated on external microbenchmarks, not on the evaluation metric.

full rationale

The paper's central claim (14.8%/4.8% energy reduction, 9.9%/3.7% EDP reduction) is based on measured NVML energy counters, not on energy values predicted by the cost model. The predictive components—XGBoost performance model, analytical power model, DVFS transition piecewise fits, and the κ=2% contention cap—are calibrated on 244 synthetic microbenchmarks and preliminary sensitivity tests, not on the four evaluation applications. The four-application MAPE validation (Table 2) is an out-of-sample check, since the applications are not in the training set. The two-phase scheduling algorithm (Eqs. 1–10) is a constructive optimization procedure, not a derivation that assumes its own conclusion. The statement that DEFT converges to HEFT placement when DVFS is disabled is a mathematical consequence of homogeneous devices and is not used to prove energy savings. The only self-citations ([12,13] in Related Work) are prior CPU/memory DVFS schedulers and are not load-bearing. The paper explicitly acknowledges limitations: frequency-invariance of utilization is an assumption (§4.1), input-dependent tasks are deferred (§3.4), and compute-saturated workloads trigger power limiting that overrides DVFS (§6.1.1). These are validity threats, not circularity. No equation or fitted parameter is equivalent to the reported energy reduction by construction.

Assumptions & free parameters 5 free parameters · 6 assumptions · 0 invented entities

The central claims rest on a substantial fitted-model stack: per-GPU power coefficients, an XGBoost performance predictor, piecewise DVFS transition models, the contention cap kappa, and an undisclosed idle threshold. These are calibrated on microbenchmarks or sensitivity tests rather than derived from first principles. The measured evaluation provides external grounding, but the fitted stack means the scheduler's behavior is not parameter-free.

free parameters (5)
  • kappa (contention slowdown cap) = 2%
    Section 3.2.2 Step 3, Eq. (8): per-task execution-time inflation cap under contention, selected via 'preliminary sensitivity testing' on the evaluation benchmarks; directly bounds how much DVFS DEFT is allowed to use.
  • idle-device transition threshold = not disclosed
    Section 3.1: GPU is idled to a low-power state after a 'predefined temporal threshold'; the threshold value is never given and it materially affects idle-energy savings, especially for CG.
  • power-model coefficients gamma_static,k, gamma_idle,k, omega_j,k and joint V-F curves = per GPU, fitted
    Section 4.2 Eq. (13): iteratively fitted on the 244-microbenchmark training set for each GPU; these coefficients feed every energy decision in the cost model.
  • DVFS transition model piecewise coefficients = e.g., L4 down: 0.53*df+400 (df<=799); 820.43 (799<df<=1235); 3.17*df+3097.66 (df>1235); L4 up: constant 427.01; L40S dow
    Section 4.4.2 and Figure 3: fitted to measured transition latencies (50 repetitions, median); the fitted thresholds directly determine whether DEFT decides a frequency change is profitable.
  • XGBoost hyperparameters and trained forest = not reported
    Section 4.3: gradient-boosted tree regressor trained on microbenchmark data; hyperparameters are not disclosed, so the exact predictor is not reproducible.
assumptions (6)
  • domain assumption DVFS transitions and inter-GPU data transfers proceed in parallel on independent hardware; task start time is max(available + T_trans, data_ready).
    Section 3.2.2 Step 2, Eq. (6): if transitions serialize with transfers, start-time and energy calculations are optimistic and the selected frequency may be suboptimal.
  • domain assumption Copy-engine bandwidth is fixed and independent of GPU DVFS states.
    Phase 1, Eq. (1): transfer time is data/BW with constant BW; memory-frequency scaling could change PCIe/NVLink copy throughput on some systems.
  • domain assumption A default-frequency utilization profile is sufficient to predict behavior at all DVFS states for the scheduled kernels.
    Sections 3.4 and 4.1-4.3: the entire Prediction Engine extrapolates from one Nsight Compute run; this is explicitly invalid for input-dependent or dynamically generated task graphs (Section 3.4).
  • domain assumption GPU power is separable as static plus idle plus utilization-dependent dynamic terms with per-component coefficients (Eq. 13).
    Section 4.2: standard analytical power model adapted from prior work [21,23]; 8.1% MAPE on four applications is acceptable but not a proof.
  • domain assumption Static task slack computed at maximum frequency remains a valid bound even when many tasks are slowed concurrently.
    Section 3.2.1 and Step 3: per-task slack bounds make sense for one slowed task; when many slack-rich tasks slow together, aggregate delay can exceed the static bound, which the contention cap (Eq. 8) only partially mitigates.
  • domain assumption Energy counters sampled every 50 ms capture DVFS energy effects reliably.
    Section 5: hardware counters update at approximately 100 ms; 50 ms sampling is chosen empirically; short transitions or short kernel-level effects may be undercounted.

how reviews work

0 comments
Cite this review

Pith. "Pith review of DEFT: Joint Task Placement and DVFS for Energy-Efficient Multi-GPU Runtimes." pith.science (2026). https://pith.science/paper/FBTP4QIL

@misc{pith2026260802122,
  author       = {Pith},
  title        = {Pith review of: DEFT: Joint Task Placement and DVFS for Energy-Efficient Multi-GPU Runtimes},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FBTP4QIL}},
  note         = {Machine review of arXiv:2608.02122}
}
read the original abstract

Energy efficiency has become a first-order concern in modern high-performance computing systems, as it directly determines achievable throughput under fixed power budgets. Although Dynamic Voltage and Frequency Scaling (DVFS) provides an effective mechanism for reducing GPU energy consumption, existing runtime systems decouple DVFS from task placement and inter-GPU communication, focus on single-GPU execution, or cannot adapt frequency to task granularity and runtime contention in multi-GPU environments. Consequently, current schedulers fail to capture the tight coupling between task placement, frequency selection, and inter-GPU data movement that fundamentally governs energy-performance trade-offs on multi-GPU systems. This paper presents DEFT, an energy-aware scheduling framework that jointly optimizes task-to-device assignment and per-GPU DVFS configuration for task-based multi-GPU applications. DEFT employs a cost-model-driven strategy that integrates slack awareness, throughput awareness, and explicit modeling of task execution cost, inter-GPU data movement, and DVFS transition overheads, enabling coordinated placement and frequency decisions at task granularity under dynamic runtime conditions. We prototype DEFT within the CUDASTF runtime and demonstrate its effectiveness across five optimization objectives. The evaluation shows that DEFT reduces energy consumption by 14.8% and 4.8% on average on NVIDIA L40S and L4, and reduces EDP by 9.9% and 3.7%, respectively, while maintaining performance within 1.5% of the fastest baseline.

Figures

Figures reproduced from arXiv: 2608.02122 by the authors.

Figure 1
Figure 1. Overview of the proposed energy-aware scheduling framework. [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. MSI coherence protocol for data instance state tran [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Measured DVFS transition latencies on NVIDIA L4 and L40S GPUs, showing asymmetric and non-monotonic behavior. [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Normalized execution time and energy-performance metrics for the four different schedulers on NVIDIA L40S [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]
Figure 5
Figure 5. Figure 5: Normalized performance and optimization objectives of four scheduling algorithms on NVIDIA L4 GPUs. For Random, [PITH_FULL_IMAGE:figures/full_fig_p010_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

51 extracted references · 3 canonical work pages

  1. [1]

    Ahmad Abdelfattah, Azzam Haidar, Stanimire Tomov, and Jack Dongarra. 2016. Fast Cholesky factorization on GPUs for batch and native modes in MAGMA. Procedia Computer Science80 (2016), 93–101

    2016

  2. [2]

    Wright, Mert Side, and Yong Chen

    Ghazanfar Ali, Sridutt Bhalachandra, Nicholas J. Wright, Mert Side, and Yong Chen. 2022. Optimal GPU Frequency Selection using Multi-Objective Approaches Jing Chen and Miquel Pericàs for HPC Systems. In2022 IEEE High Performance Extreme Computing Conference (HPEC). 1–7. doi:10.1109/HPEC55821.2022.9926317

    arXiv 2022

  3. [3]

    Ghazanfar Ali, Mert Side, Sridutt Bhalachandra, Nicholas J Wright, and Yong Chen. 2023. Performance-aware energy-efficient gpu frequency selection using dnn-based models. InProceedings of the 52nd International Conference on Parallel Processing. 433–442

    2023

  4. [4]

    Negar Baradar Alizadeh and Mahmoud Momtazpour. 2024. Multi-Objective Concurrent Kernel Scheduling for Multi-GPU Systems. In2024 32nd International Conference on Electrical Engineering (ICEE). 1–6. doi:10.1109/ICEE63041.2024. 10667973

    arXiv 2024

  5. [5]

    Cédric Augonnet, Andrei Alexandrescu, Albert Sidelnik, and Michael Garland

  6. [6]

    Cédric Augonnet, Samuel Thibault, Raymond Namyst, and Pierre-André Wacre- nier. 2011. StarPU: a unified platform for task scheduling on heterogeneous multicore architectures.Concurrency and Computation: Practice and Experience23, 2 (2011), 187–198. arXiv:https://onlinelibrary.wiley.com/doi/pdf/10.1002/cpe.1631 doi:10.1002/cpe.1631

    doi:10.1002/cpe.1631 2011

  7. [7]

    Srikant Bharadwaj, Shomit Das, Kaushik Mazumdar, Bradford M Beckmann, and Stephen Kosonocky. 2023. Predict; don’t react for enabling efficient fine- grain dvfs in gpus. InProceedings of the 28th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume

    2023

  8. [8]

    Joshua Dennis Booth, Jagadish Kotra, Hui Zhao, Mahmut Kandemir, and Padma Raghavan. 2015. Phase detection with hidden markov models for dvfs on many- core processors. In2015 IEEE 35th International Conference on Distributed Com- puting Systems. IEEE, 185–195

    2015

Show all 51 references
  1. [9]

    Alfredo Buttari, Julien Langou, Jakub Kurzak, and Jack Dongarra. 2009. A class of parallel tiled linear algebra algorithms for multicore architectures.Parallel Comput.35, 1 (2009), 38–53. doi:10.1016/j.parco.2008.10.002

    2009 doi

  2. [10]

    Lorenzo Carpentieri, Antonio De Caro, Majid Salimi Beni, Kaijie Fan, and Biagio Cosenza. 2025. Phase-Based Frequency Scaling for Energy-Efficient Heteroge- neous Computing. In2025 IEEE International Parallel and Distributed Processing Symposium (IPDPS). 824–836. doi:10.1109/IP...

    2025

  3. [11]

    Chao Chen, Chris Porter, and Santosh Pande. 2022. CASE: a compiler-assisted SchEduling framework for multi-GPU systems. InProceedings of the 27th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming(Seoul, Republic of Korea)(PPoPP ’22). Association for Comp...

    2022

  4. [12]

    Jing Chen, Madhavan Manivannan, Bhavishya Goel, and Miquel Pericàs. 2023. JOSS: Joint Exploration of CPU-Memory DVFS and Task Scheduling for Energy Efficiency. InProceedings of the 52nd International Conference on Parallel Process- ing(Salt Lake City, UT, USA)(ICPP ’23). Assoc...

    2023

  5. [13]

    Jing Chen, Madhavan Manivannan, Bhavishya Goel, and Miquel Pericàs. 2024. SWEEP: Adaptive Task Scheduling for Exploring Energy Performance Trade-offs. In2024 IEEE International Parallel and Distributed Processing Symposium (IPDPS). 325–336. doi:10.1109/IPDPS57955.2024.00036

    2024

  6. [14]

    Tianqi Chen and Carlos Guestrin. 2016. XGBoost: A Scalable Tree Boosting System. InProceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining(San Francisco, California, USA)(KDD ’16). Association for Computing Machinery, New York, NY, US...

    2016

  7. [15]

    Gilberto Contreras and Margaret Martonosi. 2008. Characterizing and improving the performance of intel threading building blocks. In2008 IEEE International Symposium on Workload Characterization. IEEE, 57–66

    2008

  8. [16]

    Georges Da Costa and Jean-Marc Pierson. 2015. DVFS Governor for HPC: Higher, Faster, Greener. In2015 23rd Euromicro International Conference on Parallel, Distributed, and Network-Based Processing. 533–540. doi:10.1109/PDP.2015.73

    2015 doi

  9. [18]

    Kaijie Fan, Biagio Cosenza, and Ben Juurlink. 2019. Predictable GPUs Fre- quency Scaling for Energy and Performance. InProceedings of the 48th In- ternational Conference on Parallel Processing(Kyoto, Japan)(ICPP ’19). Asso- ciation for Computing Machinery, New York, NY, USA, A...

    2019

  10. [19]

    Kaijie Fan, Marco D’Antonio, Lorenzo Carpentieri, Biagio Cosenza, Federico Ficarelli, and Daniele Cesarini. 2023. SYnergy: Fine-Grained Energy-Efficient Heterogeneous Computing for Scalable Energy Saving. InSC23: International Conference for High Performance Computing, Network...

    2023

  11. [20]

    Leiserson, and Keith H

    Matteo Frigo, Charles E. Leiserson, and Keith H. Randall. 1998. The implementa- tion of the Cilk-5 multithreaded language. InProceedings of the ACM SIGPLAN 1998 Conference on Programming Language Design and Implementation(Montreal, Quebec, Canada)(PLDI ’98). Association for Co...

    1998

  12. [21]

    Joao Guerreiro, Aleksandar Ilic, Nuno Roma, and Pedro Tomas. 2018. GPGPU Power Modeling for Multi-domain Voltage-Frequency Scaling. In2018 IEEE International Symposium on High Performance Computer Architecture (HPCA). 789–800. doi:10.1109/HPCA.2018.00072

    2018

  13. [22]

    João Guerreiro, Aleksandar Ilic, Nuno Roma, and Pedro Tomás. 2019. GPU Static Modeling Using PTX and Deep Structured Learning.IEEE Access7 (2019), 159150–159161. doi:10.1109/ACCESS.2019.2951218

    2019

  14. [23]

    João Guerreiro, Aleksandar Ilic, Nuno Roma, and Pedro Tomás. 2019. Modeling and Decoupling the GPU Power Consumption for Cross-Domain DVFS.IEEE Transactions on Parallel and Distributed Systems30, 11 (2019), 2494–2506. doi:10. 1109/TPDS.2019.2917181

    2019

  15. [24]

    Supercomputer’s lifelong energy costs almost equal the investment costs

    Hamblen, Anna-Lena. 2014. Total Cost of Ownership in High Performance Com- puting. (2014). Presentation/Technical Report, University of Hamburg. Explicitly states "Supercomputer’s lifelong energy costs almost equal the investment costs. "

    2014

  16. [25]

    Magnus R Hestenes and Eduard Stiefel. 1952. Methods of conjugate gradients for solving linear systems.J. Res. Nat. Bur. Standards49, 6 (1952), 409–435

    1952

  17. [26]

    Yanhui Huang, Bing Guo, and Yan Shen. 2020. GPU Energy optimization based on task balance scheduling.Journal of Systems Architecture107 (2020), 101808. doi:10.1016/j.sysarc.2020.101808

    2020

  18. [27]

    Joseph John, Josh Milthorpe, Thomas Herault, and George Bosilca. 2024. Multi- GPU work sharing in a task-based dataflow programming model.Future Genera- tion Computer Systems156 (2024), 313–324. doi:10.1016/j.future.2024.03.017

    2024 doi

  19. [28]

    Eric Masanet, Arman Shehabi, Nuoa Lei, Sarah Smith, and Jonathan Koomey

  20. [29]

    Xinxin Mei, Qiang Wang, and Xiaowen Chu. 2017. A survey and measure- ment study of GPU DVFS on energy conservation.Digital Communications and Networks3, 2 (2017), 89–100. doi:10.1016/j.dcan.2016.10.001

    2017 doi

  21. [30]

    Matthew R Norman, Jeff Larkin, and Isaac Lyngaas. 2020. miniWeather. https: //github.com/mrnorman/miniWeather OSTI ID: 1631691

    2020

  22. [31]

    NVIDIA Corporation. [n. d.]. NVIDIA Nsight Compute. ([n. d.]). https://docs. nvidia.com/nsight-compute/index.html

  23. [32]

    NVIDIA Corporation. 2023. NVIDIA ADA GPU ARCHITECTURE - Designed to deliver outstanding gaming and creating, professional graphics, AI, and compute performance. (2023). https://images.nvidia.com/aem-dam/Solutions/geforce/ ada/nvidia-ada-gpu-architecture.pdf

    2023

  24. [33]

    NVIDIA Corporation. 2025. NVIDIA Management Library (NVML) API Reference Guide. (2025). https://docs.nvidia.com/deploy/pdf/NVML_API_Reference_Guide. pdf Version used: vR580, September 2025

    2025

  25. [34]

    OpenMP Architecture Review Board. 2018. OpenMP Application Program Inter- face. Version 5.0

    2018

  26. [35]

    Pratyush Patel, Zibo Gong, Syeda Rizvi, Esha Choukse, Pulkit Misra, Thomas Anderson, and Akshitha Sriraman. 2023. Towards Improved Power Management in Cloud GPUs.IEEE Comput. Archit. Lett.22, 2 (July 2023), 141–144. doi:10.1109/ LCA.2023.3278652

    2023

  27. [36]

    Perez, Vicenç Beltran, Jesus Labarta, and Eduard Ayguadé

    Josep M. Perez, Vicenç Beltran, Jesus Labarta, and Eduard Ayguadé. 2017. Improv- ing the Integration of Task Nesting and Dependencies in OpenMP. In2017 IEEE International Parallel and Distributed Processing Symposium (IPDPS). 809–818. doi:10.1109/IPDPS.2017.69

    2017 doi

  28. [37]

    Efe Sencan, Dhruva Kulkarni, Ayse Coskun, and Kadidia Konate. 2025. Analyzing GPU Utilization in HPC Workloads: Insights from Large-Scale Systems. InPractice and Experience in Advanced Research Computing 2025: The Power of Collaboration (PEARC ’25). Association for Computing M...

    2025

  29. [38]

    Smith, Adam Hubbard, Diana Sartor, et al

    Arman Shehabi, Sarah J. Smith, Adam Hubbard, Diana Sartor, et al . 2024.2024 United States Data Center Energy Usage Report. Tech- nical Report LBNL-2001637. Lawrence Berkeley National Laboratory. https://eta-publications.lbl.gov/sites/default/files/2024-12/lbnl-2024-united- st...

    2024

  30. [39]

    Seokwoo Song, Minseok Lee, John Kim, Woong Seo, Yeongon Cho, and Soojung Ryu. 2014. Energy-efficient scheduling for memory-intensive GPGPU workloads. In2014 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE, 1–6

    2014

  31. [40]

    Topcuoglu, S

    H. Topcuoglu, S. Hariri, and Min-You Wu. 2002. Performance-effective and low-complexity task scheduling for heterogeneous computing.IEEE Transactions on Parallel and Distributed Systems13, 3 (2002), 260–274. doi:10.1109/71.993206

    2002 doi

  32. [41]

    Ilyas Turimbetov, Mohamed Wahib, and Didem Unat. 2025. A Device-Side Execution Model for Multi-GPU Task Graphs. InProceedings of the 39th ACM International Conference on Supercomputing (ICS ’25). Association for Computing Machinery, New York, NY, USA, 384–396. doi:10.1145/3721...

    2025

  33. [42]

    Daniel Velicka, Ondrej Vysocky, and Lubomir Riha. 2025. Methodology for GPU Frequency Switching Latency Measurement. In2025 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW). 830–839. doi:10.1109/IPDPSW66978.2025.00133 DEFT: Joint Task Placeme...

    2025

  34. [43]

    Igual, and Katzalin Olcoz

    Jorge Villarrubia, Luis Costero, Francisco D. Igual, and Katzalin Olcoz. 2025. Leveraging Multi-Instance GPUs through moldable task scheduling.J. Parallel and Distrib. Comput.204 (2025), 105128. doi:10.1016/j.jpdc.2025.105128

    2025

  35. [44]

    Qiang Wang and Xiaowen Chu. 2020. GPGPU Performance Estimation With Core and Memory Frequency Scaling.IEEE Transactions on Parallel and Distributed Systems31, 12 (2020), 2865–2881. doi:10.1109/TPDS.2020.3004623

    2020

  36. [45]

    Qiang Wang, Laiyi Li, Weile Luo, Yijia Zhang, and Bingqiang Wang. 2024. DSO: A GPU Energy Efficiency Optimizer by Fusing Dynamic and Static Information. In2024 IEEE/ACM 32nd International Symposium on Quality of Service (IWQoS). 1–6. doi:10.1109/IWQoS61813.2024.10682917

    2024

  37. [46]

    Yidi Wang, Mohsen Karimi, Yecheng Xiang, and Hyoseung Kim. 2021. Balancing energy efficiency and real-time performance in GPU scheduling. In2021 IEEE Real-Time Systems Symposium (RTSS). IEEE, 110–122

    2021

  38. [47]

    Bo Wu, Guoyang Chen, Dong Li, Xipeng Shen, and Jeffrey Vetter. 2015. Enabling and exploiting flexible task assignment on GPU through SM-centric program transformations. InProceedings of the 29th ACM on International Conference on Supercomputing. 119–130

    2015

  39. [48]

    Greathouse, Alexander Lyashevsky, Nuwan Jayasena, and Derek Chiou

    Gene Wu, Joseph L. Greathouse, Alexander Lyashevsky, Nuwan Jayasena, and Derek Chiou. 2015. GPGPU performance and power estimation using machine learning. In2015 IEEE 21st International Symposium on High Performance Com- puter Architecture (HPCA). 564–576. doi:10.1109/HPCA.201...

    2015

  40. [49]

    Kane Yee. 1966. Numerical solution of initial boundary value problems involving Maxwell’s equations in isotropic media.IEEE Transactions on Antennas and Propagation14, 3 (1966), 302–307. doi:10.1109/TAP.1966.1138693

    1966

  41. [50]

    Hadi Zamani, Laxmi Bhuyan, Jieyang Chen, and Zizhong Chen. 2023. GreenMD: Energy-efficient Matrix Decomposition on Heterogeneous Multi-GPU Systems. ACM Trans. Parallel Comput.10, 2, Article 12 (June 2023), 23 pages. doi:10.1145/ 3583590

    2023

  42. [2020]

    arXiv:https://www.science.org/doi/pdf/10.1126/science.aba3758 doi:10.1126/science.aba3758

    Recalibrating global data center energy-use estimates.Science367, 6481 (2020), 984–986. arXiv:https://www.science.org/doi/pdf/10.1126/science.aba3758 doi:10.1126/science.aba3758

    2020 doi

  43. [2024]

    InSC24: International Conference for High Performance Computing, Networking, Storage and Analysis

    CUDASTF: Bridging the Gap Between CUDA and Task Parallelism. InSC24: International Conference for High Performance Computing, Networking, Storage and Analysis. 1–17. doi:10.1109/SC41406.2024.00049

    2024 arXiv

Pith tools

Reviewed August 4, 2026 · model on record in the stance chip above.