DRL Demo for Cloud-Edge-End Heterogeneous Scheduling

This repository currently serves two roles:

the original STG workflow scheduling benchmark suite
a submission-oriented demo prototype for the operating-system competition topic

The demo prototype focuses on deep reinforcement learning for cloud-edge-end heterogeneous resource scheduling. It includes:

a modular workflow scheduling environment
legal action masking over ready-task and feasible-node pairs
a trainable DRL-style policy
HEFT baseline comparison
one-command train + evaluate + export workflow

Quick Demo

Run the current submission-style demo with:

python run_demo.py --config configs/demo_config.json

Main demo outputs:

demo_outputs/competition_submission_demo/summary.json
demo_outputs/competition_submission_demo/demo_manifest.json
demo_outputs/competition_submission_demo/results/rl_results.json
demo_outputs/competition_submission_demo/results/heft_results.json

Standard entrypoints are also available:

train.py
evaluate.py
run_demo.py
run_cross_scale.py
run_multi_seed.py
run_tuning_sweep.py

Requirement-oriented tuning workflow:

python run_cross_scale.py --config configs/cross_scale_config.json
python run_tuning_sweep.py --base-config configs/ppo_tuning_config.json --candidates configs/ppo_tuning_candidates.json
python run_multi_seed.py --config configs/ppo_tuning_config.json --seeds 42 101 202

CUDA environment setup for Windows + Anaconda is documented in SETUP_CUDA_CN.md.

See DEMO_SUBMISSION.md and PROJECT_INTRO_CN.md for submission-ready wording.

STG Workflow Scheduling Benchmark Suite for Heterogeneous HPC Systems

This repository provides solver implementations, analysis scripts, and result figures for research on workflow mapping and scheduling in heterogeneous High Performance Computing (HPC) systems.

The project builds on the Standard Task Graph (STG) benchmark suite (Kasahara et al., Waseda University) by converting STG task graphs into structured JSON workflow representations and benchmarking six scheduling solvers across multiple graph sizes and system configurations.

Zenodo Datasets

Dataset	DOI	Contents
STG JSON Input Graphs	10.5281/zenodo.18927122	540 STG workflow instances (rnc50/100/300, homo/hetero) in JSON format
Multi-Solver Benchmark Results	10.5281/zenodo.20419279	6,480 JSON result files from 6 solvers x 3 graph sizes x 2 system modes x 180 instances

Repository Structure

grapheonrl-benchmark/
+-- stg_to_json_dataset/          Input graph conversion tools and system configurations
+-- stg_to_json_benchmarks/       Solver implementations (MILP, CP-SAT, HEFT)
+-- benchmark_results/            Figure generation script and all analysis figures
|   +-- generate_figures.py
|   +-- figures/                  21 PDF + 21 PNG figures + summary_stats.csv
+-- README.md

Solvers

Solver	Class	Implementation
MILP (PuLP)	Exact	`stg_to_json_benchmarks/milp_solver.py`
MILP (Gurobi)	Exact	`stg_to_json_benchmarks/milp_solver_gurobi.py`
CP-SAT	Exact	`stg_to_json_benchmarks/cp_sat_solver.py`
HEFT	Heuristic	`stg_to_json_benchmarks/heft_solver.py`
GNNRL (self)	Learned	GNN-RL model (separate training repo)
GNNRL (teacher)	Learned	GNN-RL model with teacher guidance (separate training repo)

Benchmark Scale (Phase I)

All runs are Small Scale Benchmark Tests in Edge Device (Phase I), executed on an Intel Core i5-1145G7 edge device (4 cores / 8 threads, 15 W TDP, 16 GB RAM, Ubuntu 22.04.5 LTS).

Graph size	Tasks	System modes	Instances per cell	Total per solver
rnc50	50	homo (3-node), hetero (8-node)	180	360
rnc100	100	homo (3-node), hetero (8-node)	180	360
rnc300	300	homo (3-node), hetero (8-node)	180	360

Total: 6 solvers x 6 cells x 180 instances = 6,480 result files

Phase II cluster-based validation on real HPC infrastructure will be published as a separate companion dataset.

Reproducing Results

Run a solver (example: HEFT on one workflow):

cd stg_to_json_benchmarks
python heft_solver.py --input workflow.json --system hetero_8node.json

Regenerate all figures from the raw Zenodo data:

cd benchmark_results
# Place main_results/ folder (extracted from benchmark_solver_results_main.zip) here
python generate_figures.py

See benchmark_results/README.md for full reproduction instructions.

Preview Figures

Benchmark Overview: Objective and Makespan Scalability

Overview of all solvers across all graph sizes and system modes

Solve Status by Solver and Graph Size

Solve status breakdown per solver and cell

Citation

If you use this repository or the associated datasets, please cite:

Input workflow graphs (STG JSON dataset):

@dataset{Sharma2026STGDataset,
  author    = {Sharma, Aasish Kumar and Kunkel, Julian Martin},
  title     = {Standard Task Graph ({STG}) Dataset With {JSON} Conversions
               for Workflow Scheduling in Heterogeneous High Performance
               Computing ({HPC}) Systems},
  year      = {2026},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.18927122},
  url       = {https://doi.org/10.5281/zenodo.18927122}
}

Benchmark solver results:

@dataset{Sharma2026BenchmarkResults,
  author    = {Sharma, Aasish Kumar and Kunkel, Julian Martin},
  title     = {Standard Task Graph ({STG}) Multi-Solver Benchmark Results
               for Workflow Scheduling in Heterogeneous High Performance
               Computing ({HPC}) Systems},
  year      = {2026},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.20419279},
  url       = {https://doi.org/10.5281/zenodo.20419279}
}

Dataset Provenance

Input workflow graphs are derived from the Standard Task Graph (STG) benchmark suite:

Hiroshi Kasahara, Waseda University https://www.kasahara.cs.waseda.ac.jp/schedule/stgarc_e.html

Authors

Author	ORCID
Aasish Kumar Sharma	0000-0002-7514-2340
Julian Martin Kunkel	0000-0002-6915-1179

University of Gottingen / GWDG, Germany