Pith. sign in

REVIEW 3 major objections 7 minor 39 references

GrapheonRL: A Graph Neural Network and Reinforcement Learning Framework for Constraint and Data-Aware Workflow Mapping and Scheduling in Heterogeneous HPC Systems

T0 review · 3 major / 7 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 The paper claims that GrapheonRL, a graph-neural-network and reinforcement-learning scheduler, reproduces MILP-optimal makespans for heterogeneous HPC workflows at near-heuristic execution speed, adapting to changed constraints through…

desk verdict GNN-RL scheduling framework with a load-bearing speed claim contradicted by its own Table III; worth refereeing but the evaluation as written does not support the central claims. read the letter →

arxiv 2506.00260 v1 pith:J5F56YXB submitted 2025-05-30 cs.DC cs.ET

Aasish Kumar Sharma , Julian Kunkel This is my paper
classification cs.DCcs.ET
keywords heterogeneousHPCworkflowschedulingtaskmappinggraphneuralnetworksreinforcementlearningproximalpolicyoptimizationmakespanMILPbaseline
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 proposes GrapheonRL, a scheduler that uses a graph neural network to encode workflow dependencies and resource requirements and a reinforcement-learning agent to choose which task runs on which node. The central claim is that, once trained, this policy produces makespans equal to those of an integer-linear-programming optimal solver on the workflows tested, while avoiding the solver's exponential growth: the authors report 76% faster inference than ILP and only 3.85 times slower decisions than the fastest heuristic. The motivation is that exact solvers become infeasible as workflows grow and heuristics ignore constraints, so a learned policy that respects dependencies, feature compatibility, and data-transfer costs would be a practical middle path. If the claim holds, GrapheonRL would let heterogeneous HPC systems schedule large, changing workloads without reformulating an optimization model each time.

What carries the argument

The central machinery is GrapheonRL: a graph neural network encoder feeding a Proximal Policy Optimization (PPO) agent in a single unified environment. The GNN maps the workflow DAG plus node resource attributes into node embeddings; the agent's action space is every (task, node) pair, restricted by a validity mask that blocks already-assigned tasks, unsatisfied dependencies, feature mismatches, and infeasible resource overlaps. Time-based concurrency is checked by testing whether a candidate assignment's resource usage overlaps in real time with existing node schedules. The reward function is the carrier of all constraints: penalties of 5 to 20 for violations, a positive assignment bonus of 15 minus duration plus a resource factor, a final bonus of 30 minus makespan, and a large penalty for episodes that run out of steps with tasks unassigned. This reward design is what lets the authors claim constraints can be changed or added without reformulating an integer program.

What would settle it

Time MILP and trained GNN-RL on a held-out workflow DAG the policy never saw during training, and compare makespan and constraint satisfaction; the paper's own table also invites the arithmetic check that its 89-task MILP solve (0.43 seconds) is faster than its reported GNN-RL inference (1.81 seconds), so a specified baseline for '76% faster' is needed.

Watch

Extended reading notes

Core claim

On its own terms, the paper's discovery is that a single environment that encodes tasks and nodes as one graph, plus a PPO agent with constraint-shaped rewards, can learn to schedule HPC workflows optimally with respect to makespan. The GNN produces per-task embeddings that summarize dependencies and resource demands; the policy then picks valid (task, node) assignments under an action mask, and the reward function punishes constraint violations and rewards shorter completion. The paper reports MILP-matching makespans across four real workflows, including an 89-task robot-control graph scoring 569, equal to MILP, and across synthetic workflows up to 10,000 tasks, where it matches OLB's makespan while HEFT is said to stall. The implication the authors draw is that scheduling quality need not be traded against scalability: the model generalizes across workflow sizes and adapts to new constraints by editing reward terms rather than rebuilding the solver.

Load-bearing premise

The load-bearing premise is that a policy trained on a workflow also schedules that same workflow, or structurally similar ones, well at test time; the paper reports training and testing on the same DAGs, so cross-workflow generalization is asserted but not demonstrated.

Editorial extensions

If this is right

  • Workflows too large for an exact solver can be scheduled with MILP-matching makespan using a trained policy, so schedule quality need not be sacrificed for scalability.
  • Changing HPC constraints (cores, memory, features, data-transfer costs) becomes an edit to reward shaping rather than a reformulation of an integer program, which makes the scheduler easier to maintain as systems evolve.
  • The one-time training cost, about 176 seconds for the 89-task case, is amortized at deployment, where inference takes 1.81 seconds, supporting offline training for online scheduling.
  • At 10,000-task scale the paper reports GNN-RL and OLB both reaching makespan 189, while HEFT is said to fail at scale, making learned schedulers the constraint-aware option at extreme scale.

Reading between the lines

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

  • The printed speed comparison needs scrutiny: in the paper's Table III the 89-task MILP solve takes 0.43 seconds while GNN-RL inference takes 1.81 seconds, so the abstract's '76% faster' cannot refer to this table unless a different baseline, such as total training amortization or a time-limited exact solve, is intended.
  • Because train and test phases appear to use the same workflow DAGs, the adaptability claim would be sharpened by a held-out evaluation: train on several workflow families and test on a structurally different DAG, which is a direct next experiment.
  • The same GNN/PPO core could be reused for multi-objective scheduling, such as energy, fairness, or throughput, by reweighting reward terms, so the method's main contribution may be the constraint-as-reward pattern rather than the specific makespan results.
  • A fairer scalability comparison would include a time-limited exact solver at 1,000 and 10,000 tasks; without that, 'optimal' at scale is only demonstrated relative to the two heuristics.
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

3 major / 7 minor

Summary. The paper proposes GrapheonRL, a GNN-RL framework for constraint- and data-aware workflow mapping and scheduling in heterogeneous HPC systems. The method models workflows as DAGs, uses a GNN to embed task dependencies and resource requirements, and trains a PPO agent to assign tasks to nodes while enforcing resource, feature, and dependency constraints. The authors compare against MILP, HEFT, and OLB on four standard task graph workflows and on synthetic scale tests, claiming that GrapheonRL matches MILP makespan while being "76 percent faster" and only 3.85x slower than OLB. The paper also claims generalization across workflows and scalability to 10,000 tasks.

Significance. If the empirical claims were correct, the work would offer a practical approach to large-scale workflow scheduling that combines the optimality of mathematical programming with the speed of learned policies. The methodological combination of GNN embeddings with PPO and explicit constraint-aware reward shaping is a reasonable direction, and the authors benchmark against standard baselines (MILP, HEFT, OLB) using a recognized task graph set. However, the central quantitative claims are internally contradicted by the paper's own tables, and the generalization evidence is missing. These issues are load-bearing because the abstract and conclusion rest on the "76% faster" and "3.85x slower" numbers, and the scalability story depends on a HEFT implementation that appears faulty.

major comments (3)
  1. [§V-C1, Table III, Workflow 4] The claim that GNN-RL inference is "76% faster" than MILP is contradicted by the paper's own Table III. For the Robot Control STG (Workflow 4), GNN-RL-Test takes 1.81 s while MILP takes 0.43 s, making GNN-RL about 4.2 times slower, not faster. The ratio 0.43/1.81 = 0.238 means MILP is 76% faster than GNN-RL, which is the opposite of the stated claim. The same inverted statement appears in the abstract, Section V-C1, and Section VII, so this is not a typo local to one sentence. This invalidates the central claim of "drastically reduced execution times" relative to MILP.
  2. [Table IV and §V-C3 / §VI-A2] The HEFT results in Table IV show a makespan of 10 for every scale from 10x10 to 10000x10000, while GNN-RL and OLB produce makespans from 41 to 189. A constant makespan of 10 across problem sizes strongly suggests a bug in the HEFT implementation or its makespan calculation, rather than a genuine scheduling result. Consequently, the claims that "HEFT is 94.7% worse than optimal" and "HEFT fails at scale" are unsupported by valid experimental evidence, and the comparison against heuristics is compromised.
  3. [§V-B, §IV-E3, §I-A] No train/test split is described for the GNN-RL experiments. The per-workflow results labeled GNN-RL-Train-Test and GNN-RL-Test appear to train and test on the same workflow DAG; there is no indication that a model trained on one workflow is evaluated on a different, held-out workflow. The abstract claims the method "effectively adapts to different workflows," but generalization to unseen workflow graphs is not demonstrated. A held-out workflow cross-validation or a description of how the GNN-RL-Test model was obtained is necessary to support this central adaptability claim.
minor comments (7)
  1. [Abstract and §V-C1] The phrase "76 percent faster" is ambiguous because no baseline is stated; please specify the comparison baseline and report the direction of the comparison clearly.
  2. [§V-C1 and Table IV] The statement "only 3.85 times slower than OLB" is awkwardly phrased; being slower is a drawback, so describing it as "only" is misleading without additional context such as the makespan gains.
  3. [Algorithm 2, line 24] The feature constraint is written as a sum of binary variables equaling an indicator function, which is not a valid linear constraint as presented; a proper linearization or a formulation with auxiliary binary variables is needed for the MILP to be correct.
  4. [Table III] The column "Mem Diff (MB)" is not defined in the text; it should be clarified what this measures and how it is computed.
  5. [§V-C1, Workflow 2 footnote] The footnote states that communication time cost is converted from seconds to milliseconds to adjust results, but the impact of this conversion on the reported makespans is not explained.
  6. [References] Several references are missing venue or year information (e.g., [9], [18], [25], [31], [34], [37]); these should be completed for reproducibility.
  7. [End matter] The text states both that project codes will be available via GitHub once the proceedings are completed and that the source code is available at a GitHub URL; these statements should be reconciled.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: GrapheonRL is benchmarked against external baselines (MILP, HEFT, OLB), and its central claims do not reduce to their inputs by construction.

full rationale

The paper contains no formal derivation in which a predicted quantity is defined in terms of a fitted quantity. The GNN-RL policy is trained with PPO against an explicit reward signal in a simulated environment (Algorithms 5 and 6), and the reported makespans are compared against independent external baselines: MILP via PuLP, HEFT, and OLB (Table III and Table IV). The reward function contains hand-set constants such as (15 - duration + resourcefactor) and (30 - makespan), but this is an optimization objective rather than a hidden reuse of the experimental outcomes; the learned policy is not guaranteed to reach that objective, so the observation that GNN-RL matches MILP makespan is an empirical result rather than a tautology. There is no load-bearing self-citation or imported uniqueness theorem: the cited prior work is external literature, and the optional imitation learning from MILP sub-DAG solutions mentioned in Section IV-E1 is not reported as being used in the experiments. The main weaknesses are experimental rather than circular. The model appears to be trained and tested on the same workflows, so the generalization claim is not established, and the abstract's '76 percent faster' claim is arithmetically contradicted by Table III for Workflow 4 (GNN-RL-Test 1.81 s versus MILP 0.43 s). These are important correctness risks, but they are not instances of a claim reducing to its own inputs by construction.

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

The paper introduces no new physical or conceptual entities. The free parameters are hand-set reward values and unspecified training hyperparameters, both of which shape the reported results. The axioms are standard deterministic scheduling assumptions plus an unverified simulator-to-reality equivalence.

free parameters (3)
  • Reward shaping constants = -5, -20, -5, +15, +10, +30, resourcefactor
    Hand-set in Algorithm 6 with no tuning or ablation reported. The policy and the resulting schedules depend on these values, and 'resourcefactor' is undefined.
  • Episode max steps = not reported
    The episode limit in Algorithm 6 affects termination and the penalty for unassigned tasks, but no value is given.
  • GNN and PPO hyperparameters = not reported
    Learning rate, GAE lambda, clipping epsilon, network architecture, and number of training episodes are omitted, so the method cannot be reproduced as-is.
assumptions (4)
  • domain assumption Task durations, resource requirements, and data transfer times are known exactly before scheduling.
    Used by all methods and stated in Section IV-B, Table II. Real systems have noise and uncertainty, but the paper assumes a deterministic workload model.
  • domain assumption A schedule feasible in the custom simulator is feasible on real SLURM and Kubernetes clusters.
    The evaluation is entirely simulated; there is no real cluster run, so the simulator's resource and timing model is an unverified proxy.
  • standard math PuLP MILP solutions are the optimal ground truth for the scheduling objective.
    The paper relies on the MILP formulation in Algorithm 2 as the exact optimum baseline, which is reasonable if the model itself is accepted.
  • domain assumption GNN embeddings adequately capture task dependencies and resource requirements for the RL policy.
    Standard ML assumption in Section IV-E2; no analysis or ablation is provided to show the embeddings improve decisions.

how reviews work

0 comments
Cite this review

Pith. "Pith review of GrapheonRL: A Graph Neural Network and Reinforcement Learning Framework for Constraint and Data-Aware Workflow Mapping and Scheduling in Heterogeneous HPC Systems." pith.science (2026). https://pith.science/paper/J5F56YXB

@misc{pith2026250600260,
  author       = {Pith},
  title        = {Pith review of: GrapheonRL: A Graph Neural Network and Reinforcement Learning Framework for Constraint and Data-Aware Workflow Mapping and Scheduling in Heterogeneous HPC Systems},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/J5F56YXB}},
  note         = {Machine review of arXiv:2506.00260}
}
read the original abstract

Effective resource utilization and decreased makespan in heterogeneous High Performance Computing (HPC) environments are key benefits of workload mapping and scheduling. Tools such as Snakemake, a workflow management solution, employ Integer Linear Programming (ILP) and heuristic techniques to deploy workflows in various HPC environments like SLURM (Simple Linux Utility for Resource Management) or Kubernetes. Its scheduler factors in workflow task dependencies, resource requirements, and individual task data sizes before system deployment. ILP offers optimal solutions respecting constraints, but only for smaller workflows. Meanwhile, meta-heuristics and heuristics offer faster, though suboptimal, makespan. As problem sizes, system constraints, and complexities evolve, maintaining these schedulers becomes challenging. In this study, we propose a novel solution that integrates Graph Neural Network (GNN) and Reinforcement Learning (RL) to flexibly handle workflows, dynamic constraints, and heterogeneous resources while providing quick responses. GNN manages dependencies and resource requirements, and RL optimizes scheduling decision-making via a learned policy, overcoming the need for a comprehensive global search. Experimental results with different datasets demonstrate that this method effectively adapts to different workflows, adheres to HPC constraints, and offers optimal solutions akin to ILP but with drastically reduced execution times (76 percent faster), comparable to heuristic methods (only 3.85 times slower than OLB). Our contribution is to provide a robust yet scalable mapping and scheduling solution that can handle changing constraints, as well as workload sizes and complexities in a heterogeneous HPC Compute Continuum system landscape.

Figures

Figures reproduced from arXiv: 2506.00260 by the authors.

Figure 1
Figure 1. Platform as a Service (PaaS): Digital Twin, User Cloud Service. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Showing Petri net example workflows with compute [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Cluster nodes input format in JSON. 1) System and Workload Input Characteristics: 7 [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Workflow input format in JSON. T1 dur=0 T2 dur=20 T3 dur=8 T4 dur=8 T5 dur=7 T6 dur=3 T7 dur=13 T8 dur=13 T9 dur=12 T10 dur=15 T11 dur=19 [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Workflow 1: Workflow without communication cost [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Workflow 2: Workflow with communication cost [PITH_FULL_IMAGE:figures/full_fig_p009_6.png]
Figure 8
Figure 8. Figure 8: Workflow 4: Robot control STGS (complex) graph. [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 9
Figure 9. Figure 9: Overall makespan of methods on different workflows [PITH_FULL_IMAGE:figures/full_fig_p010_9.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

39 extracted references · 29 canonical work pages

  1. [1]

    SLURM: Simple linux utility for resource management,

    A. B. Yoo, M. A. Jette, and M. Grondona, “SLURM: Simple linux utility for resource management,” in Proceedings of the 9th Workshop on Job Scheduling Strategies for Parallel Processing (JSSPP). Springer, 2003, pp. 44–60. [Online]. Available: https://doi.org/10.1007/10968987 3

    doi:10.1007/10968987 2003

  2. [2]

    Burns, B

    B. Burns, B. Grant, D. Oppenheimer, E. Brewer, and J. Wilkes, Kuber- netes: Up and Running: Dive into the Future of Infrastructure. O’Reilly Media, 2019. 10

    work page 2019

  3. [3]

    Snakemake–a scalable bioinformatics workflow engine,

    J. Koster and S. Rahmann, “Snakemake–a scalable bioinformatics workflow engine,” Bioinformatics, vol. 28, no. 19, pp. 2520–2522,

    work page

  4. [4]

    Hpc forecast: Cloudy and uncertain,

    J. Dongarra, “Hpc forecast: Cloudy and uncertain,” Communications of the ACM, vol. 65, no. 5, pp. 56–66, 2022

    work page 2022

  5. [5]

    Graph neural networks: A review of methods and applications,

    J. Zhou, G. Cui, S. Hu, Z. Zhang, C. Yang, Z. Liu, L. Wang, C. Li, and M. Sun, “Graph neural networks: A review of methods and applications,” AI open, vol. 1, pp. 57–81, 2020

    2020

  6. [6]

    R. S. Sutton, A. G. Barto et al., Reinforcement learning: An introduction. MIT press Cambridge, 2018, vol. 1, no. 1

    work page 2018

  7. [7]

    Container scheduling techniques: A survey and assessment,

    I. Ahmad, M. G. AlFailakawi, A. AlMutawa, and L. Alsalman, “Container scheduling techniques: A survey and assessment,” Journal of King Saud University - Computer and Information Sciences , vol. 34, no. 7, pp. 3934–3947, 2022. [Online]. Available: https: //www.sciencedirect.com/science/article/pii/S1319157821000562

    work page 2022

  8. [8]

    Container oriented job scheduling using linear programming model,

    D. Zhang, B.-H. Yan, Z. Feng, C. Zhang, and Y .-X. Wang, “Container oriented job scheduling using linear programming model,” in 3rd In- ternational Conference on Information Management (ICIM) , 2017, pp. 174–180

    work page 2017

Show all 39 references
  1. [9]

    Bertsimas, Introduction to Linear Optimization

    D. Bertsimas, Introduction to Linear Optimization . Belmont, Mass. : Athena Scientific. [Online]. Available: http://archive.org/details/ introductiontoli0000bert

  2. [10]

    Mixed-integer programming solvers,

    R. E. Bixby, “Mixed-integer programming solvers,” Wiley Encyclopedia of Operations Research and Management Science , vol. 5, pp. 1–13, 2012

    2012

  3. [11]

    M. L. Pinedo, Scheduling: Theory, Algorithms, and Systems , 5th ed. Springer, 2016

    2016

  4. [12]

    Load balancing in cloud computing: a big picture,

    S. K. Mishra, B. Sahoo, and P. P. Parida, “Load balancing in cloud computing: a big picture,” Journal of King Saud University-Computer and Information Sciences , vol. 32, no. 2, pp. 149–158, 2020

    2020

  5. [13]

    A heuristic task scheduling approach in cloud computing systems,

    X. Liao et al., “A heuristic task scheduling approach in cloud computing systems,” in International Conference on Advanced Cloud and Big Data (CBD). IEEE, 2014, pp. 40–47

    2014

  6. [14]

    Metaheuristics in combinatorial optimiza- tion: Overview and conceptual comparison,

    C. Blum and A. Roli, “Metaheuristics in combinatorial optimiza- tion: Overview and conceptual comparison,” ACM Computing Surveys (CSUR), vol. 35, no. 3, pp. 268–308, 2003

    2003

  7. [15]

    A Multiple Priority Queueing Genetic Algorithm for Task Scheduling on Heterogeneous Computing Systems,

    Y . Xu, K. Li, T. T. Khac, and M. Qiu, “A Multiple Priority Queueing Genetic Algorithm for Task Scheduling on Heterogeneous Computing Systems,” in 2012 IEEE 14th International Conference on High Performance Computing and Communication & 2012 IEEE 9th International Conference o...

    2012

  8. [16]

    Deep reinforcement learning for job scheduling and resource management in cloud computing: An algorithm-level review

    Y . Gu, Z. Liu, S. Dai, C. Liu, Y . Wang, S. Wang, G. Theodoropoulos, and L. Cheng, “Deep reinforcement learning for job scheduling and resource management in cloud computing: An algorithm-level review.” [Online]. Available: http://arxiv.org/abs/2501.01007

    arXiv

  9. [17]

    Efficient deep reinforcement learning based task scheduler in multi cloud environment,

    S. Mangalampalli, G. R. Karri, M. V . Ratnamani, S. N. Mohanty, B. A. Jabr, Y . A. Ali, S. Ali, and B. S. Abdullaeva, “Efficient deep reinforcement learning based task scheduler in multi cloud environment,” vol. 14, no. 1, p. 21850, publisher: Nature Publishing Group. [Online]...

  10. [18]

    The Graph Neural Network Model,

    F. Scarselli, M. Gori, A. C. Tsoi, M. Hagenbuchner, and G. Monfardini, “The Graph Neural Network Model,” vol. 20, no. 1, pp. 61–80. [Online]. Available: https://ieeexplore.ieee.org/document/4700287

  11. [19]

    Neural message passing for quantum chemistry,

    J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals, and G. E. Dahl, “Neural message passing for quantum chemistry,” in Proceedings of the 34th International Conference on Machine Learning (ICML) , 2017, pp. 1263–1272

    2017

  12. [20]

    Semi-supervised classification with graph convolutional networks,

    T. N. Kipf and M. Welling, “Semi-supervised classification with graph convolutional networks,” in International Conference on Learning Rep- resentations (ICLR), 2017

    2017

  13. [21]

    Graph attention networks,

    P. Veli ˇckovi´c, G. Cucurull, A. Casanova, A. Romero, P. Lio, and Y . Bengio, “Graph attention networks,” in International Conference on Learning Representations (ICLR) , 2018

    2018

  14. [22]

    A graph neural network approach to multi-job scheduling in high-performance computing,

    M. Zeng, M. Zhang, W. Chen, and J. Li, “A graph neural network approach to multi-job scheduling in high-performance computing,” in Proceedings of the IEEE International Parallel and Distributed Pro- cessing Symposium Workshops. IEEE, 2020, pp. 915–924

    2020

  15. [23]

    Gnn-based scheduling for heterogeneous hpc cluster,

    L. Pan, S. Wu, and L. Zheng, “Gnn-based scheduling for heterogeneous hpc cluster,” Journal of Parallel and Distributed Computing , vol. 145, pp. 104–117, 2021

    2021

  16. [24]

    Playing atari with deep reinforcement learn- ing,

    V . Mnih, K. Kavukcuoglu, D. Silver, A. Graves, I. Antonoglou, D. Wier- stra, and M. Riedmiller, “Playing atari with deep reinforcement learn- ing,” in NIPS Deep Learning Workshop , 2013

    2013

  17. [25]

    R. S. Sutton and A. G. Barto, Reinforcement Learning: An Introduction, 2nd Ed , ser. Reinforcement Learning: An Introduction, 2nd Ed. The MIT Press

  18. [26]

    GNN-RL: An Intelligent HPC Resource Scheduler,

    K. C. Adimora and H. Sun, “GNN-RL: An Intelligent HPC Resource Scheduler,” ACM, 2024. [Online]. Available: https://sc24. supercomputing.org/proceedings/poster/poster files/post137s2-file3.pdf

    2024

  19. [27]

    Deep reinforcement learning-based methods for resource scheduling in cloud computing: a review and future directions,

    G. Zhou, W. Tian, R. Buyya, R. Xue, and L. Song, “Deep reinforcement learning-based methods for resource scheduling in cloud computing: a review and future directions,” vol. 57, no. 5, p. 124. [Online]. Available: https://doi.org/10.1007/s10462-024-10756-9

    doi

  20. [28]

    A reinforcement learning based job scheduling algorithm for heterogeneous computing environment,

    Y . Song, C. Li, L. Tian, and H. Song, “A reinforcement learning based job scheduling algorithm for heterogeneous computing environment,” vol. 107, p. 108653. [Online]. Available: https://www.sciencedirect. com/science/article/pii/S0045790623000782

  21. [29]

    Topology-aware network pruning using multi-stage graph embedding and reinforcement learning,

    S. Yu, A. Mazaheri, and A. Jannesari, “Topology-aware network pruning using multi-stage graph embedding and reinforcement learning,” in Proceedings of the 39th International Conference on Machine Learning, ser. Proceedings of Machine Learning Research, vol. 162. PMLR, 17–23 Ju...

    2022

  22. [30]

    Spatl: Salient parameter aggregation and transfer learning for hetero- geneous federated learning,

    S. Yu, P. Nguyen, W. Abebe, W. Qian, A. Anwar, and A. Jannesari, “Spatl: Salient parameter aggregation and transfer learning for hetero- geneous federated learning,” in 2022 SC22: International Conference for High Performance Computing, Networking, Storage and Analysis (SC) (S...

    2022

  23. [31]

    Auto graph encoder-decoder for neural network pruning,

    S. Yu, A. Mazaheri, and A. Jannesari, “Auto graph encoder-decoder for neural network pruning,” in Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV) . IEEE/CVF International Conference on Computer Vision (ICCV), October 2021, pp. 6362–6372

    2021

  24. [32]

    Eadline, High Performance Computing for Dummies: Learn to: Pick out Hardware and Software, Find the Best Vendor to Work with, Get Your People up to Speed on HPC

    D. Eadline, High Performance Computing for Dummies: Learn to: Pick out Hardware and Software, Find the Best Vendor to Work with, Get Your People up to Speed on HPC . Hoboken, NJ: Wiley, 2009

    2009

  25. [33]

    W. M. Van Der Aalst and K. Van Hee, Workflow Management: Models, Methods, and Systems . The MIT Press. [Online]. Available: https://direct.mit.edu/books/book/2820/ Workflow-ManagementModels-Methods-and-Systems

  26. [34]

    Schulman, F

    J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov. Proximal Policy Optimization Algorithms. [Online]. Available: http: //arxiv.org/abs/1707.06347

    arXiv

  27. [35]

    [Online]

    Optimization with PuLP — PuLP 2.9.0 documentation. [Online]. Available: https://coin-or.github.io/pulp/

  28. [36]

    A standard task graph set for fair evaluation of multiprocessor scheduling algorithms,

    T. Tobita and H. Kasahara, “A standard task graph set for fair evaluation of multiprocessor scheduling algorithms,” Journal of Scheduling, vol. 5, no. 5, pp. 379–394, 2002

    2002

  29. [37]

    Practical Multiprocessor Scheduling Algorithms for Efficient Parallel Processing,

    Kasahara and Narita, “Practical Multiprocessor Scheduling Algorithms for Efficient Parallel Processing,” vol. C-33, no. 11, pp. 1023–1029. [Online]. Available: https://ieeexplore.ieee.org/document/1676376 11

  30. [646]

    Available: https://ieeexplore.ieee.org/document/6332230

    [Online]. Available: https://ieeexplore.ieee.org/document/6332230

  31. [2012]

    Available: https://doi.org/10.1093/bioinformatics/bts480

    [Online]. Available: https://doi.org/10.1093/bioinformatics/bts480

    doi

Pith tools

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