Pith. sign in

REVIEW 4 major objections 6 minor 35 references

Evaluating the Efficacy of LLM-Based Reasoning for Multiobjective HPC Job Scheduling

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

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

Pith's one-line read A ReAct-style LLM scheduler can balance makespan, wait time, utilization, throughput, and fairness for small HPC workloads without retraining.

desk verdict The paper's first-of-its-kind LLM scheduling evaluation is worth a look, but the wait-time and fairness comparisons are invalidated by an internal contradiction in the problem setup. read the letter →

arxiv 2506.02025 v2 pith:K5LH4IHU submitted 2025-05-29 cs.DC cs.AI

Prachi Jadhav , Hongwei Jin , Ewa Deelman , Prasanna Balaprakash This is my paper
classification cs.DCcs.AI
keywords LargeLanguageModelsReActpromptingmultiobjectiveschedulingHPCjobscratchpadmemoryconstraintenforcementzero-shotreasoningJain'sfairnessindex
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

This paper tries to establish that a current reasoning LLM, prompted with a ReAct-style reason-and-act loop, can make multiobjective HPC job-scheduling decisions that compete with classical heuristics and an optimization solver on small workloads while explaining each decision in natural language. The authors evaluate O4-Mini and Claude 3.7 against FCFS, SJF, and Google OR-Tools over seven synthetic workload patterns and a 100-job real trace, and report that the LLM schedulers maintain balanced performance across makespan, wait time, utilization, throughput, and fairness without domain-specific training. Their advantage shows most clearly in heterogeneous, bursty, and long-job-dominated scenarios, where heuristics suffer convoy effects and OR-Tools trades fairness away for utilization. If true, this would give HPC operators an inspectable, zero-retraining scheduling option for small-to-medium batch workloads, while the paper's overhead measurements show that cloud-based reasoning APIs are too slow for real-time scheduling today.

What carries the argument

The load-bearing mechanism is the ReAct (Reason+Act) loop augmented with a scratchpad. At each decision point, the LLM receives a text prompt containing the current system state, the waiting jobs with their resource demands, and a running scratchpad that logs prior thoughts, actions, and feedback; it responds with a Thought and one of StartJob, BackfillJob, Delay, or Stop. A separate constraint-enforcement module (the discrete-event simulator) checks the proposed action against node and memory capacities, executes it if feasible, and otherwise returns natural-language feedback that is appended to the scratchpad. This design separates the LLM's reasoning from feasibility guarantees and gives the agent memory and self-correction without any fine-tuning.

What would settle it

Re-run the same seven workload scenarios and the 100-job Polaris trace with OR-Tools configured to maximize a weighted objective that includes Jain's fairness index; if that version attains LLM-level fairness without sacrificing utilization or throughput, the paper's central comparison collapses because the LLM advantage becomes a baseline-configuration artifact.

Watch

Extended reading notes

Core claim

The authors claim that separating LLM reasoning from constraint enforcement is what makes zero-shot scheduling work: the LLM proposes actions, a discrete-event simulator validates feasibility, and rejected actions generate natural-language feedback that is appended to the agent's scratchpad for later steps. On seven workload scenarios with 10 to 100 jobs, they observe that OR-Tools achieves the highest utilization and throughput but degrades wait-time and user-level fairness, while the LLM schedulers keep all objectives in balance; in Long Job Dominant and Bursty Idle scenarios, the LLMs sharply reduce wait and turnaround times relative to FCFS and SJF. In the Heterogeneous Mix at 80-100 jobs, Claude 3.7 and O4-Mini maintain throughput around 1.4x and utilization above 1.4x versus FCFS while preserving fairness, whereas OR-Tools reaches higher utilization (up to about 1.8x) at the cost of worse wait and turnaround times. On the 100-job Polaris trace, the LLM schedulers match OR-Tools on latency-related metrics while keeping utilization on par with baselines. The authors also find that overhead grows with queue size, with Claude 3.7 faster and more stable than O4-Mini, and conclude that current cloud-based LLM services are not viable for real-time scheduling but may suit batch or periodic optimization.

Load-bearing premise

The central claim rests on the unstated premise that the baselines, especially OR-Tools, were configured in a way that makes the multiobjective comparison fair; because the paper never specifies what objective OR-Tools was set to optimize, the fairness gap between OR-Tools and the LLMs could be an artifact of baseline setup rather than a property of LLM reasoning.

Editorial extensions

If this is right

  • If the central claim holds, zero-shot LLM schedulers can serve as interpretable alternatives for small-to-medium batch scheduling windows, where knowing why each job was chosen matters more than sub-second latency.
  • The advantage is workload-dependent: LLM reasoning pays off in heterogeneous, bursty, and long-job-dominated mixes, while homogeneous or resource-sparse workloads leave little room for improvement over simple heuristics.
  • Constraint satisfaction is guaranteed by the simulator rather than by the model, so the scheduler remains safe even when the LLM proposes infeasible actions.
  • The reported overhead implies that practical deployment today would be limited to periodic or strategic scheduling decisions, or to on-premises fast reasoning models, rather than to online real-time job submission.
  • The successful transfer to a 100-job Polaris trace, under an assumed idle initial state, suggests the framework generalizes from synthetic logs to real job histories without retraining.

Reading between the lines

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

  • The paper measures 'balance' qualitatively across normalized metrics rather than as a formal Pareto front; a natural extension would be to convert the seven objectives into a scalar or Pareto evaluation and test whether LLM choices are actually on the frontier.
  • Because the paper never states what objective OR-Tools was configured to optimize, an immediate test is to rerun the comparison with a fairness-aware OR-Tools objective; if that configuration closes the fairness gap, the LLM advantage is partly an artifact of baseline setup.
  • The observation that per-call latency, not call count, drives overhead suggests a cheap extension: route only the hardest decision steps to a slow reasoning model and let a fast heuristic handle routine steps, which could cut wall-clock time without losing the balance reported here.
  • The scratchpad mechanism is a kind of in-context learning, so a testable sequel is to feed the agent explicit per-user fairness statistics and ask it to rebalance, which may amplify the fairness gains already observed in the real-trace experiment.
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 / 6 minor

Summary. The paper proposes an LLM-based HPC job scheduler using a ReAct-style reasoning loop with a persistent scratchpad memory and a separate constraint-enforcement module. The authors evaluate OpenAI's O4-Mini and Anthropic's Claude 3.7 against FCFS, SJF, and Google OR-Tools on seven synthetic workload scenarios with 10 to 100 jobs, on a five-run robustness study, and on a 100-job segment of the Polaris workload trace. The central claims are that the LLM schedulers balance makespan, wait time, utilization, throughput, and fairness without domain-specific training, that they provide transparent natural-language reasoning traces, and that their main limitation is computational overhead.

Significance. If the central claims were fully supported, this would be a useful early empirical study of reasoning-capable LLMs for HPC scheduling. The paper has notable strengths: the authors release code, prompts, and configurations publicly, they provide representative reasoning traces that make the decision process transparent, they evaluate on a real workload trace, and they openly discuss the overhead barrier to real-time deployment. However, the quantitative support for the headline 'balanced multiobjective scheduling' claim is currently compromised by an internally inconsistent definition of wait time, an impossible zero-wait-time report, and an underspecified OR-Tools baseline. These issues affect Figures 3, 4, 7, and 8 and the abstract's claims, so the paper needs substantial revision before its empirical conclusions can be accepted.

major comments (4)
  1. [3.1, 3.2, 3.3] Section 3.1 states that jobs arrive dynamically over time following Poisson processes with scenario-specific arrival rates, whereas Section 3.2 defines average wait time as w_j = x_j 'since all s_j = 0' and Section 3.3 states that all n jobs are submitted simultaneously at time s_j = 0. These are incompatible descriptions of the same experiments. If arrivals are dynamic, the wait-time formula is incorrect; if arrivals are simultaneous, the event-driven arrival process described in Section 3.1 was not used for the reported wait-time results. Please disambiguate the arrival model and recompute wait time and Jain's fairness indices under the correct definition.
  2. [3.5] The statement that 'the average wait time for all methods, including FCFS, was 0.0' is impossible under the resource constraints of Section 3.3 for contended scenarios. In Long Job Dominant and Adversarial, jobs requesting 128 nodes cannot all start at time 0, so FCFS wait times must be positive for at least some jobs, and the average wait time cannot be zero. Omitting wait time from the normalized comparison because of this value invalidates the wait-time and fairness conclusions drawn in Section 3.5, including the claims of reduced wait time for LLM schedulers and OR-Tools' fairness degradation.
  3. [3.3] The OR-Tools baseline is described only as 'an optimization-based scheduling solution' that computes globally optimal or near-optimal schedules; the objective function, constraints, and solver configuration are not stated anywhere in the paper. The recurring claim that OR-Tools maximizes utilization at the expense of fairness is not interpretable without knowing the scalar objective it was configured to optimize. Please specify the OR-Tools model (objective, constraints, variable definitions) or point to the exact code in the public repository.
  4. [3.7] The overhead analysis is internally inconsistent: Section 3.7.1 excludes delay calls from the measurements, Section 3.7.3 says scheduling times range from 1-2 hours for 100 jobs, and Figure 6's caption reports 4,000 s (O4-Mini) and 700 s (Claude 3.7) at 100 jobs, with a 6.9k s spike at 80 jobs. Deployment conclusions should be based on total wall-clock time including all LLM queries, and the stated ranges should match the reported data.
minor comments (6)
  1. [Abstract] The abstract writes 'FJFS' where FCFS is meant; please correct the typo.
  2. [Figure 7] The caption contains the typo 'perofrmance'; please fix it.
  3. [3.7.3] 'on-perm' should be 'on-premises'.
  4. [3.2] The notation in the turnaround-time formula is unclear; x_j d_j could be read as a product, but the surrounding text suggests it means the completion time x_j + d_j. Please define it explicitly.
  5. [3.5] 'BurstyIdle' should be 'Bursty + Idle' for consistency with Section 3.1.
  6. [5] The sentence 'Claude 3.7, Or-Tools achieves the highest wait time fairness' is missing punctuation or a verb; please clarify which method achieves the highest fairness.

Circularity Check

1 steps flagged · score 3.0 of 10

The advertised constraint-satisfaction advantage is guaranteed by the simulator's validation module, while the core comparisons against FCFS, SJF, and OR-Tools remain externally grounded.

  1. self definitional [Abstract; Section 2.4 (Constraint Enforcement)]
    "The method excels in constraint satisfaction ... To ensure validity: the simulator validates each LLM-suggested action; feasible actions are executed; invalid ones are rejected; violations (e.g., memory overflow) are explained in natural language."

    The framework's constraint-enforcement module is defined so that no invalid action can enter the schedule: feasible actions are executed, invalid ones are rejected, and violations are only appended as feedback. Consequently, the top-line claim that the LLM scheduler 'excels in constraint satisfaction' follows directly from the system definition rather than from a measured comparison. Any LLM (or random proposer) placed behind the same validator would exhibit the same property, so the claim does not empirically distinguish the proposed scheduler from the baselines. The core multiobjective comparisons against FCFS, SJF, and OR-Tools remain independent of this step, so the circularity is limited to this advertised advantage.

full rationale

The derivation chain is otherwise self-contained. The scheduler is evaluated zero-shot against external baselines (FCFS, SJF, Google OR-Tools) and real Polaris workload traces; no parameter is fitted to the target metrics, and the central makespan/wait-time/utilization/fairness comparisons are not forced by construction. The paper does not rely on a load-bearing self-citation chain: ReAct, OR-Tools, Jain's index, and the trace source are all external references. The only step that reduces to its own inputs is the constraint-satisfaction claim, which is guaranteed by the validator in Section 2.4 and restated as an achievement in the abstract. Separately, and not itself a circularity, Sections 3.1/3.2/3.5 contain an internal inconsistency: Section 3.1 says jobs arrive via Poisson processes, Section 3.2 defines average wait time as w_j = x_j because all s_j = 0, and Section 3.5 reports average wait time of 0.0 for all methods and omits it from normalization. This undermines the interpretability of the wait-time comparisons but does not make any claimed prediction equivalent to its inputs.

Assumptions & free parameters 1 free parameters · 3 assumptions · 0 invented entities

No fitted parameters in the sense of fitting to outcomes; the workload arrival rates are scenario-design inputs. The evaluation rests on domain assumptions about the simulator, the baseline configuration, and the representativeness of the synthetic and real workloads.

free parameters (1)
  • Per-scenario job arrival rate lambda = not reported
    Each of the seven synthetic scenarios uses a scenario-specific Poisson arrival rate to generate workloads; these rates shape the evaluation instances but are not fitted to performance outcomes, so they are experimental design choices rather than parameters tuned to support the conclusion.
assumptions (3)
  • domain assumption All synthetic jobs arrive at time s_j=0 (simultaneous submission).
    Invoked in Section 3.3 problem setup and used in the formulation; conflicts with the text's claim of dynamic job arrival and makes reported wait times of 0 suspicious.
  • domain assumption First-fit allocation and simplified cluster model (no topology, storage) are sufficient to evaluate high-level scheduling decisions.
    Stated in Section 3.3; results may not transfer to production schedulers where placement constraints matter.
  • domain assumption OR-Tools is a valid strong baseline for multiobjective comparison.
    Section 3.3 uses OR-Tools as near-optimal without specifying its objective function, so the baseline's behavior may reflect a single-objective optimization rather than a multiobjective one.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Evaluating the Efficacy of LLM-Based Reasoning for Multiobjective HPC Job Scheduling." pith.science (2026). https://pith.science/paper/K5LH4IHU

@misc{pith2026250602025,
  author       = {Pith},
  title        = {Pith review of: Evaluating the Efficacy of LLM-Based Reasoning for Multiobjective HPC Job Scheduling},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/K5LH4IHU}},
  note         = {Machine review of arXiv:2506.02025}
}
read the original abstract

High-Performance Computing (HPC) job scheduling involves balancing conflicting objectives such as minimizing makespan, reducing wait times, optimizing resource use, and ensuring fairness. Traditional methods, including heuristic-based, e.g., First-Come-First-Served (FJFS) and Shortest Job First (SJF), or intensive optimization techniques, often lack adaptability to dynamic workloads and, more importantly, cannot simultaneously optimize multiple objectives in HPC systems. To address this, we propose a novel Large Language Model (LLM)-based scheduler using a ReAct-style framework (Reason + Act), enabling iterative, interpretable decision-making. The system incorporates a scratchpad memory to track scheduling history and refine decisions via natural language feedback, while a constraint enforcement module ensures feasibility and safety. We evaluate our approach using OpenAI's O4-Mini and Anthropic's Claude 3.7 across seven real-world HPC workload scenarios, including heterogeneous mixes, bursty patterns, and adversarial cases etc. Comparisons against FCFS, SJF, and Google OR-Tools (on 10 to 100 jobs) reveal that LLM-based scheduling effectively balances multiple objectives while offering transparent reasoning through natural language traces. The method excels in constraint satisfaction and adapts to diverse workloads without domain-specific training. However, a trade-off between reasoning quality and computational overhead challenges real-time deployment. This work presents the first comprehensive study of reasoning-capable LLMs for HPC scheduling, demonstrating their potential to handle multiobjective optimization while highlighting limitations in computational efficiency. The findings provide insights into leveraging advanced language models for complex scheduling problems in dynamic HPC environments.

Figures

Figures reproduced from arXiv: 2506.02025 by the authors.

Figure 1
Figure 1. LLM-based HPC scheduling with ReAct-style rea [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Representative LLM reasoning traces demonstrating interpretable scheduling decisions. The traces show multiobjective [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Normalized performance metrics across six workload scenarios with 60 jobs each. All metrics are normalized relative [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Scalability analysis showing normalized performance metrics across increasing job queue sizes (10 to 100 jobs) for the [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: Computational overhead comparison across six workload scenarios. Metrics include total elapsed time (left), number [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: LLM computational Overhead scaling with job queue size for Heterogeneous Mix workloads. Scheduling time grows [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]
Figure 7
Figure 7. Figure 7: Distribution of normalized perofrmance metrics for the Heterogeneous Mix workload with 100 jobs over 5 independent [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]
Figure 8
Figure 8. Figure 8: Normalized performance metrics for 100 Polaris job logs. LLM-based schedulers reduce latency and improve fairness [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

35 extracted references · 29 canonical work pages

  1. [1]

    Q. Wang, H. Zhang, C. Qu, Y. Shen, X. Liu, and J. Li, ``Rlschert: An hpc job scheduler using deep reinforcement learning and remaining time prediction,'' Applied Sciences, vol. 11, no. 20, p. 9448, 2021

    work page 2021

  2. [2]

    Abdurahman, A

    A. Abdurahman, A. Hossain, K. A. Brown, K. Yoshii, and K. Ahmed, ``Scalable hpc job scheduling and resource management in sst,'' in 2024 Winter Simulation Conference (WSC). 1em plus 0.5em minus 0.4em IEEE, 2024, pp. 2226--2237

    work page 2024

  3. [3]

    B. Li, Y. Fan, M. Dearing, Z. Lan, P. Rich, W. Allcock, and M. Papka, ``Mrsch: Multi-resource scheduling for hpc,'' in 2022 IEEE International Conference on Cluster Computing (CLUSTER). 1em plus 0.5em minus 0.4em IEEE, 2022, pp. 47--57

    work page 2022

  4. [4]

    Srinivasan, R

    S. Srinivasan, R. Kettimuthu, V. Subramani, and P. Sadayappan, ``Characterization of backfilling strategies for parallel job scheduling,'' in Proceedings. International Conference on Parallel Processing Workshop. 1em plus 0.5em minus 0.4em IEEE, 2002, pp. 514--519

    work page 2002

  5. [5]

    A. V. Goponenko, K. Lamar, C. Peterson, B. A. Allan, J. M. Brandt, and D. Dechev, ``Metrics for packing efficiency and fairness of hpc cluster batch job scheduling,'' in 2022 IEEE 34th International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD). 1em plus 0.5em minus 0.4em IEEE, 2022, pp. 241--252

    work page 2022

  6. [6]

    Wang, ``A tutorial on llm reasoning: Relevant methods behind chatgpt o1,'' arXiv preprint arXiv:2502.10867, 2025

    J. Wang, ``A tutorial on llm reasoning: Relevant methods behind chatgpt o1,'' arXiv preprint arXiv:2502.10867, 2025

    arXiv 2025

  7. [7]

    Kayabali, ``Anthropic's claude 3.7 sonnet hybrid reasoning model is now available in amazon bedrock,'' 2025

    E. Kayabali, ``Anthropic's claude 3.7 sonnet hybrid reasoning model is now available in amazon bedrock,'' 2025. [Online]. Available: https://aws.amazon.com/blogs/aws/anthropics-claude-3-7-sonnet-the-first-hybrid-reasoning-model-is-now-available-in-amazon-bedrock/

    work page 2025

  8. [8]

    S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, ``React: Synergizing reasoning and acting in language models,'' in International Conference on Learning Representations (ICLR), 2023

    work page 2023

Show all 35 references
  1. [9]

    Blazewicz, K

    J. Blazewicz, K. Ecker, E. Pesch, G. Schmidt, and J. Weglarz, Handbook on scheduling. 1em plus 0.5em minus 0.4em Springer, 2019

    2019

  2. [10]

    Zhao and J

    W. Zhao and J. A. Stankovic, ``Performance analysis of fcfs and improved fcfs scheduling algorithms for dynamic real-time computer systems,'' in 1989 Real-Time Systems Symposium, 1989, pp. 156--157

    1989

  3. [11]

    T. A. Simon, P. Nguyen, and M. Halem, ``Multiple objective scheduling of hpc workloads through dynamic prioritization,'' UMBC Student Collection, 2013

    2013

  4. [12]

    Mirjalili and S

    S. Mirjalili and S. Mirjalili, ``Genetic algorithm,'' Evolutionary algorithms and neural networks: Theory and applications, pp. 43--55, 2019

    2019

  5. [13]

    Bertsimas and J

    D. Bertsimas and J. Tsitsiklis, ``Simulated annealing,'' Statistical science, vol. 8, no. 1, pp. 10--15, 1993

    1993

  6. [14]

    D. Wang, D. Tan, and L. Liu, ``Particle swarm optimization algorithm: an overview,'' Soft computing, vol. 22, no. 2, pp. 387--408, 2018

    2018

  7. [15]

    Blum and A

    C. Blum and A. Roli, ``Metaheuristics in combinatorial optimization: Overview and conceptual comparison,'' ACM computing surveys (CSUR), vol. 35, no. 3, pp. 268--308, 2003

    2003

  8. [16]

    J. Yin, J. Hines, E. Herron, T. Ghosal, H. Liu, S. Prentice, V. Lama, and F. Wang, ``chathpc: Empowering hpc users with large language models,'' The Journal of Supercomputing, vol. 81, no. 1, p. 194, 2025

    2025

  9. [17]

    B. Zhu, C. Chen, X. Fan, and Y. Zhu, ``Llmsched: Uncertainty-aware workload scheduling for compound llm applications,'' arXiv preprint arXiv:2504.03444, 2025

    2025 arXiv

  10. [18]

    Amayuelas, J

    A. Amayuelas, J. Yang, S. Agashe, A. Nagarajan, A. Antoniades, X. E. Wang, and W. Wang, ``Self-resource allocation in multi-agent llm systems,'' arXiv preprint arXiv:2504.02051, 2025

    2025 arXiv

  11. [19]

    L. Chen, N. K. Ahmed, A. Dutta, A. Bhattacharjee, S. Yu, Q. I. Mahmud, W. Abebe, H. Phan, A. Sarkar, B. Butler et al., ``The landscape and challenges of hpc research and llms,'' arXiv preprint arXiv:2402.02018, 2024

    2024 arXiv

  12. [20]

    L. Wang, C. Ma, X. Feng, Z. Zhang, H. Yang, J. Zhang, Z. Chen, J. Tang, X. Chen, Y. Lin et al., ``A survey on large language model based autonomous agents,'' Frontiers of Computer Science, vol. 18, no. 6, p. 186345, 2024

    2024

  13. [21]

    Y. Fu, S. Zhu, R. Su, A. Qiao, I. Stoica, and H. Zhang, ``Efficient llm scheduling by learning to rank,'' in The Thirty-eighth Annual Conference on Neural Information Processing Systems, 2024

    2024

  14. [22]

    T. P. Ferraz, K. Mehta, Y.-H. Lin, H.-S. Chang, S. Oraby, S. Liu, V. Subramanian, T. Chung, M. Bansal, and N. Peng, ``Llm self-correction with decrim: Decompose, critique, and refine for enhanced following of instructions with multiple constraints,'' arXiv preprint arXiv:2410....

    arXiv

  15. [23]

    Tantakoun, X

    M. Tantakoun, X. Zhu, and C. Muise, ``Llms as planning modelers: A survey for leveraging large language models to construct automated planning models,'' arXiv preprint arXiv:2503.18971, 2025

    2025

  16. [24]

    [Online]

    OpenAI, ``Learning to reason with llms,'' 2024. [Online]. Available: https://openai.com/index/learning-to-reason-with-llms/

    2024

  17. [25]

    [Online]

    WandB, ``Evaluating claude 3.7 sonnet: Performance, reasoning, and cost optimization,'' 2025. [Online]. Available: https://wandb.ai/byyoung3/Generative-AI/reports/Evaluating-Claude-3-7-Sonnet-Performance-reasoning-and-cost-optimization--VmlldzoxMTYzNDEzNQ

    2025

  18. [26]

    Naghshnejad and M

    M. Naghshnejad and M. Singhal, ``A hybrid scheduling platform: a runtime prediction reliability aware scheduling platform to improve hpc scheduling performance,'' The Journal of Supercomputing, vol. 76, pp. 122--149, 2020

    2020

  19. [27]

    Englert, D

    M. Englert, D. \"O zmen, and M. Westermann, ``The power of reordering for online minimum makespan scheduling,'' in 2008 49th Annual IEEE Symposium on Foundations of Computer Science. 1em plus 0.5em minus 0.4em IEEE, 2008, pp. 603--612

    2008

  20. [28]

    Smith, V

    W. Smith, V. Taylor, and I. Foster, ``Using run-time predictions to estimate queue wait times and improve scheduler performance,'' in Job Scheduling Strategies for Parallel Processing: IPPS/SPDP’99Workshop, JSSPP’99 San Juan, Puerto Rico, April 16, 1999 Proceedings 5. 1em plus...

    1999

  21. [29]

    Mekkittikul and N

    A. Mekkittikul and N. McKeown, ``A practical scheduling algorithm to achieve 100\

  22. [30]

    M. Lee, S. Song, J. Moon, J. Kim, W. Seo, Y. Cho, and S. Ryu, ``Improving gpgpu resource utilization through alternative thread block scheduling,'' in 2014 IEEE 20th international symposium on high performance computer architecture (HPCA). 1em plus 0.5em minus 0.4em IEEE, 2014...

    2014

  23. [31]

    Ajtai, J

    M. Ajtai, J. Aspnes, M. Naor, Y. Rabani, L. J. Schulman, and O. Waarts, ``Fairness in scheduling,'' Journal of Algorithms, vol. 29, no. 2, pp. 306--357, 1998

    1998

  24. [32]

    A. B. Sediq, R. H. Gohary, R. Schoenen, and H. Yanikomeroglu, ``Optimal tradeoff between sum-rate efficiency and jain's fairness index in resource allocation,'' IEEE Transactions on Wireless Communications, vol. 12, no. 7, pp. 3496--3509, 2013

    2013

  25. [33]

    Perron and V

    L. Perron and V. Furnon, ``Or-tools,'' Google. [Online]. Available: https://developers.google.com/optimization/

  26. [34]

    K. C. Adimora and H. Sun, ``Gnn-rl: An intelligent hpc resource scheduler,'' 2024

    2024

  27. [35]

    ) , \`FU 0 *E UnҸ Zm ݙYrO;( N-?μ͛هLrs/_ a:a B &qgD_'L;Hw İe6Cv8 7 O.N plqvĤ g<b_m 9C .[bIm Ė Ń^ [ F]]2

    11em plus .33em minus .07em 4000 4000 100 4000 4000 500 `\.=1000 = #1 \@IEEEnotcompsoconly \@IEEEcompsoconly #1 * [1] 0pt [0pt][0pt] #1 * [1] 0pt [0pt][0pt] #1 * \| ** #1 \@IEEEauthorblockNstyle \@IEEEcompsocnotconfonly \@IEEEauthorblockAstyle \@IEEEcompsocnotconfonly \@IEEEco...

Pith tools

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