Jmchenn/AutoThread-dataset-runtime-log

DES Multithreaded Trajectory Dataset (AutoThread Dataset)

This dataset targets research on accelerating Discrete Event Simulation (DES) systems for Simulation-in-the-Loop Reinforcement Learning (SiL-RL). It records multithreaded execution traces of DES environments under varying application workloads, hardware platforms, and worker-thread (WT) counts, supporting research in thread-level behavior analysis, performance modeling, and adaptive thread tuning.

Companion paper: Hybrid-Adaptive Thread Tuning to Mitigate Simulation Execution Bottlenecks in High-Performance Reinforcement Learning Inference (AutoThread, IJCAI/ECAI 2026 submission).

To the best of our knowledge, this is the first public DES multithreaded trajectory dataset for RL-based decision-making systems, and one of the largest single-node thread-level trace sets currently available, comprising over 10,000 multithreaded execution samples.

---

1. Overview

The dataset is organized along four dimensions — application × hardware platform × workload parameters × worker-thread count — and contains two categories of data:

Top-level directory	Purpose
PCS/	Full static thread-count sweeps of the PCS (Personal Communication System) application across platforms and workloads
UAV/	Full static thread-count sweeps of the UAV (autonomous navigation and obstacle avoidance) application across platforms, scenarios, and workloads
Dynamic/	Comparative experiment traces produced by various thread-tuning methods (Static / XGBoost / Reinforcer / Otter / PINN / dPINN, etc.) under dynamic workloads

Both application cases are built on the DES paradigm:

• PCS: A classic DES benchmark simulating multi-class communication tasks among nodes in a wireless network. Each agent represents a communication node generating five types of communication tasks, with task execution times following a Poisson distribution of mean t.
• UAV: A case study based on real flight trajectories from FlightAware, simulating multi-UAV autonomous navigation and obstacle avoidance. Each agent represents a UAV and performs perception and navigation tasks; each UAV deterministically generates 2 tasks per cycle.

To emulate high-fidelity simulation, each task embeds array dot products and iterative power-function computations, yielding per-task execution times distributed between 10 μs and 800 μs.

---

2. Hardware Platforms

Traces were collected on two mainstream server-grade CPU platforms:

• AMD EPYC 9734 (224 logical cores)
• Intel Xeon Gold 6338

The operating system is Linux (kernel 6.8.0-78-generic, Ubuntu-based). Original pidstat timestamps and system identifiers are preserved in the trace files so that the sampling context can be reconstructed.

---

3. Directory Structure

3.1 Static-sweep data: PCS/ and UAV/

PCS/
├── AMD EPYC 9734/
│   └── load_log/
│       ├── complex_500/
│       │   ├── lp_400_tm_2000/
│       │   │   ├── perf_out_{K}.txt          # K = 1..60, the WT count
│       │   │   ├── pidstat_out_{K}.txt
│       │   │   └── simulation_out_{K}.txt
│       │   ├── lp_900_tm_2000/
│       │   ├── lp_1600_tm_2000/
│       │   ├── lp_2500_tm_2000/
│       │   └── lp_3600_tm_2000/
│       ├── complex_1000/
│       ├── complex_1500/
│       ├── complex_2000/
│       ├── complex_3000/
│       └── complex_4000/
└── Intel Xeon Gold 6338/
    └── load_log/
        ├── complex_0/ ... complex_8000/

UAV/
├── AMD EPYC 9734/
│   └── load_log/
│       ├── nohot_data_0/
│       │   ├── scenario2/
│       │   │   ├── perf_out_{K}.txt          # K = 1..70
│       │   │   ├── pidstat_out_{K}.txt
│       │   │   └── simulation_out_{K}.txt
│       │   ├── scenario3/
│       │   ├── scenario4/
│       │   ├── scenario5/
│       │   └── scenario6/
│       ├── nohot_data_1000/ ... nohot_data_8000/
└── Intel Xeon Gold 6338/
    └── load_log/...

Naming conventions (PCS):

• complex_X — computational-complexity level of a single task (embedded compute size); larger X produces longer per-task execution times.
• lp_Y_tm_Z — Y is the number of agents (Logical Processes, LP); Z is the number of simulation steps (total simulation duration).
• {kind}_out_K.txt — K is the worker-thread count configured for that run; kind ∈ {perf, pidstat, simulation}.

Naming conventions (UAV):

• nohot_data_X — embedded-computation scale parameter (X = 0 means no extra compute load; larger X means heavier per-task work).
• scenarioY — different navigation scenarios partitioned from real flight data (varying UAV count and trajectory distribution).
• {kind}_out_K.txt — same as above; K is the WT count.

Within each leaf directory, K ranges from 1 up to the maximum WT count tested on that platform (typically 1–60 for PCS, 1–70 for UAV), corresponding to one full thread-count sweep.

3.2 Dynamic-tuning comparison data: Dynamic/

Dynamic/
├── AMD_PCS/        # AMD EPYC 9734 + PCS
├── AMD_Airline/    # AMD EPYC 9734 + UAV (trajectories from Airline data)
├── X86_PCS/        # Intel Xeon Gold 6338 + PCS
└── X86_Airline/    # Intel Xeon Gold 6338 + UAV
    └── round_{1..5}/
        ├── Static_{X} / static_complex_{X}/        # fixed-thread baselines
        ├── Xgboost_{X} / Xgbcpu_complex_{X}/       # XGBoost-based thread predictor
        ├── reinfor_complex_{X}/                    # Reinforcer (RL) tuner
        ├── Otter_{X}/                              # Otter baseline
        ├── PINN_complex_{X}/                       # PINO predictor only (no online fine-tuning)
        ├── dPINN_complex_{X}/                      # AutoThread (PINO + dynamic online fine-tuning)
        ├── ADA_complex_{X}/ ADAPINN_complex_{X}/   # adaptive ablation variants
        └── Robustness/                             # dedicated robustness experiments

• round_N — independent repeated trials, used to assess stability and variance.
• The prefix of each subdirectory denotes the thread-tuning method; the _X suffix usually corresponds to a workload-intensity level (e.g., 500 / 1000 / 1500 / 2000).
• Robustness/ — robustness tests under abnormal workloads or noise perturbations.
• The contents of each leaf directory follow the same three-file convention: perf_out_*.txt, pidstat_out_*.txt, simulation_out_*.txt.

---

4. File Contents and Field Definitions

Each experiment sample consists of three trace files:

4.1 Hardware-layer traces

CPU utilization is a classic and widely used performance indicator, so we record kernel time and waiting time per thread. Memory subsystem, cache, I/O rate, and context switching also directly impact job performance and are therefore included.

• pidstat_out_K.txt — Per-thread runtime trace collected by pidstat (CPU, memory, I/O, context switching, etc.), with one row per worker-thread child of the main process. For pidstat field semantics see https://www.man7.org/linux/man-pages/man1/pidstat.1.html.
• perf_out_K.txt — Microarchitectural metrics collected by perf (cache references / cache misses, including LLC load / store miss ratios), characterizing memory-subsystem behavior.

4.2 Application-layer traces

Following the conservative-synchronization PDES execution model, event processing and entity synchronization are the dominant time consumers; we therefore record per-event time, per-cycle thread-pool execution time, and per-cycle synchronization time.

• simulation_out_K.txt — DES engine log, containing:
  • Startup information: configuration / scenario parsing, entity initialization, Pub/Sub interaction registration (Interaction event_vector:*).
  • Per-simulation-step summary: simulation time=…, wall time=… ms, excute time=… vs, synchronize time=… vs, executed events=….
  • Per-event execution time: event{ID} excute time=… vs.
  • Task-queue length per cycle of the thread pool: 同时事件任务队列大小:… (concurrent task-queue size).

Selected samples were also profiled with Intel VTune to analyze hotspot functions and thread time consumption (used to localize lock waiting and busy-waiting overhead). When provided, VTune outputs are stored as standalone reports.

4.3 Field-definition reference

Metric	Description	Metric	Description
Time	Real-world (wall-clock) timestamp	kB_ccwr/s	Cancelled write KB per second (pidstat)
UID	User ID	iodelay	I/O delay clock ticks
TGID	Thread-group ID (main process)	cswch/s	Voluntary context switches per second
TID	Thread ID	nvcswch/s	Non-voluntary context switches per second
%usr	User-space CPU usage	Command	Process / thread command name
%system	Kernel-space CPU usage	LLC-load-misses	Last-level-cache load misses
%guest	Virtual-CPU usage	LLC-store-misses	Last-level-cache store misses
%wait	Time waiting in run queue	interaction event_vector	Pub/Sub interaction ID
%CPU	Total CPU usage	simulation time	Simulation clock (step index)
CPU	Physical core currently used	wall time	Cumulative wall-clock time (ms)
minflt/s	Minor page faults per second	executed events	Cumulative number of executed events
majflt/s	Major page faults per second	entityID	Entity ID
VSZ	Virtual memory size (KB)	threads	Worker-thread count
RSS	Resident set size (KB)	event excute time	Single-event execution time
%MEM	Physical memory usage (%)	task queue	Task-queue length
kB_rd/s	Disk read KB per second	synchronize time	Entity synchronization time
kB_wr/s	Disk write KB per second	excute time	Thread-pool execution time per simulation step

A total of 34 feature variables, covering hardware resource utilization, application logs, and microarchitectural features.

---

5. Dataset Scale

• A full thread-count sweep (single platform × single application) produces 3 × K_max files (K_max = 60 or 70).
• PCS: 2 platforms × 6–10 complex_X × 5 lp_*_tm_* × ~60 thread counts.
• UAV: 2 platforms × 9 nohot_data_X × 5 scenarioY × ~70 thread counts.
• Dynamic: 4 platform × application combinations × multiple rounds (round_1..5) × multiple tuning methods × multiple workload levels.
• Total: >10,000 multithreaded execution samples.

---

6. Recommended Usage

1. Static performance modeling. Use traces in PCS/ and UAV/ to fit "thread count vs. speedup" curves and regress task service rate μ_e and scheduler service rate μ_b.
2. Multithreaded behavior analysis. Combine %usr / %system / %CPU / cswch/s from pidstat_out_*.txt with cache metrics from perf_out_*.txt to study busy waiting, lock contention, and microarchitectural bottlenecks (see the Empirical Study section of the paper).
3. Thread-tuning-algorithm benchmarking. Use Dynamic/ traces with matched round and workload to directly compare Static, XGBoost, Reinforcer, Otter, PINN, and AutoThread (dPINN).
4. Robustness evaluation. Use Dynamic/*/Robustness/ to evaluate tuner stability under abnormal workloads and disturbances.

Parsing tips

• Lines beginning with simulation time=K in simulation_out_*.txt can be regex-extracted in one pass into 5-tuples (step, wall_time, exec_time, sync_time, cumulative_events) forming a time series.
• pidstat_out_*.txt consists of multiple sampling blocks separated by # Time … header lines, each block being one sampling interval; we recommend splitting on the header and parsing into a long-format DataFrame keyed by TID.
• perf_out_*.txt has a fixed schema (time / counts / unit / events) and can be grouped by cache-references / cache-misses to reconstruct time series.

---

7. Citation

If this dataset or the accompanying method assists your work, please cite:

8. License and Disclaimer

This dataset is intended for academic research only. The traces were collected on shared multi-user Linux servers and may contain unpredictable runtime noise and external disturbances; such noise itself is a valuable signal for studying the robustness of adaptive thread-tuning methods.