REVIEW 4 major objections 5 minor 28 references
Hybrid-Adaptive Thread Tuning to Mitigate Simulation Execution Bottlenecks in High-Performance Reinforcement Learning Inference
T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash
Pith's one-line read AutoThread predicts the worker-thread count that balances task execution against scheduling, cutting simulation runtime by up to 83.8% in RL-in-the-loop systems.
desk verdict Real engineering contribution with a new public dataset, but the queueing-theoretic anchor is under-derived and should be fixed before the 'physics-informed' claim is taken at face value. read the letter →
The pith
A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.
The reading
What carries the argument
The load-bearing object is the finite-source M/M/1 queueing model of the simulator's scheduling phase: worker threads are the customers, the shared scheduler is a single server with service rate μ_b, and threads arrive for scheduling at effective rate k μ_e after finishing tasks. From this model the paper derives a piecewise formula for total cycle time and the optimum condition k*≈μ_b/μ_e, which becomes the 'physics' in the physics-informed neural operator. That operator, a neural network mapping workload and hardware features to an optimal thread count, takes seven features (task count N, task service rate μ_e, observed thread count, user/system CPU, virtual memory, context-switch rate) and uses a residual-based attention mechanism to balance the physical loss against supervised data. The companion adaptive tuner then uses load-triggered prediction, periodic CPU-aware reductions, and throughput-driven fine-tuning to correct prediction residuals online.
What would settle it
Run a fixed workload on one machine, sweep worker-thread count k across the full core range, and record both the scheduling time per cycle and the optimal k; if the measured optimum does not track μ_b/μ_e computed from directly timed scheduler and task service rates, or if the shape of the paper's closed-form scheduling-time formula is not reproduced, the queueing model anchoring AutoThread is falsified.
Extended reading notes
Core claim
The core claim is that the ratio of task execution time to scheduling time determines how many worker threads a centralized-queue DES simulator should use. The paper models the scheduler as a finite-source M/M/1 queue in which worker threads are customers and the shared scheduler is a single server, giving total cycle time T(k) that is minimized near k*≈μ_b/μ_e, where μ_b is the scheduler service rate and μ_e is the task service rate. AutoThread operationalizes this by training a neural operator whose physics loss penalizes deviations from the queueing model's predicted execution time and from the ratio k*=μ_b/μ_e, then adds a three-level tuner that reacts to load changes, CPU contention signals, and throughput stalls. On PCS and UAV DES workloads, the paper claims this combination delivers the reported speedups and throughput gains while staying stable under workload fluctuation.
Load-bearing premise
The load-bearing premise is that the simulator's shared scheduler behaves like a single-server queue, so the best thread count equals the ratio of scheduler speed to task-processing speed; if that queueing description does not match the real scheduler, the physics constraint that guides the neural predictor is built on a wrong model.
Editorial extensions
If this is right
- If the ratio rule holds, thread tuning for any shared-queue simulation reduces to estimating two service rates, so the same PINO-plus-tuner structure should transfer to new platforms with only lightweight retraining.
- The queueing model identifies a saturation ceiling: once k μ_e exceeds μ_b, more worker threads cannot help, so effort should shift from adding threads to reducing scheduler contention.
- The reported 18.4% average speedup over a fixed strategy implies that static thread configurations, even ones chosen with prior knowledge, leave substantial simulation throughput untapped under dynamic loads.
- The tuner's deliberate asymmetry, reducing threads on contention but never adding them during fine-tuning, codifies the model's claim that oversubscription is the dominant and most costly failure mode.
- Because the predictor responds to changes in average task service time, the method is expected to work wherever task sizes vary over time, not only in the two benchmark applications.
Reading between the lines
- A direct test of the physical model would be to measure μ_b on a live system (for example, by timing the scheduler under a single thread at increasing k) and compare the measured optimum with k*=μ_b/μ_e; the paper does not report such a direct measurement, so this ratio remains an inferred rather than independently validated quantity.
- The model suggests a simpler deployment rule: monitor average task service time and the user/system CPU crossover, and you can approximate the optimal thread count without a neural network; the PINO's contribution is mainly speed and smoothness of prediction.
- The same ratio-based tuning could apply to any shared-queue runtime where task executors contend for a serial dispatcher, such as serverless function pools or database worker pools; a testable extension is to run AutoThread's tuner on those systems with only the queueing loss retained.
- If task execution times become very short relative to scheduling overhead, the predicted optimum k* will fall toward one, suggesting that for fine-grained tasks the simulator should batch tasks before parallelizing rather than adding threads.
Editorial analysis
A structured set of objections, weighed in public.
Referee Report
Summary. This paper addresses the problem of selecting the worker-thread (WT) count in centralized-queue discrete-event simulation environments used for reinforcement-learning inference. Based on a newly collected multithreaded trajectory dataset, the authors identify workload-intensity and contention-related metrics that correlate with optimal WT counts. They propose AutoThread, which combines a physics-informed neural operator (PINO) that predicts the optimal WT count with a three-level adaptive dynamic tuner. The PINO is trained with a physics loss derived from a finite-source M/M/1 queueing model, a supervised loss against empirically swept thread counts, and a regularization term. Experiments on two DES benchmarks and two CPU platforms report large speedups, including up to 83.8% runtime reduction, 18.4% average speedup over a static strategy, and throughput improvements over XGBoost and Thread Reinforcer. The code and dataset are publicly released.
Significance. If the technical claims hold, the paper would make a practically useful contribution: it introduces a public multithreaded DES trajectory dataset, a plausible two-stage architecture for online thread tuning, and end-to-end ablations suggesting that both the predictor and the tuner contribute to the reported gains. The idea of constraining a neural thread-count predictor with a queueing-theoretic performance model is attractive, and the public code and data are valuable supporting artifacts. However, the queueing model that anchors the 'physics-informed' component is not correctly derived as stated, and the key optimality condition k*≈μ_b/μ_e is asserted rather than demonstrated. Because the physical loss directly penalizes deviations from this ratio using a scheduler service rate that is itself learned from the data, the mechanistic interpretation and the claimed out-of-distribution robustness are not currently supported. The empirical results may still be real, but the central theoretical justification requires substantial revision.
major comments (4)
- [Section 3.1, Eq. (1)] The finite-source M/M/1 analysis is internally inconsistent. In a finite-source queue with k worker threads as customers, the state-dependent request rate when i threads are already queued or in service is (k−i)·μ_e, not the constant k·μ_e used in the paper. The same constant rate appears in P0 and in the expression for T_sch, so the steady-state probabilities and the scheduling-time formula do not follow from the stated finite-source model. In addition, T_sch = N·(k/(μ_b(1−P0)) − 1/(kμ_e)) is dimensionally inconsistent: the first term has units of k·time while the second term has units of time/k, so the two terms cannot be subtracted. The saturation formula T_exe(k)+T_sch(k)=N/μ_b+1/μ_e has a similar unit problem in its second term. The authors should either supply a correct derivation of T_sch and the resulting optimum, or abandon the queueing-theoretic derivation and present the model as an empirical functional form.
- [Section 3.1, 'Numerical analysis reveals'] The claim that the optimal thread count satisfies k*≈μ_b/μ_e is not supported by any derivation or quantitative evidence. The sentence 'Numerical analysis reveals' does not state what was computed, over what parameter range, or with which version of Eq. (1). This matters because μ_b and μ_e are themselves functions of k through the contention models μ_b(k)=1/(a1 k + t_base1) and μ_e(k)=1/(a2 k + t_base2); under those definitions, k*=μ_b/μ_e becomes a fixed-point equation rather than a direct ratio, and it is not obvious that its solution is the minimizer of Eq. (1). Since this ratio is used as the physical target in the PINO loss, the optimality condition is load-bearing and must be proven or verified against measured scheduler behavior.
- [Section 3.1, PINO physical loss] There is a circularity concern in the 'physics-informed' training objective. The physical loss L_phy contains the term α·||μ_b/μ_e − k*||², but μ_b is not measured independently; it is derived from the contention coefficients a1 and b1 that are outputs of the same network and are fit to observations. The supervised loss also trains k* toward the empirically swept optimal thread counts. Thus the physics constraint partly re-encodes a fitted relationship rather than imposing an independently validated mechanistic law. This weakens the subsequent claim that out-of-distribution robustness comes from the queueing-theoretic prior. The authors should validate the predicted μ_b against direct measurements of scheduler service time, or reframe the physical loss as a regularizer whose contribution is empirical rather than mechanistic.
- [Section 4.2 and Figure 7] The evaluation reports strong performance claims without statistical support. The paper states that each test case was executed at least five times, but figures and tables report only point values, with no error bars, confidence intervals, or per-run variance. Given that the method is explicitly designed to cope with runtime noise and transient disturbances, it is important to show that the reported 83.8% reduction and 18.4% average speedup are not within run-to-run variability. Please report distributions or confidence intervals, and specify the number of test scenarios and how the average is computed.
minor comments (5)
- [Figure 2 caption] The caption reads 'under different different application parameters'; the duplicated word should be removed.
- [Section 3.1 notation] The idle probability is written as P_o in the text near Eq. (1) but as P0 elsewhere; please unify the notation.
- [Algorithm 1, line 14] The condition in line 14, 'if usr cpu < usrcpu', appears to duplicate the condition in line 9 and is likely a typo; the intended comparison is probably between system CPU and user CPU, so please correct it.
- [Section 4.4] The platform is referred to as 'ADM platform'; this should be 'AMD platform'. Also, 'ADTPT-T' in Section 4.3 should be 'ADAPT-T'.
- [Section 4.2] Please clarify how the static strategy's thread count of 20 was chosen and state explicitly whether it was tuned per scenario or fixed globally; this is relevant for interpreting the 18.4% average speedup.
Circularity Check
The PINO predictor's input feature vector includes the optimal-thread-count label k_obs, and the physics loss trains the predicted ratio μ_b/μ_e to that same label, so the central 'prediction' reduces to reproducing or re-encoding the fitted label.
-
self definitional
[Section 3.1, PINO Predictor (feature vector and supervised loss)]
"We construct the feature vector a={N, µe, kobs, usrcpu, systemcpu, V SZ, cswch} from both application and hardware features. ... Lsup =∥k ∗ −k obs∥2 ... T obs and k obs denote the observed task queue execution time and iteratively measured optimal WT number, respectively."
The predictor Gθ:a→k* is given an input feature a that contains k_obs, while the supervised loss is L_sup=||k*−k_obs||² and k_obs is explicitly defined as the iteratively measured optimal WT number. The network can therefore satisfy the prediction task by copying the input feature; the claimed optimal-thread-count prediction is identical to the training target by construction. The prediction is not an inference of an unknown quantity but a reconstruction of a label already supplied in the input.
-
fitted input called prediction
[Section 3.1, Eq. (1), performance model and physics loss]
"Numerical analysis reveals that the optimal configuration occurs at k∗ ≈µb/µe ... FC layers decode fused features into optimal WT count k∗ and contention coefficients a1,b1. Physical loss: Lphy =∥T(N, k, µb, µe)−T obs∥2 +α∥ µb/µe −k ∗∥2"
The claimed theoretical optimum k*≈μ_b/μ_e is directly enforced by the physics-loss term α||μ_b/μ_e−k*||². But μ_b is not measured independently; it is derived from contention coefficients a1,b1 that are themselves outputs of the same PINO, while supervised training pushes k* to the empirical sweep label k_obs. Jointly minimizing both losses calibrates the 'physics' ratio μ_b/μ_e to k_obs, so the queueing-theoretic prior is a re-encoding of the fitted optimal label rather than an independent first-principles constraint.
full rationale
The central prediction chain of AutoThread contains two circular reductions. First, the PINO feature vector includes k_obs, and the same symbol is defined in the loss discussion as the iteratively measured optimal WT number used as the supervised target; thus Gθ can 'predict' the optimum by copying its input. Second, even if k_obs in the feature vector were intended as the current observed thread count, the physics loss explicitly trains the ratio μ_b/μ_e to equal k*, while L_sup trains k* to k_obs; since μ_b is produced by the same network's contention head and is never independently measured, the theoretical optimum k*≈μ_b/μ_e is a fitted quantity renamed as a queueing prediction. The paper's empirical speedups against static, Otter, Reinforcer, and XGBoost baselines, together with the released dataset and code, can still provide independent engineering evidence for AutoThread's practical gains, and supervised regression on genuine sweep labels is not itself circular. However, the paper's stated mechanistic justification—that a finite-source M/M/1 model guides and constrains prediction—reduces at the equation level to supervised copying and self-consistency, so the derivation chain is substantially circular. Separate correctness concerns, including the finite-source M/M/1 arrival rate being written as kμ_e instead of (k−i)μ_e and the apparent dimensional inconsistency in T_sch, are noted here only to avoid conflating them with circularity.
Assumptions & free parameters
free parameters (7)
- Contention coefficients a1, b1 for scheduler service rate =
not reported; learned by PINO
- Contention model coefficients a2, t_base2 for task execution =
not reported; assumed from per-thread linear interference
- Loss weight alpha =
not reported
- Supervised loss weight lambda =
not reported
- Regularization weight gamma =
not reported
- Load-change threshold delta =
0.3 in AMD UAV experiment; robust range in Fig. 10
- Check periods C1, C2 =
optimal ratio approximately 2-4; exact values not reported
assumptions (5)
- domain assumption A single simulation cycle consists of sequential task execution, scheduling, and synchronization phases; synchronization time is constant with respect to WT count.
- domain assumption The scheduler with k worker threads is a finite-source M/M/1 queueing system with effective arrival rate lambda = k mu_e, and steady-state CTMC formulas apply.
- domain assumption Per-thread execution and scheduling times increase linearly with active thread count (linear interference).
- ad hoc to paper The optimal WT count is approximately k* = mu_b / mu_e.
- domain assumption Optimal thread-count labels from full-execution sweeps under constant load transfer to instantaneous dynamic workloads.
Cite this review
Pith. "Pith review of Hybrid-Adaptive Thread Tuning to Mitigate Simulation Execution Bottlenecks in High-Performance Reinforcement Learning Inference." pith.science (2026). https://pith.science/paper/DSE57XW6
@misc{pith2026260806025,
author = {Pith},
title = {Pith review of: Hybrid-Adaptive Thread Tuning to Mitigate Simulation Execution Bottlenecks in High-Performance Reinforcement Learning Inference},
year = {2026},
howpublished = {\url{https://pith.science/paper/DSE57XW6}},
note = {Machine review of arXiv:2608.06025}
}
read the original abstract
In simulation-in-the-loop decision-making systems, reinforcement learning (RL) inference is often constrained by simulator-side execution overhead, where workloads are highly dynamic and sensitive to runtime thread configurations. Existing multithreaded strategies struggle to match thread resources before or during execution, causing resource contention, scheduling overhead, and reduced throughput. Through empirical analysis, we identify the ratio of task execution time to scheduling time as the key factor determining the optimal thread count. Building on this insight, we propose AutoThread, a hybrid adaptive thread-tuning method for mitigating simulation bottlenecks in RL inference. AutoThread employs a Physics-Informed Neural Operator (PINO) as a thread-count predictor and incorporates a finite-source M/M/1 queueing model to constrain and guide prediction, enabling fast and accurate estimation under dynamic workloads. It further performs load-aware online fine-tuning to compensate for prediction errors and refine resource allocation. Experiments show that AutoThread improves average speedup by 18.4\% over static strategies, achieves average throughput of 1.7x and 1.8x that of XGBoost and Reinforcer, respectively, and reduces execution time by up to 83.8\% compared with state-of-the-art methods. Our code and dataset are publicly available at https://github.com/suchenjm/AutoThread.
Figures
Figures from the paper (5 more)
Reference graph
Works this paper leans on
-
[1]
Machine learning based thread pool tuning via program analysis
[Akashet al., 2021 ] Lakindu Akash, Duneesha Fernando, Malith Jayasinghe, Chamath Keppitiyagama, and Kishan- than Thangarajah. Machine learning based thread pool tuning via program analysis. In2021 IEEE 23rd Int Conf on High Performance Computing & Communica- tions; 7th Int Conf on Data Science & Systems; 19th Int Conf on Smart City; 7th Int Conf on Depen...
work page 2021
-
[5]
Reinforcement learning with discrete event simulation: the premise, re- ality, and promise
[Belsareet al., 2022 ] Sahil Belsare, Emily Diaz Badilla, and Mohammad Dehghanimohammadabadi. Reinforcement learning with discrete event simulation: the premise, re- ality, and promise. In2022 Winter Simulation Conference (WSC), pages 2724–2735. IEEE,
work page 2022
-
[8]
Adapt-t: An adaptive algorithm for auto- tuning worker thread pool size in application servers
[Costaet al., 2019 ] Nilushan Costa, Malith Jayasinghe, Ajantha Atukorale, Supun Abeysinghe, Srinath Perera, and Isuru Perera. Adapt-t: An adaptive algorithm for auto- tuning worker thread pool size in application servers. In 2019 IEEE Symposium on Computers and Communica- tions (ISCC), pages 1–6. IEEE,
work page 2019
-
[10]
[Feriani and Hossain, 2021] Amal Feriani and Ekram Hos- sain. Single and multi-agent deep reinforcement learning for ai-enabled wireless networks: A tutorial.IEEE Com- munications Surveys & Tutorials, 23(2):1226–1252,
work page 2021
-
[11]
Flightaware - flight tracker / flight status
[FlightAware, 2025] FlightAware. Flightaware - flight tracker / flight status. https://uk.flightaware.com/,
work page 2025
-
[12]
Accessed: 2025-10-25. [Huet al., 2024 ] Kai Hu, Mingyang Li, Zhiqiang Song, Keer Xu, Qingfeng Xia, Ning Sun, Peng Zhou, and Min Xia. A review of research on reinforcement learning algorithms for multi-agents.Neurocomputing, 599:128068,
work page 2025
-
[13]
[Jancauskaset al., 2019 ] Vytautas Jancauskas, Tomasz Pi- ontek, Piotr Kopta, and Bartosz Bosak. Predicting queue wait time probabilities for multi-scale comput- ing.Philosophical Transactions of the Royal Society A, 377(2142):20180151,
work page 2019
-
[14]
Adwtune: an adaptive dynamic workload tuning system with deep reinforcement learning
[Liet al., 2025 ] Cuixia Li, Junhai Wang, Jiahao Shi, Liqiang Liu, and Shuyan Zhang. Adwtune: an adaptive dynamic workload tuning system with deep reinforcement learning. Complex & Intelligent Systems, 11(4):192,
work page 2025
Show all 28 references
-
[15]
Hap: Hybrid adaptive parallelism for efficient mixture-of-experts inference.arXiv preprint arXiv:2508.19373,
[Linet al., 2025 ] Haoran Lin, Xianzhi Yu, Kang Zhao, Han Bao, Zongyuan Zhan, Ting Hu, Wulong Liu, Zekun Yin, Xin Li, and Weiguo Liu. Hap: Hybrid adaptive parallelism for efficient mixture-of-experts inference.arXiv preprint arXiv:2508.19373,
2025 arXiv
-
[16]
Online thread auto-tuning for performance improvement and resource saving.IEEE Transactions on Parallel and Distributed Systems, 33(12):3746–3759,
[Luanet al., 2022 ] Guangqiang Luan, Pu Pang, Quan Chen, Shuai Xue, Zhuo Song, and Minyi Guo. Online thread auto-tuning for performance improvement and resource saving.IEEE Transactions on Parallel and Distributed Systems, 33(12):3746–3759,
2022
-
[17]
An extensi- ble thread throttling method for multiple openmp parallel programs.ACM Trans
[Luoet al., 2025 ] Xiaoxuan Luo, Weiwei Lin, Jiachun Li, Fan Chen, Haocheng Zhong, and Keqin Li. An extensi- ble thread throttling method for multiple openmp parallel programs.ACM Trans. Embed. Comput. Syst., September
2025
-
[18]
Spatial/temporal locality-based load-sharing in speculative discrete event simulation on multi-core machines.ACM Transactions on Modeling and Computer Simulation, 35(1):1–31,
[Montesanoet al., 2024 ] Federica Montesano, Romolo Marotta, and Francesco Quaglia. Spatial/temporal locality-based load-sharing in speculative discrete event simulation on multi-core machines.ACM Transactions on Modeling and Computer Simulation, 35(1):1–31,
2024
-
[19]
Evaluating end-to- end autonomous driving architectures: a proximal policy optimization approach in simulated environments.Au- tonomous Intelligent Systems, 5(1):14,
[Morgadoet al., 2025 ] ˆAngelo Morgado, Kaoru Ota, Mi- anxiong Dong, and Nuno Pombo. Evaluating end-to- end autonomous driving architectures: a proximal policy optimization approach in simulated environments.Au- tonomous Intelligent Systems, 5(1):14,
2025
-
[20]
Thread reinforcer: Dy- namically determining number of threads via os level monitoring
[Pusukuriet al., 2011 ] Kishore Kumar Pusukuri, Rajiv Gupta, and Laxmi N Bhuyan. Thread reinforcer: Dy- namically determining number of threads via os level monitoring. In2011 IEEE International Symposium on Workload Characterization (IISWC), pages 116–125. IEEE,
2011
-
[22]
A unified cloud-enabled discrete event parallel and distributed simulation architecture.Simulation Modelling Practice and Theory, 118:102539,
[Risco-Mart´ınet al., 2022 ] Jos´e L Risco-Mart ´ın, Kevin Henares, Saurabh Mittal, Luis F Almendras, and Katzalin Olcoz. A unified cloud-enabled discrete event parallel and distributed simulation architecture.Simulation Modelling Practice and Theory, 118:102539,
2022
-
[23]
Time-predictable task-to-thread mapping in multi-core processors.Journal of Systems Architecture, 148:103068,
[Samadiet al., 2024 ] Mohammad Samadi, Sara Royuela, Luis Miguel Pinho, Tiago Carvalho, and Eduardo Qui˜nones. Time-predictable task-to-thread mapping in multi-core processors.Journal of Systems Architecture, 148:103068,
2024
-
[24]
Thread pool parameters tuning us- ing simulation
[Stetsenko and Dyfuchyna, 2019] Inna V Stetsenko and Oleksandra Dyfuchyna. Thread pool parameters tuning us- ing simulation. InInternational Conference on Computer Science, Engineering and Education Applications, pages 78–89. Springer,
2019
-
[25]
Mixed opinion dynamics based on degroot model and hegselmann–krause model in social networks.IEEE Transactions on Systems, Man, and Cybernetics: Systems, 53(1):296–308,
[Wuet al., 2022 ] Zhibin Wu, Qinyue Zhou, Yucheng Dong, Jiuping Xu, Abdulrahman H Altalhi, and Francisco Her- rera. Mixed opinion dynamics based on degroot model and hegselmann–krause model in social networks.IEEE Transactions on Systems, Man, and Cybernetics: Systems, 53(1):296–308,
2022
-
[26]
Url: A unified reinforcement learning approach for autonomic cloud management.Journal of Parallel and Distributed Computing, 72(2):95–105,
[Xuet al., 2012 ] Cheng-Zhong Xu, Jia Rao, and Xiangping Bu. Url: A unified reinforcement learning approach for autonomic cloud management.Journal of Parallel and Distributed Computing, 72(2):95–105,
2012
-
[28]
A hierarchical composite framework of paral- lel discrete event simulation for modelling complex adap- tive systems.Simulation Modelling Practice and Theory, 77:141–156, 2017
[Zhuet al., 2017 ] Feng Zhu, Yiping Yao, Wenjie Tang, and Jun Tang. A hierarchical composite framework of paral- lel discrete event simulation for modelling complex adap- tive systems.Simulation Modelling Practice and Theory, 77:141–156, 2017
2017
-
[2002]
Memory- efficient and adaptive heterogeneous framework for gate- level fault simulation.ACM Transactions on Design Au- tomation of Electronic Systems, 30(5):1–27,
[Chaoet al., 2025 ] Zhiteng Chao, Feng Gu, Junying Huang, Wenjie Li, Jing Ye, Huawei Li, and Xiaowei Li. Memory- efficient and adaptive heterogeneous framework for gate- level fault simulation.ACM Transactions on Design Au- tomation of Electronic Systems, 30(5):1–27,
2025
-
[2011]
Formation flight of fixed-wing uavs: Dynamic mod- eling, guidance design, and testing in realistic scenarios
[Riboldiet al., 2025 ] Carlo ED Riboldi, Marco Tomasoni, et al. Formation flight of fixed-wing uavs: Dynamic mod- eling, guidance design, and testing in realistic scenarios. Aerospace, 12(3):1–49,
2025
-
[2012]
Parallel actors and learners: A framework for generating scalable rl implementations
[Zhanget al., 2021 ] Chi Zhang, Sanmukh Rao Kuppanna- gari, and Viktor K Prasanna. Parallel actors and learners: A framework for generating scalable rl implementations. In2021 IEEE 28th International Conference on High Per- formance Computing, Data, and Analytics (HiPC), pages...
2021
-
[2019]
Offline and distributional reinforcement learning for wire- less communications.arXiv preprint arXiv:2504.03804,
[Eldeeb and Alves, 2025] Eslam Eldeeb and Hirley Alves. Offline and distributional reinforcement learning for wire- less communications.arXiv preprint arXiv:2504.03804,
2025 arXiv
-
[2021]
Dynamic schedul- ing strategies for cloud-based load balancing in parallel and distributed systems.Journal of Cloud Computing, 14(1):33,
[Albalawi, 2025] Nasser S Albalawi. Dynamic schedul- ing strategies for cloud-based load balancing in parallel and distributed systems.Journal of Cloud Computing, 14(1):33,
2025
-
[2022]
Ross: A high-performance, low-memory, modular time warp system.Journal of par- allel and distributed computing, 62(11):1648–1669,
[Carotherset al., 2002 ] Christopher D Carothers, David Bauer, and Shawn Pearce. Ross: A high-performance, low-memory, modular time warp system.Journal of par- allel and distributed computing, 62(11):1648–1669,
2002
-
[2024]
Poolrunner: An extensible perfor- mance testing simulation tool for thread-pool middleware
[Bahaduret al., 2025 ] Faisal Bahadur, Zulfiqar Ahmad, and Abdulmohsen Algarni. Poolrunner: An extensible perfor- mance testing simulation tool for thread-pool middleware. IEEE Access,
2025
-
[2025]
Residual-based attention in physics-informed neural networks.Computer Methods in Applied Mechanics and Engineering, 421:116805,
[Anagnostopouloset al., 2024 ] Sokratis J Anagnostopou- los, Juan Diego Toscano, Nikolaos Stergiopulos, and George Em Karniadakis. Residual-based attention in physics-informed neural networks.Computer Methods in Applied Mechanics and Engineering, 421:116805,
2024
Reviewed August 7, 2026 · model on record in the stance chip above.
Discussion (0). Continue with ORCID to comment.