Pith. sign in

REVIEW 3 major objections 5 minor 48 references

A Comparative Study of OpenMP Scheduling Algorithm Selection Strategies

T0 review · 3 major / 5 minor · reviewed 2026-08-15 · deepseek-v4-flash

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

Pith's one-line read Reinforcement learning can select the best OpenMP scheduling algorithm at runtime, but the learning phase is costly.

desk verdict Solid empirical comparison of expert- and RL-based OpenMP scheduling selection; main results are believable, but the RL formalization is under-specified enough that the paper needs code inspection and a rewrite of the reward/state description before the learning claim is fully reproducible. read the letter →

arxiv 2507.20312 v1 pith:4BRJOSSG submitted 2025-07-27 cs.DC cs.AIcs.LGcs.PF

Jonas H. Müller Korndörfer , Ali Mohammed , Ahmed Eleliemy , Quentin Guilloteau , Reto Krummenacher , Florina M. Ciorba This is my paper · ORCID
classification cs.DCcs.AIcs.LGcs.PF
keywords OpenMPloopschedulingalgorithmselectionreinforcementlearningQ-learningSARSAloadimbalanceHPCruntime
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

The paper argues that the choice of which OpenMP scheduling algorithm to use for a loop can be automated at runtime, and that machine-learned selectors can approach the performance of an oracle that already knows the best algorithm. Its experiments with six applications and three systems show that Q-learning and SARSA agents, embedded in the OpenMP runtime, learn high-performing scheduling decisions on repeated time-stepping loops. The catch is exploration: the agents must try 144 algorithm combinations before they choose, which can erase the gains on short or memory-bound loops. The reward function is decisive; rewarding low load imbalance (LIB) tends to pick algorithms with heavy overhead, while rewarding low loop time (LT) finds the best algorithm. Combining expert knowledge, in the form of a golden-ratio-based chunk parameter, with RL reduces the cost and improves performance.

What carries the argument

The load-bearing mechanism is a per-loop reinforcement-learning agent placed inside the OpenMP runtime. At each execution of a repeated loop the agent chooses one of 12 scheduling algorithms from the LB4OMP portfolio (static, self-scheduling, guided, trapezoid, factoring variants, adaptive weighted factoring variants, adaptive factoring, static steal, and LLVM's auto), receives a reward computed from Eq. (11), and updates a Q-table over 144 state–action pairs using either SARSA (Eq. 9) or Q-Learn (Eq. 10). The reward is normalized by the running minimum and maximum of the measured quantity — loop execution time or load imbalance LIB — so that a result inside the observed range is neutral, below it is positive, and above it is negative. The explore-first policy forces every one of the 144 combinations to be tried before exploitation. The expert counterpart is the golden-ratio chunk parameter, $\phi = 1.618$, which the paper uses to shrink the chunk-size interval and lower scheduling overhead, and the Oracle baseline supplies the best achievable selection against which every method is measured.

What would settle it

Run Q-Learn with the LT reward on a repeated loop whose execution time drifts across time steps (Mandelbrot's increasing-imbalance loop L1 is a suitable case), logging the online min/max bounds against bounds computed from the complete run. If the agent's selections deviate from the Oracle whenever the online bounds lag the true range, the reward-normalization assumption is the limiting factor; if selections stay near-optimal, the assumption holds.

Watch

Extended reading notes

Core claim

On the paper's own terms, the central discovery is that model-free reinforcement learning can be made to work for online scheduling-algorithm selection in OpenMP: Q-Learn and SARSA, operating per loop over a 12-algorithm portfolio, converge to selections that match or approach the Oracle baseline once their explore-first learning phase of 144 loop instances is over. The choice of reward is not a detail; rewards based on loop execution time produce near-oracle selections, while rewards based on load-imbalance percentage (LIB) systematically favor fine-grained schedules such as self-scheduling, whose overhead destroys performance. Expert-based selection (ExhaustiveSel, ExpertSel) is cheaper but can miss the optimal algorithm on some systems, and the paper shows that the two paradigms can be combined, for example by using the expert chunk parameter with RL, to achieve better performance than either alone.

Load-bearing premise

The RL results rest on the reward normalization in Eq. (11): the running minimum and maximum of past loop execution times (or LIB values) are assumed to provide stable relative rewards, but the paper does not specify how these bounds are initialized or updated when a loop's behavior changes; if the bounds are unrepresentative during early or non-stationary executions, the Q-table updates are distorted.

Editorial extensions

If this is right

  • Per-loop runtime selection can replace a single hard-coded schedule: a loop whose workload changes across time steps can switch scheduling algorithms as the execution evolves.
  • On time-stepping applications with enough repetitions, RL-based selectors can match or approach the Oracle's choice, so applications can approach best-in-portfolio performance without prior benchmarking.
  • Rewarding low load imbalance (LIB) misleads the learner into fine-grained schedules with heavy overhead, so future selectors should optimize loop time or a cost-aware proxy rather than balance alone.
  • The 144-instance explore-first phase makes RL selection worthwhile only when loops repeat many times; for short runs, expert rules or pre-trained Q-tables are needed.
  • The same per-loop selection mechanism can be extended to MPI-level scheduling whenever a portfolio of distributed-memory scheduling algorithms exists, as the paper anticipates.

Reading between the lines

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

  • Editorial inference: warm-starting the Q-table from a prior run on the same system, which the paper names as future work, would largely erase the exploration cost and could make RL selection practical for short-running loops.
  • Editorial inference: the LIB-reward failure suggests a general autotuning caution — any objective that rewards balance without charging for scheduling overhead drifts toward the finest-grained schedule; a cost-aware imbalance metric that includes overhead per work request is a natural next experiment.
  • Editorial inference: the min/max reward normalization in Eq. (11) is an online estimation problem; on loops whose workload distribution shifts, the stored bounds may go stale, and an adaptive-bounds variant would directly test whether reward normalization is the true bottleneck.
  • Editorial inference: if the expChunk-plus-RL combination generalizes beyond the six applications tested, the practical recipe for HPC users is to let expert-derived parameters guide exploration and let RL fine-tune the final algorithm choice, rather than using either approach alone.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 5 minor

Summary. This paper studies automatic selection of OpenMP loop scheduling algorithms for repeated-loop HPC applications. It compares three expert-based methods from the authors' prior Auto4OMP work (RandomSel, ExhaustiveSel, ExpertSel) with two novel model-free RL methods (Q-Learn and SARSA) embedded in the LB4OMP runtime, using two reward signals (loop time and load-imbalance LIB) with and without an expert chunk parameter. The evaluation is a factorial campaign covering six applications (Mandelbrot, STREAM Triad, Triangle Counting, HACCKernels, LULESH, SPHYNX) on three systems (Broadwell, Cascade-Lake, EPYC), 720 configurations and 3,600 executions with five repetitions. Performance is reported as degradation relative to an Oracle baseline. The main findings are that RL-based selection can match Oracle's choice after an expensive 144-instance explore-first phase when a loop-time reward is used, that LIB rewards perform poorly by over-prioritizing balance, and that combining expert knowledge via expChunk substantially improves both families.

Significance. The experimental campaign is a genuine strength: six diverse applications, three systems, 720 configurations, 3,600 executions, five repetitions, with data and scripts released ([27], [28]). The paper also exposes the exploration-cost trade-off and shows that reward design, not just the RL algorithm, is a first-order factor. If the RL reward and state definitions are clarified and the reported learning behavior is robust, the demonstration that online per-loop schedule selection can approach an oracle in repeated-loop applications is a useful contribution to OpenMP scheduling and algorithm selection.

major comments (3)
  1. [Section 3.5, Eq. 11] Equation (11) is not a normalization of the current metric to the observed range; it is a record-statistics reward: r+ is awarded only when x is a new running minimum, r- only when x is a new running maximum, and the fixed neutral r0 otherwise. Because min_t and max_t are taken over already executed loop instances, the same measured loop time or LIB yields different rewards depending on sampling order and on how many records have already been set. The manuscript also does not state how min_t and max_t are initialized for the first loop instance or how they are updated for non-stationary loops. With Q-values initialized to 0 and the stated rewards (+0.01, -2.0, -4.0), an action that sets a first record receives Q approximately 0.005 while a later neutral action receives Q approximately -1, so the Q-values encode order statistics rather than expected performance. Since all RL results in Figs. 7 and 8 depend on this reward, the paper's central claim that the agents 'learn high-performing scheduling decisions' is not supported as written; please either correct the reward definition or provide the exact implementation and show that the selections are insensitive to record order.
  2. [Section 3.5, Eqs. 9-10] The state s used in the Q-learning and SARSA updates is never defined. The only quantitative hint is that the Q-table contains 144 state-action combinations for a 12-algorithm portfolio, which suggests that s is the previously selected scheduling algorithm, but this is not stated anywhere. The description of the explore-first policy ('selects every scheduling algorithm ... considering all possible different orders' requiring 144 loop instances) is ambiguous for the same reason. Without a definition of s and s', Eqs. (9)-(10) cannot be instantiated, the experiment is not reproducible from the manuscript, and the post-learning selections reported in Figs. 7 and 8 cannot be attributed to a well-defined learning process.
  3. [Section 4.2, Fig. 5] The headline comparison in Fig. 5 reports only the median of five repetitions per cell, with no confidence intervals or statistical tests. Several quantitative claims in Section 4.2 rely on small differences, e.g., ExhaustiveSel with expChunk 'surpassed Oracle by 1.4%' for SPHYNX on EPYC, and the statement that 'Q-Learn and SARSA with LT reward and expChunk achieved similar performance.' Given that the same section reports coefficients of variation above 1 for STREAM Triad and LULESH, these differences may be within run-to-run noise. Please add dispersion measures or a statistical analysis (the ANOVA mentioned in Section 7 would be natural) or soften the affected claims.
minor comments (5)
  1. [Section 4.1, Table 2] Table 2 and the surrounding text label Mandelbrot's third loop inconsistently as L2 and L3; unify the notation.
  2. [Section 3.5, Eq. 11] Equation (11) has a stray closing parenthesis after max_t(x), and the subscripts min_t and max_t are not defined before use.
  3. [Section 4.2, Fig. 5] The color scale in Fig. 5 is clipped at 100% even though many degradation values exceed 100% (e.g., 15,673%); consider a logarithmic or two-scale visualization or annotate clipped cells.
  4. [Section 3.5] The statement that alpha decay 'prevents agents from ever selecting a single action' is unclear; a decaying learning rate does not by itself prevent convergence, so the intended mechanism should be explained.
  5. [Section 3.3 and Section 4.2] The definition of Oracle as a manually selected combination 'across ... time-step' should state explicitly whether Oracle is allowed to switch algorithms between time-steps, since Figs. 7 and 8 present it as a fixed selection in some panels.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the comparison is an empirical benchmark whose Oracle, expert, and RL baselines are independently defined, and no prediction reduces by construction to a fitted input.

full rationale

The paper's chain is experimental rather than derivational. The Oracle baseline is explicitly built from exhaustive separate executions of every portfolio algorithm, so it is not a fitted parameter that the other methods reproduce by construction. Expert-based methods are carried over from prior work and evaluated comparatively, not invoked as an external uniqueness or correctness argument. The RL methods use standard Q-Learn and SARSA update rules whose only custom element is the reward function in Eq. 11; although that running-min/max reward is underspecified and order-dependent, it is a learning signal, not a quantity that is algebraically identical to the paper's selection claims. The self-citations to LB4OMP, Auto4OMP, and expChunk are tool and heuristic provenance; no ansatz or uniqueness theorem is smuggled in by citation. The paper also explicitly reports limitations such as high exploration overhead, reward-type sensitivity, and the need for newer-hardware validation, which is consistent with an empirical study rather than a circular justification. Consequently, no specific step can be quoted where a predicted result equals its own input by construction, so the circularity score is 0.

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

No new physical or conceptual entities are introduced. The central dependencies are the hand-chosen RL hyperparameters, the expert-derived chunk parameter, the fixed scheduler portfolio, and the repeated-loop execution model. The reward normalization in Eq. 11 is the least specified piece and carries the most unstated burden.

free parameters (8)
  • RL learning rate alpha = 0.5
    Default in Sect. 3.5; configurable via KMP_RL_ALPHA. Affects convergence speed but is not fit to the data.
  • RL discount factor gamma = 0.5
    Default in Sect. 3.5; controls future reward weighting.
  • RL reward magnitudes = positive 0.01, neutral -2.0, negative -4.0
    Hand-chosen in Sect. 3.5; positive value is nonzero to distinguish a good action from the zero-initialized Q-table.
  • Alpha decay = 0.05
    Set in Sect. 3.5 to prevent the agent from fixing on a single action after learning.
  • Explore-first phase length = 144 loop instances
    In Sect. 3.5, required to try all state-action combinations; equals 28.8% of the 500 time-steps and dominates RL overhead.
  • RandomSel jump probability divisor = 10
    Pj = LIB/10 in Eq. 8; an empirically chosen constant from prior work [25].
  • ExhaustiveSel LIB retrigger threshold = 10%
    Sect. 3.2: re-trigger exhaustive search when imbalance varies 10% from average; empirical threshold.
  • expChunk golden-ratio parameter = phi=1.618 point on interval [N/(2P), ...]
    From prior work [25]; used in all expChunk variants. An expert-derived chunk size, not fitted to this study's data.
assumptions (5)
  • domain assumption Selection methods are evaluated only on time-stepping applications where the same loop executes many times.
    Stated in Sect. 5 and 7; RL needs 144 loop instances to learn, and expert methods also rely on repeated loop observations.
  • ad hoc to paper The reward normalization in Eq. 11 uses running min and max of past loop metrics and assumes these bounds are representative.
    Sect. 3.5 defines Rt(x) via min_t(x) and max_t(x) but does not specify initialization or handling of non-stationary loops.
  • domain assumption Loop execution time and load imbalance (LIB) are sufficient reward signals for scheduling quality.
    Sect. 3.5 and 4.3; the LIB reward fails because it ignores scheduling overhead, showing this assumption is only partially valid.
  • domain assumption The fixed 12-algorithm LB4OMP portfolio is the right search space.
    Sect. 3.1; all selection methods are constrained to this portfolio, and results may not generalize to other schedulers or chunk choices.
  • domain assumption Oracle, built from separate exhaustive runs, is a valid upper-bound baseline.
    Sect. 3.3; the authors acknowledge Oracle does not account for system variability and that automated methods can exceed it by about 1.4%.

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Comparative Study of OpenMP Scheduling Algorithm Selection Strategies." pith.science (2026). https://pith.science/paper/4BRJOSSG

@misc{pith2026250720312,
  author       = {Pith},
  title        = {Pith review of: A Comparative Study of OpenMP Scheduling Algorithm Selection Strategies},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/4BRJOSSG}},
  note         = {Machine review of arXiv:2507.20312}
}
read the original abstract

Scientific and data science applications are becoming increasingly complex, with growing computational and memory demands. Modern high performance computing (HPC) systems provide high parallelism and heterogeneity across nodes, devices, and cores. To achieve good performance, effective scheduling and load balancing techniques are essential. Parallel programming frameworks such as OpenMP now offer a variety of advanced scheduling algorithms to support diverse applications and platforms. This creates an instance of the scheduling algorithm selection problem, which involves identifying the most suitable algorithm for a given combination of workload and system characteristics. In this work, we explore learning-based approaches for selecting scheduling algorithms in OpenMP. We propose and evaluate expert-based and reinforcement learning (RL)-based methods, and conduct a detailed performance analysis across six applications and three systems. Our results show that RL methods are capable of learning high-performing scheduling decisions, although they require significant exploration, with the choice of reward function playing a key role. Expert-based methods, in contrast, rely on prior knowledge and involve less exploration, though they may not always identify the optimal algorithm for a specific application-system pair. By combining expert knowledge with RL-based learning, we achieve improved performance and greater adaptability. Overall, this work demonstrates that dynamic selection of scheduling algorithms during execution is both viable and beneficial for OpenMP applications. The approach can also be extended to MPI-based programs, enabling optimization of scheduling decisions across multiple levels of parallelism.

Figures

Figures reproduced from arXiv: 2507.20312 by the authors.

Figure 1
Figure 1. illustrates how chunk sizes evolve across work requests for the dynamic and non-adaptive scheduling algorithms when scheduling the main loop (L1) of SPHYNX Evrard collapse [10] (see Section 4.1 for more details) [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 2
Figure 2. Progression of chunk sizes for dynamic and adaptive techniques for scheduling the most time consuming loop (gravity calculation across particles) of SPHYNX with 1, 000, 000 loop iterations and 20 threads executed on an Intel Broadwell E5-2640 v4 (2 sockets, 10 cores each) CPU node. The chunk parameters here were also 781 and 3125 loop iterations. That is, any scheduling technique will not assign fewer than 781 or 31… view at source ↗
Figure 3
Figure 3. Scheduling in LB4OMPaugmented with RL-based selection of scheduling algorithms. [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Coefficient of variation (c.o.v.) per application-system pair considering the standard deviation of loop(s) execution time with every scheduling algorithm and chunk parameter divided by the average execution time of the loop(s). High c.o.v. values indicate that the app…
Figure 5
Figure 5. Figure 5: Comparison of expert- and RL-based scheduling algorithm selection methods in terms of performance degradation (%) relative to Oracle. The x-axis represents algorithm selection methods with or without the expChunkparameter and reward type (LT or LIB), while the y-axis l…
Figure 6
Figure 6. Figure 6: We selected STREAM Triad to deliberately highlight the challenges behind scheduling algorithm selection on scenarios where a single wrong choice can cause extreme performance degradation. SPHYNX Evrard collapse was selected to highlight the potential of scheduling algo…
Figure 6
Figure 6. Figure 6: Median parallel loop(s) execution time (s), top two plots show results for [PITH_FULL_IMAGE:figures/full_fig_p015_6.png]
Figure 7
Figure 7. Figure 7: Scheduling algorithms selected by the expert- and RL-based automated selection methods or by [PITH_FULL_IMAGE:figures/full_fig_p016_7.png]
Figure 8
Figure 8. Figure 8: Scheduling algorithms selected by the expert- and RL-based automated selection methods or by [PITH_FULL_IMAGE:figures/full_fig_p017_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

48 extracted references · 47 canonical work pages

  1. [27]

    H., Mohammed, A., Eleliemy, A., Guilloteau, Q., Krummenacher, R., and M

    M¨uller Kornd¨orfer, J. H., Mohammed, A., Eleliemy, A., Guilloteau, Q., Krummenacher, R., and M. Ciorba, F. Data, scripts, and plots for the paper ”Learning to Select Scheduling Algorithm in OpenMP”, Aug. 2024

    work page 2024

  2. [28]

    H., Mohammed, A., Eleliemy, A., and M

    M¨uller Kornd¨orfer, J. H., Mohammed, A., Eleliemy, A., and M. Ciorba, F. LB4OMP

    work page

  3. [1]

    The role of idle waves, desynchronization, and bottleneck evasion in the performance of parallel programs

    Afzal, A., Hager, G., and Wellein, G. The role of idle waves, desynchronization, and bottleneck evasion in the performance of parallel programs. IEEE Transactions on Parallel and Distributed Systems 34, 2 (2023), 15

    work page 2023

  4. [2]

    Are static schedules so bad? a case study on cholesky factorization

    Agullo, E., Beaumont, O., Eyraud-Dubois, L., and Kumar, S. Are static schedules so bad? a case study on cholesky factorization. In 2016 IEEE International Parallel and Distributed Processing Symposium (IPDPS) (2016), pp. 1021–1030

    work page 2016

  5. [3]

    M., and Srivastava, S

    Banicescu, I., Ciorba, F. M., and Srivastava, S. Scalable Computing: Theory and Practice . John Wiley & Sons, Inc, 2013, ch. Performance Optimization of Scientific Applications using an Autonomic Computing Approach, p. 29

    work page 2013

  6. [4]

    Adaptive Factoring: A Dynamic Scheduling Method Tuned to the Rate of Weight Changes

    Banicescu, I., and Liu, Z. Adaptive Factoring: A Dynamic Scheduling Method Tuned to the Rate of Weight Changes. In Proceedings of the High performance computing Symposium (2000), pp. 122–129

    work page 2000

  7. [5]

    On the Scalability of Dynamic Scheduling Scientific Applications with Adaptive Weighted Factoring

    Banicescu, I., Velusamy, V., and Devaprasad, J. On the Scalability of Dynamic Scheduling Scientific Applications with Adaptive Weighted Factoring. Journal of Cluster Computing 6 , 3 (2003), 215–226

    work page 2003

  8. [6]

    The gap benchmark suite

    Beamer, S., Asanovi ´c, K., and Patterson, D. The gap benchmark suite. arXiv preprint arXiv:1508.03619 (2015). 1Multilevel scheduling project: https://hpc.dmi.unibas.ch/research/mls/ 20

    arXiv 2015

Show all 48 references
  1. [7]

    The polyhedral model is more widely applicable than you think

    Benabderrahmane, M.-W., Pouchet, L.-N., Cohen, A., and Bastoul, C. The polyhedral model is more widely applicable than you think. In International Conference on Compiler Construction (2010), Springer, p. 20

    2010

  2. [8]

    D., and Leiserson, C

    Blumofe, R. D., and Leiserson, C. E. Scheduling Multithreaded Computations by Work Stealing. Journal of ACM (1999), 720–748

    1999

  3. [9]

    M., and Abdennadher, N

    Boulmier, A., Banicescu, I., Ciorba, F. M., and Abdennadher, N. An Autonomic Approach for the Selection of Robust Dynamic Loop Scheduling Techniques. In Proceedings of 16th International Symposium on Parallel and Distributed Computing (2017), p. 8

    2017

  4. [10]

    SPHYNX Website

    Cabezon, R. SPHYNX Website. https://astro.physik.unibas.ch/en/people/ruben-cabezon/sphynx/. Accessed: October 20, 2022

    2022

  5. [11]

    M., Garcia-Senz, D., and Figueira, J

    Cabez´on, R. M., Garcia-Senz, D., and Figueira, J. SPHYNX: An Accurate Density-based SPH Method for Astrophysical Applications. Journal of Astronomy & Astrophysics (2017), A78

    2017

  6. [12]

    M., Iwainsky, C., and Buder, P

    Ciorba, F. M., Iwainsky, C., and Buder, P. OpenMP loop scheduling revisited: Making a case for more schedules. In Evolving OpenMP for Evolving Architectures: 14th International Workshop on OpenMP, IWOMP (2018), pp. 21–36

    2018

  7. [13]

    M., Mohammed, A., Kornd ¨orfer, J

    Ciorba, F. M., Mohammed, A., Kornd ¨orfer, J. H. M., and Eleliemy, A. Automated scheduling algorithm selection in openmp. In 2023 22nd International Symposium on Parallel and Distributed Computing (ISPDC) (2023), pp. 106–109

    2023

  8. [14]

    Efficient model-based deep reinforcement learning with variational state tabulation

    Corneil, D., Gerstner, W., and Brea, J. Efficient model-based deep reinforcement learning with variational state tabulation. In International Conference on Machine Learning (2018), PMLR, pp. 1049–1058

    2018

  9. [15]

    da Silva, F. H. S., Fernandes, J. B., Sardina, I. M., Barros, T., de Souza, S. X., and Assis, I. A. Auto-tuning for openmp dynamic scheduling applied to full waveform inversion. Computers & Geosciences 202 (2025), 105932

    2025

  10. [16]

    Detecting application load imbalance on high end massively parallel systems

    DeRose, L., Homer, B., and Johnson, D. Detecting application load imbalance on high end massively parallel systems. In Euro-Par 2007 Parallel Processing: 13th International Euro-Par Conference, Rennes, France, August 28-31, 2007. Proceedings 13 (2007), Springer, pp. 150–159

    2007

  11. [17]

    HACCKernels

    Finkel, H. HACCKernels. https://git.cels.anl.gov/hacc/HACCKernels, 2018. Accessed: February 20, 2024

    2018

  12. [18]

    Flynn Hummel, S., Schonberg, E., and Flynn, L. E. Factoring: A Method for Scheduling Parallel Loops. ACM Journal of Communication 35 , 8 (1992), 90–101

    1992

  13. [19]

    Hacc: Simulating sky surveys on state-of-the-art supercomputing architectures

    Habib, S., Pope, A., Finkel, H., Frontiere, N., Heitmann, K., Daniel, D., Fasel, P., Morozov, V., Zagaris, G., Peterka, T., Vishwanath, V., Luki ´c, Z., Sehrish, S., and keng Liao, W. Hacc: Simulating sky surveys on state-of-the-art supercomputing architectures. New Astronomy ...

    2016

  14. [20]

    Karlin, I., Keasler, J., and Neely, J. R. Lulesh 2.0 updates and changes. Tech. rep., Lawrence Livermore National Lab.(LLNL), Livermore, CA (United States), 2013

    2013

  15. [21]

    M., and Banicescu, I

    Kasielke, F., Tsch ¨uter, R., Iwainsky, C., Velten, M., Ciorba, F. M., and Banicescu, I. Exploring Loop Scheduling Enhancements in OpenMP: An LLVM Case Study. In P. Intern. Symp. on Par. Dist. Comp. (Amsterdam, 2019)

    2019

  16. [22]

    P., and LeBlanc, T

    Markatos, E. P., and LeBlanc, T. J. Using processor affinity in loop scheduling on shared-memory multiprocessors. IEEE Transactions on Parallel and Distributed systems 5 , 4 (1994), 21

    1994

  17. [23]

    M., Broekens, J., Plaat, A., Jonker, C

    Moerland, T. M., Broekens, J., Plaat, A., Jonker, C. M., et al. Model-based reinforcement learning: A survey. Foundations and Trends® in Machine Learning 16 , 1 (2023), 1–118

    2023

  18. [24]

    Mohammed, A., and Ciorba, F. M. Simas: A simulation-assisted approach for the scheduling algorithm selection under perturbations. Concurrency and Computation: Practice and Experience 32 , 15 (2020), 15

    2020

  19. [25]

    H., Eleliemy, A., and Ciorba, F

    Mohammed, A., M ¨uller Kornd ¨orfer, J. H., Eleliemy, A., and Ciorba, F. M. Automated scheduling algorithm selection and chunk parameter calculation in openmp. IEEE Transactions on Parallel and Distributed Systems 33 (2022), 12. 21

    2022

  20. [26]

    H., Eleliemy, A., Mohammed, A., and Ciorba, F

    M¨uller Kornd¨order, J. H., Eleliemy, A., Mohammed, A., and Ciorba, F. M. LB4OMP: A Dynamic Load Balancing Library for Multithreaded Applications. IEEE Transactions on Parallel and Distributed Systems 33 , 4 (2022), 830–841

    2022

  21. [29]

    J., Gratl, F

    Newcome, S. J., Gratl, F. A., Lerchner, M., Pazar, A., Mishra, M. K., and Bungartz, H.-J. Algorithm selection in short-range molecular dynamics simulations, 2025

    2025

  22. [30]

    Processor Self-Scheduling for Multiple-Nested Parallel Loops

    Peiyi, T., and Pen-Chung, Y. Processor Self-Scheduling for Multiple-Nested Parallel Loops. In Proceedings of the International Conference on Parallel Processing (1986), pp. 528–535

    1986

  23. [31]

    Penna, P. H., A. Gomes, A. T., Castro, M., DM Plentz, P., C. Freitas, H., Broquedis, F., and M´ehaut, J.-F. A Comprehensive Performance Evaluation of the BinLPT Workload-aware Loop Scheduler. J. Concurrency & Computation: Practice & Experience (2019)

    2019

  24. [32]

    D., and Kuck, D

    Polychronopoulos, C. D., and Kuck, D. J. Guided Self-Scheduling: A Practical Scheduling Scheme for Parallel Supercomputers. IEEE Transactions on Computers C-36 , 12 (Dec. 1987), 1425–1439

    1987

  25. [33]

    Imagination-augmented agents for deep reinforcement learning

    Racani`ere, S., Weber, T., Reichert, D., Buesing, L., Guez, A., and et al. Imagination-augmented agents for deep reinforcement learning. In Advances in Neural Information Processing Systems (2017), I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and...

    2017

  26. [34]

    Model-free reinforcement learning from expert demonstrations: a survey

    Ram´ırez, J., Yu, W., and Perrusqu´ıa, A. Model-free reinforcement learning from expert demonstrations: a survey. Artificial Intelligence Review (2022), 1–29

    2022

  27. [35]

    Rice, J. R. The algorithm selection problem. In Advances in Computers, M. Rubinoff and M. C. Yovits, Eds., vol. 15 of Advances in Computers. Elsevier, 1976, pp. 65–118

    1976

  28. [36]

    R., and de Supinski, B

    Sreenivasan, V., Javali, R., Hall, M., Balaprakash, P., Scogland, T. R., and de Supinski, B. R. A framework for enabling openmp autotuning. In International Workshop on OpenMP (2019), Springer, p. 10

    2019

  29. [37]

    STREAM Microbenchmark

    STREAM. STREAM Microbenchmark. http://www.cs.virginia.edu/stream/ref.html. Accessed: March 29, 2023

    2023

  30. [38]

    S., and Barto, A

    Sutton, R. S., and Barto, A. G. Reinforcement Learning: An Introduction. Adaptive Computation and Machine Learning series. A Bradford Book, 1998

    1998

  31. [39]

    Graph500

    t. Graph500. https://graph500.org/. Accessed: April 10, 2024

    2024

  32. [40]

    Automatic openmp loop scheduling: a combined compiler and runtime approach

    Thoman, P., Jordan, H., Pellegrini, S., and Fahringer, T. Automatic openmp loop scheduling: a combined compiler and runtime approach. In International Workshop on OpenMP (2012), Springer, p. 12

    2012

  33. [41]

    Transfer learning

    Torrey, L., and Shavlik, J. Transfer learning. In Handbook of research on machine learning applications and trends: algorithms, methods, and techniques . IGI global, 2010, pp. 242–264

    2010

  34. [42]

    H., and Ni, L

    Tzen, T. H., and Ni, L. M. Trapezoid Self-scheduling: A Practical Scheduling Scheme for Parallel Compilers. IEEE Transactions on Parallel and Distributed Systems 4 , 1 (Jan. 1993), 87–98

    1993

  35. [43]

    J., and Dayan, P

    Watkins, C. J., and Dayan, P. Q-learning. Machine learning 8 (1992), 279–292

    1992

  36. [44]

    No free lunch theorems for optimization

    Wolpert, D., and Macready, W. No free lunch theorems for optimization. IEEE Transactions on Evolutionary Computation 1 , 1 (1997), 67–82

    1997

  37. [45]

    Chapter 7 - mathematical framework for algorithm analysis

    Yang, X.-S., He, X.-S., and Fan, Q.-W. Chapter 7 - mathematical framework for algorithm analysis. In Nature-Inspired Computation and Swarm Intelligence , X.-S. Yang, Ed. Academic Press, 2020, pp. 89–108

    2020

  38. [46]

    Zadeh, L. A. Fuzzy Sets. In Fuzzy sets, fuzzy logic, and fuzzy systems: selected papers by Lotfi A Zadeh . World Scientific, 1996, pp. 394–432. 22

    1996

  39. [47]

    Runtime Empirical Selection of Loop Schedulers on Hyperthreaded SMPs

    Zhang, Y., and Voss, M. Runtime Empirical Selection of Loop Schedulers on Hyperthreaded SMPs. In P. 19th IEEE International Parallel and Distributed Processing Symposium (Washington, DC, USA, 2005), IPDPS ’05, pp. 44.2–

    2005

  40. [48]

    Machine learning

    Zhou, Z.-H. Machine learning. Springer Nature, 2021. 23

    2021

Pith tools

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