Coupling Complementary Simulations for Combined Performance and Energy Optimization Adel Dabah1[0000−0001−9175−469X] , Gregor Häfner3[0000−0002−1750−493X] , Sonja Happ2[0000−0002−1858−3641] , Simon Pickartz2[0000−0002−6316−6396] , Marcus Müller3[0000−0002−7472−973X] , and Andreas Herten1[0000−0002−7150−2505] Jülich Supercomputing Centre, Forschungszentrum Jülich, Germany {a.dabah,a.herten}@fz-juelich.de 2 ParTec AG, Munich, Germany {sonja.happ,pickartz}@par-tec.com 3 Institute for Theoretical Physics, Georg August University Göttingen, Germany [email protected], [email protected]
arXiv:2606.09356v1 [cs.DC] 8 Jun 2026
1
Abstract. Polymer simulations are among the most computationally demanding workloads in soft-matter research, often requiring days of execution and high energy consumption to achieve physically meaningful results. In this work, we address these challenges through the coupling and optimization of two complementary simulation frameworks: the Uneyama–Doi Model (UDM) and the SOft coarse-grained Monte Carlo Acceleration (SOMA). UDM efficiently propagates concentration fields at the continuum level, while SOMA resolves chain-scale thermal fluctuations via particle-based Monte Carlo dynamics. Each model was individually optimized for GPU execution using kernel fusion, memory coalescing, asynchronous random-number generation yielding up to 70 % (UDM) and 80 % (SOMA) performance improvement. The coupling is performed through our proposed coordinator library that orchestrates data exchange and synchronizes time-stepping across multiple GPUs. Further management of coupling workload distribution enabled a 13× overall speedup and 24.5× reduction in total energy usage compared to the SOMA baseline, i. e., 96 % energy saving. The proposed hybrid approach maintains the same scientific fidelity while drastically reducing the computational and energy footprint, showcasing the potential of energy-aware, cross-application co-design for sustainable highperformance simulations.
Keywords: Energy-Aware Computing, GPU Acceleration, Performance Optimization, Multi-scale Simulations, Message-Passing Interface.
1
Introduction
Simulating collective phenomena in polymer systems at realistic scales remains a grand challenge in computational materials science. Despite advances in computational resources, even coarse-grained polymer simulations continue to demand
2
A. Dabah et al.
multi-day execution times and substantial energy consumption due to the high dimensionality and stochastic nature of their physical models [10]. Achieving shorter time-to-solution without sacrificing model fidelity is therefore essential for sustainable High-Performance Computing (HPC) simulations. To date, the majority of research on energy efficiency in supercomputing has focused on low-level hardware control, such as Dynamic Voltage and Frequency Scaling (DVFS) [8,9], runtime system coordination and resource management strategies, like power capping and multi-objective scheduling [3]. While these approaches are important, they primarily optimize energy through infrastructurelevel control. In contrast, our strategy focuses on coupling complimentary applications. To our knowledge, this is an under-explored area of research for achieving effective energy efficiency. In this work, we target this challenge by coupling two complementary polymer simulation models: Uneyama-Doi Model (UDM) and SOft coarse grained Monte-carlo Acceleration (SOMA). UDM captures macroscopic concentration field dynamics through partial differential equations, enabling efficient largedomain simulations but lacking chain-level statistics [14,6]. In contrast, SOMA resolves molecular-scale configurations using Monte Carlo (MC) sampling, providing accuracy at the cost of extremely high computational demand [12]. To overcome the limitations of each model while minimizing the energy footprint, both codes were first optimized independently on A100 and H100 GPUs. For UDM, grouping small kernels, overlapping random-number generation, and fusing compute steps reduced global memory operations by up to 87 %, achieving a 70 % runtime improvement. For SOMA, porting initialization and validation to GPU, restructuring memory access, and improving data-reuse for key kernels improved throughput by 80 % and reduced the energy consumption by 50 % compared to the baseline SOMA. Beyond these independent optimizations, the two models were coupled using our proposed coordinator library that enables concurrent execution of the two models across multiple GPUs. It facilitates data communication and synchronization between continuum and particle models. The coupling framework runs UDM as a parent application. Choosing the region, in which the continuum model is expected to show suboptimal accuracy, the parent application starts a child SOMA application to model only this subdomain. Then, the models run concurrently, and, periodically communicating, the high-fidelity results are integrated into the parent application. Profiling using NVIDIA Nsight Systems [11] reveals minimal communication overhead and identifies synchronization gaps, which are mitigated through adaptive domain partitioning. The final coupled multi-scale UDM–SOMA system maintains similar physical fidelity as standalone SOMA simulations while achieving a 13× speedup and 24× reduction in total energy consumption as compared to the baseline SOMA code on two JUWELS Booster nodes with four NVIDIA A100 GPUs. This 96 % energy reduction illustrates that energy-efficient scientific computing can be achieved not only through hardware optimization but also through intelligent cross-model coupling.
Coupling Complementary Simulations for Combined Perf. and Energy Opt.
3
The rest of the paper is organized as follows: Section 2 gives an overview of the two complementary simulation models and optimizations performed. Section 3 introduces the proposed coordinator library and general view of the coupling mechanism. Section 4 summarizes the obtained results and discussions. Section 5 provides the lessons learned and finally, Section 6 concludes this paper.
2
Overview and Optimizations
This section gives an overview of the two complementary simulation models, UDM and SOMA, and introduces the Graphics Processing Units (GPUs) optimizations performed for ensuring efficient hardware utilization. UDM is a continuum model that propagates local concentration fields over time by numerically integrating coupled partial differential equations, which captures the diffusive dynamics of each monomer species, driven by solventnonsolvent exchange and equilibration within a free energy landscape [14,6]. This approach offers significant advantages in computational efficiency and scalability, allowing for the simulation of large domains with fewer resources. However, this efficiency comes at the cost of reduced accuracy, as the model lacks explicit polymer-chain configuration statistics and neglecting the thermal noise. SOMA offers a particle-based framework to study multi-component polymer systems at a coarse-grained level, designed for high-performance computers [1,12]. It implements the Single-Chain-in-Mean-Field (SCMF) algorithm using a soft, coarse-grained polymer model to investigate phase separation and self-assembly in soft matter systems. As a result, it requires substantial computational resources, which can be efficiently parallelized using the quasi-instantaneousfield approximation for non-bonded interactions. The time evolution of the system is modeled through bond-force-biased Monte-Carlo (MC) propagation of polymer beads within the SOMA program, allowing the model to naturally capture polymer dynamics with thermal fluctuations, an essential aspect of the underlying physical processes. Coupling of these two approaches as a multi-scale solution, using the coordinator library (see subsection 3.1), combines the strengths of both methods: the computational efficiency of UDM and the physical accuracy of the particle-based SOMA. Before coupling and to fully utilize modern GPUs, each model is optimized independently for GPU execution to improve its performance and reduce memory bottlenecks and energy consumption. After coupling, additional optimization ensures balanced workload distribution and reduced synchronization overhead across multiple GPUs. This end-to-end optimization, before and after coupling, increases simulation throughput and keeps large-scale hybrid simulations both efficient and sustainable. 2.1
UDM Optimization
To optimize UDM for GPU execution, we first conduct a detailed analysis of its computational workflow. These insights guide targeted optimizations to improve
A. Dabah et al.
26%
→2 .9%
4
renew_noise_kernel
Overlapping memory copy and simulation
Fig. 1: UDM kernels in one time step using Nsight Systems profiling tool (top) and overlapping Random Numbers Generation (RNG) with the UDM simulation (bottom).
parallel efficiency, memory utilization, and overall simulation throughput. For this purpose, the top part of Figure 1 shows the NVIDIA Nsight Systems profile for a single UDM time step. In the top part of Figure 1, less than 1 % of data transfers occur between the Central Processing Unit (CPU) and GPU. Each time step executes up to 112 short kernels in less than 10 ms, dominated by the renew_noise_kernel function (27 %) and 24 Fourier transforms (16 %). To reduce kernel launch overhead and memory traffic, multiple small kernels are grouped into larger ones. This kernel fusion yields a 20 % performance gain, reducing the kernel count from 112 to 69, and lowering global memory operations by up to 33 % for reads and 87 % for writes, enabling the memory subsystem to reach 90 % throughput. The renew_noise_kernel is responsible for RNG in UDM and is further optimized by extracting RNG to a dedicated GPU and overlapping the generation with simulation. This reduces the share of the function of the runtime from 26 % to 2.9 % (bottom part of Figure 1) and yields an additional 30 % speedup, resulting in a total 70 % improvement over the baseline UDM application without optimizations. The approach generates random numbers for L upcoming steps in advance and transfers them asynchronously, ensuring they are ready when needed. Moreover, Figure 2 shows steady UDM performance gains across NVIDIA GPUs, with the optimized H100 achieving a 155 % speedup over the A100 baseline through combined software and hardware improvements. 2.2
SOMA Optimization
Following the same approach as for UDM, the SOMA application [7] is profiled to identify major performance bottlenecks. The initialization and testing phases originally consume about 235 s, dominated by generating bead coordinates and
Performance (TPS)
Coupling Complementary Simulations for Combined Perf. and Energy Opt.
50
+155% 96
+70% 65
100
5
38
0 A100 Baseline A100 opt.
H100 opt.
Fig. 2: UDM code performance in Time steps Per Second (TPS) for the baseline and optimized versions, tested across various NVIDIA GPU architectures. The percentages indicate the speedup relative to the A100 baseline.
Fig. 3: Profile of the SOMA application with two major kernels consuming 95% of execution time
4
3.5
3 2
2.5 1.6
1 A100 Base A100 opt. H100 opt.
Energy consumption (kJ)
Performance (TPS)
validation functions. Offloading these routines to the GPU reduces their runtime to under 2 s, eliminating repeated overhead when coupling with the continuum model. As depicted in Figure 3, two main kernels dominated the execution time: mc_polymer_iteration (65 %), which performs biased trial moves and energy evaluations, and update_density_fields (25 %), which updates particle density fields. Both kernels are optimized by improving memory coalescing, caching frequently used variables, and adjusting launch configurations to reduce thread divergence and register pressure. As a result, memory throughput nearly doubles, and kernel runtimes are improved by 40 %.
90 90 70 50 30
46 26
10 A100 Base A100 opt. H100 opt.
Fig. 4: Performance in TPS and energy consumption in kJ of the SOMA application across GPU generations.
6
A. Dabah et al.
Steps per kJ (norm.)
Speedup (vs 4 GPUs)
Figure 4 shows the performance and energy efficiency of SOMA using one GPU. From the A100 baseline (SOMA without optimizations) to the H100 GPUs, the SOMA application achieved over a 2× speedup and a more than three times reduction in energy consumption, highlighting the benefits of combined software tuning and architectural advances. Note that the impact of optimizations in a multi-node setup is reduced by communication overhead at each step of the simulation.
Actual Ideal scaling
4 3 2 1 4
8
12 GPUs
(a) Speedup – higher is better.
16
1.4
Actual Ideal (constant efficiency)
1.2 1 0.8 0.6 4
8
12
16
GPUs (b) Steps per kJ – higher is better.
Fig. 5: SOMA scaling on A100 GPUs: from 4 to 16 GPUs, speedup reaches only 2.33× (parallel efficiency ≈ 58%). Energy per step increases by 72%, and energy efficiency (steps/kJ) drops by 42%. Adding GPUs makes each simulation step less energy efficient, motivating our coupled approach that uses only 4 GPUs.
Figure 5 shows that scaling standalone SOMA from 4 to 16 GPUs leads to significant parallel efficiency reduction due to communication and synchronization overheads. More critically, it increases energy per timestep, as idle GPUs still draw power. This exposes a fundamental limit of scaling the expensive particle model alone. Our coupled UDM–SOMA approach bypasses this limit by replacing most of the expensive work with the efficient continuum UDM on just 4 GPUs, yielding higher speed and far lower energy per step.
3
Coupling Scheme
The coupling scheme performs a concurrent multi-fidelity modeling based on the UDM and SOMA applications using the coordinator library. 3.1
Coordinator Library
Both, SOMA and UDM are Message-Passing Interface (MPI) applications. A comparison of their coupling requirements with the technical possibilities and state-of-the-art in MPI simulation coupling suggested to implement their coupling as a lightweight MPI-based coordinator library. As shown in Figure 6, the
Parent App
UDM
ML
7
...
SOMA 2
results
Coordinator Library
inputs
SOMA 1
Child App spawn
MPI Library ParaStation MPI
Coupling Complementary Simulations for Combined Perf. and Energy Opt.
ML
ML
...
execution time
Fig. 6: Overview of coordinator library integration into MPI library (ParaStation MPI) and parent (UDM) and child (SOMA) applications. The workflow at execution time including spawn of SOMA via ML-based decision making and data exchange between parent and child applications is shown on the right.
computationally less expensive continuum model UDM acts as the parent application for the coupling, while the computationally more expensive SOMA model is spawned as child application. For spawning the child application, the coordinator library leverages the MPI spawning interface MPI_COMM_SPAWN and the capabilities of integrating new MPI processes into MPI communication via an inter-communicator. This ensures that the spawn mechanism is portable to other HPC applications and not limited to the simulation coupling use case presented in this work. In order to decide when to spawn a child application and what data to send to the child application, the coordinator library calls the Machine Learning (ML)-based decision-making callback [2], which is a multilayer perceptron (MLP) model called from the parent application. It takes descriptors of the current and previous concentration fields from UDM and outputs the expected discrepancy between continuum and particle results. The subdomain boundaries are then identified via thresholding and post-processed to enforce the zero-flux constraint. Training data were generated from paired UDM–SOMA simulations. Inference overhead is negligible; details are given in [2]. The outputs of this callback provide the spawn decision as well as the input data for the child application to be spawned. The input data is sent to the child application using MPI communication procedures and an inter-communicator. Similarly, once the child application has finished its computation, results are sent back to the parent application for further processing and integration into the overall coupled simulation progress. Through this exchange of data using MPI communication parent and child applications are synchronized to the required extent. The parent application may spawn several instances of the child application consecutively based on the need and the outcome of the decision-making callback (see for example the spawn of “SOMA 2” in Figure 6). Thereby, the resources used by the child application can be tailored to the use case dependent algorithmic and computational requirements that emerge at execution time. This fine-granular control over resource usage helps minimizing the energy footprint
8
A. Dabah et al.
of the overall coupled simulation since the child application may only be spawned at times when it is required for the input data that it really needs to process. For the simulation experiments presented in this work, ParaStation MPI [13] was used together with the coordinator library which was compiled and linked against ParaStation MPI. To provide additional spawning parameters in the MPI_COMM_SPAWN procedure, such as the number and type of nodes or GPUs to be used by the child application, non-MPI standard features were added to ParaStation MPI. The parallel execution environment can then take these additional parameters into account to spawn the child application processes on the desired resources. Using the coordinator library with other MPI libraries works in general, however the additional non-standard spawn configuration features may not be available. 3.2
Coupling
Given a morphology (polymer structure), i. e., the concentration fields ϕα (r, t), a coupling decision and subsequent spawn or communication step are performed periodically every tsync . At the first synchronization time, the UDM communicates the current and previous morphologies to the ML model [2], which predicts the subdomain boundaries in the z-direction for the particle-based SOMA simulation. To satisfy the zero polymer flux constraint, boundaries are extended if required. The UDM then spawns a SOMA simulation via the coordinator library (see Figure 6) and receives an MPI inter-communicator for data exchange. A virtual HDF5 image containing simulation parameters, subdomain concentration fields, and boundary fluxes is transmitted to initialize the SOMA run. Each SOMA simulation begins by generating particle positions that reproduce the supplied concentration fields. Molecules are placed within half a mean end-to-end distance of their target positions and equilibrated using an umbrella potential for about half a synchronization period. The boundary zones in the simulation act as transition layers where particles are converted into continuum units (and vice versa) to maintain a constant flow and stable density at the edges of the box. These boundaries (fluxes) and conversion rates are periodically updated through synchronization with the UDM. The parent UDM concurrently evolves the full domain and replaces the subdomain concentrations with the data received from SOMA. If polymer fluxes exceed a threshold, the SOMA run is terminated and a new subdomain is spawned. Readers may refer to [5] for more details about the coupling theory.
4
Results
In this section, we present example results of large simulation domains and discuss considerations required for ideal synchronization and the resulting speedup compared to the baseline SOMA on 8 A100 GPUs. All comparisons in this section use NVIDIA A100 GPUs (JUWELS Booster nodes, 4 A100s per node, interconnected via NVLink within nodes and 4 HDR-200 InfiniBand across nodes).
Coupling Complementary Simulations for Combined Perf. and Energy Opt.
9
We deliberately run the coupled simulation on fewer GPUs (4) than the standalone SOMA baseline (8), making the comparison conservative. This asymmetry is by design: coupling is a way to achieve more with less. The energy consumption is obtained from the LLview job accounting system [4], which reports total node energy (CPU, GPU, memory, and network) at job granularity. The reported energy per time step is calculated as the total job energy divided by the number of simulation steps.
Fig. 7: Time evolution of the B-block concentration ϕB (r, t) in UDM (left) and SOMA (right).
Using this multiscale scheme, we simulate the Nonsolvent-Induced Phase Separation (NIPS) process within a three-dimensional domain of size V = Lx × Ly × Lz = 19.4Re × 22.4Re × 96Re , discretized into Nx × Ny × Nz = 194 × 224 × 960 grid cells. Here, Re denotes the polymer end-to-end distance, used as a natural unit of length. The x and y plane represents the lateral dimensions of the membrane, while the extended z-direction (Lz ) corresponds to the film-thickness or phase-separation axis. The system is evolved for a total simulation time of −1 T = 96λ−1 0 . The synchronization period is tsync = 0.16λ0 , and each spawned SOMA simulation runs for 15 such periods. The simulation was executed on a single JUWELS Booster node, assigning one GPU to UDM and three to SOMA, resulting in ∼20 % UDM idle time. As shown in Figure 7, the subdomain follows the structure formation front where nonsolvent first phase-separates from the polymer. The used error prediction guides subdomain placement by tracking the region of highest error, effectively capturing the structure formation front and maintaining the polymer flux below the prescribed threshold. The final output structure represents the vitrified membrane structure, that can be compared to standalone simulations of SOMA and UDM. Figure 8 compares the coupled multi-scale simulation to an independent full SOMA run (V = 14Re × 16Re × 200Re , constrained to the smaller z-dimension in the plot), as well as to an independent UDM simulation (V = 14Re × 16Re × 96Re , at increased grid resolution Lx /Nx = Ly /Ny = Lz /Nz = Re /15). This is deliberate to give the standalone UDM its best achievable accuracy, to see the
10
A. Dabah et al.
Fig. 8: Comparison of final B-block concentration fields of standalone SOMA, coupled and standalone-UDM simulation, showing (a) the 3D morphology, (b) the laterally-averaged polymer concentration and (c) vertical correlation.
SOMA
UDM is waiting for SOMA
Fig. 9: Nsight Systems profiling of the coupled multi-scale simulation.
impact of the coupling. Contrarily to the UDM simulation, the coupled simulation closely reproduces the high-fidelity SOMA results with only minor deviations near the interface (z − zI ≈ 5–10Re ) due to residual continuum dynamics. Quantitative analyses of laterally-averaged polymer density ϕ̄xy P (z) and vertical correlation C(∆z ) confirm highly-improved agreement of the coupled simulation compared to the standalone UDM simulation. In addition, while UDM overestimates the persistence of the macro-pores, the coupled version successfully resolved this issue bringing the simulation results in line with the SOMA reference. Note that the three simulations in Figure 8 use different domain extents in z because each method has different stability requirements: SOMA requires Lz = 200 Re , whereas the coupled simulation reaches the same converged morphology at Lz = 96 Re because the continuum part of the domain absorbs the far-field dynamics. Therefore, we compare each method at the domain size it requires to be physically valid, not at a common Lz . Figure 9 shows an excerpt of the NVIDIA Nsight Systems timeline for the coupled multi-scale simulation, illustrating the concurrent execution of the continuum-based UDM and the particle-based SOMA components. The figure also highlights the minimal impact of communication overhead. However, it reveals synchronization delay, causing to waste computational resources. The idle periods observed occur when the continuum UDM simulation finishes its time steps faster than the corresponding particle-based SOMA simulation. By varying the
Lz = 18Re
50
Lz = 15Re Lz = 12Re
0
−50
10 Lz = 21Re Lz = 18Re
150
200
50
(a) Idle time vs. subdomain length Lsd .
24.5×
200 28.9
200
(b) Speedup vs. subdomain length Lsd .
Norm. energy (%)
400
150
Domain length Lsd /Re
707.5
600
100
100
50
96% energy saving
100
Domain length Lsd /Re
Energy per time step (J)
Lz = 15Re
5
Lz = 12Re
50
800
11
15
Lz = 21Re
Speedup factor
Idle time difference (%)
Coupling Complementary Simulations for Combined Perf. and Energy Opt.
0
0 SOMA
Coupled simulation
(c) Energy per time step.
SOMA Coupled Simulation (d) Normalized energy consumption.
Fig. 10: Coupled multi-scale simulation idle time (10a) and overall speedup (10b) as functions of subdomain length Lsd , demonstrating up to 13× speedup and 96 % energy saving (10c and 10d) compared to the baseline SOMA on two nodes, i. e., 8 A100 GPUs.
total domain size Lz and subdomain length Lsd , we can control this computational imbalance as shown in Figure 10. Figure 10 shows the impact of varying the simulation domain length Lz i. e., the thickness dimension of the simulated polymer film and SOMA subdomain size Lsd on idle time, and overall performance in our multi-scale coupled simulation. Figure 10a plots the UDM idle time percentage for different subdomain sizes Lsd . Increasing the subdomain length increases computational cost of a SOMA simulation which is proportional to the number of simulated polymer beads. This impacts the idle time of the UDM process. Two configurations lead to near zero percent idle UDM time at {Lsd = 12Re , Lz = 78Re } and {Lsd = 18Re , Lz = 100Re }. Figure 10b shows the speedup compared to a full SOMA simulation on two JUWELS Booster nodes with four A100 GPUs each. Indeed, the two configurations from Figure 10a correspond to the best attained speedups compared
12
A. Dabah et al.
to baseline, showing respectively 13× and 11.5×. The best trade-off occurs at Lsd = 18Re , Lz = 78Re , where the coupled simulation achieves both a close to zero UDM idle time, and standard thickness of the simulated polymer film reflecting on the speedup to reach 13×. Increasing the thickness of film beyond the standard value reduces the overall speedup due to UDM taking more time to finish than SOMA. Figure 10c and Figure 10d present the energy (J) consumption per time step for the baseline SOMA and multi-scale coupled simulation. Figure 10c shows a more than 24× improvement in energy consumption per time step resulting in up to 96 % saved energy compared to the full SOMA baseline on eight A100 GPUs. This dramatic saving stems from two factors: (i) the inherent efficiency of the continuum UDM for the simulation domain, and (ii) the reduced idle time when the subdomain is optimally sized, demonstrating that performance and energy efficiency are aligned in this multi-scale approach.
5
Lessons Learned
We summarize four lessons that we believe transfer beyond this work. Lesson 1: Adding more computers saves time, not energy. A natural reaction to a slow simulation is to run it on more processors. This shortens the execution time but it does not, in general, reduce the total energy consumed. The reason is that once communication between processors starts to dominate, each processor spends time waiting rather than computing, while still drawing power. Formally, if η(N ) measures the parallel efficiency for N processors (ideal is η = 1), then the runtime scales as T (N ) = T (1)/ (η(N )N ) but the total energy scales as T (1) , where PGPU represents the power consumption per GPU. E(N ) ≈ PGPU η(N ) Hence, it only grows worse as efficiency η drops, which is the case for large numbers of scientific applications. In our case, doubling the number of GPUs from 8 to 16 made the simulation 1.45× faster but cost 1.72× more energy per simulated time step. Therefore, energy savings cannot come from speedup alone or efficient hardware, they must also have to come from less workload if possible. This is exactly what our coupled model achieves, by replacing the expensive particle-based calculation with a much cheaper continuum calculation. Lesson 2: Simulations should weigh accuracy against energy efficiency. At present, our framework decides to invoke the expensive model whenever the cheap model’s prediction looks physically unreliable. This is a sensible criterion but it ignores cost. A more refined criterion would compare the expected gain in accuracy against the energy required to obtain it, invoking the expensive model only when the gain is worth the energy cost. Building this cost-awareness into scientific simulations is, in our view, an underexplored direction with a good energy-saving potential.
Coupling Complementary Simulations for Combined Perf. and Energy Opt.
13
Lesson 3: “Faster” and “energy-efficient” are not the same thing, and should be reported separately. Performance in high-performance computing are generally expressed as speedups. Energy are usually expressed as percentage reductions. These are related but not equivalent, and reporting only one can be misleading: a code can become faster while becoming less energy-efficient, by running more processors that mostly wait on each other. Three performance indicators are sufficient to remove the ambiguity: (1) How much faster the code runs (speedup), (2) how much energy each unit of useful work consumes, and (3) how many units of work are done per Watt. For our scaling experiment, the three performance indicators told visibly different stories, which is why we report all three. We suggest this triple, together with full-node power measurements, for example as displayed through integrated tools such as LLview [4] reports at FZJ-JSC. Lesson 4: Heterogeneous workloads require heterogeneous workflows Effective tooling is required in order to combine separate applications into a super-application to solve multi-scale/multi-fidelity scientific challenges collaboratively. Such superapplication use cases are not limited to the polymer physics use case studied in this paper. They are also conceivable for example in weather and climate modeling (a coarse global model coupled to a fine-grained model over a single storm), in chemistry (classical molecular dynamics coupled to a quantum-mechanical calculation around a reacting bond), and in engineering fluid dynamics (a fast turbulence approximation coupled to a detailed simulation near a critical component). A lightweight coordinating entity can effectively decouple direct applicationapplication interaction and act as a generalizable translator. Well-defined APIs are essential. Also heterogeneous hardware platforms are enabled through this coordinator, an important feature for upcoming HPC system designs.
6
Conclusion
This work demonstrates a pathway toward sustainable, energy-aware polymer simulation by combining two algorithmically complementary methods with GPUspecific optimization. By coupling the continuum UDM with the particle-based SOMA, and optimizing both independently and jointly, we achieved a 13× speedup resulting in 24.5× less energy consumed per time step and 96 % reduction in energy consumption while maintaining the same scientific fidelity. The results highlight the high impact of algorithmic design and complementarity compared to GPU-specific optimization alone. The coordinator library provides a mechanism for managing hybrid, multi-model workflows on heterogeneous HPC systems. The results underline the importance of software co-design and workload orchestration for sustainable simulations, where performance per Watt/Joule has become a key efficiency metric. Future work will extend the multi-scale idea to other workloads to minimize the energy footprint for large-scale scientific simulations. Acknowledgments. This work was funded by the German Federal Ministry of Research, Technology and Space (MExMeMo, grants 16ME0661,16ME0660,16ME0658K).
14
A. Dabah et al.
Computing time was provided by the Gauss Centre for Supercomputing (GCS) via the John von Neumann Institute for Computing (NIC) on the JUWELS Booster at JSC. Access to JUPITER and JEDI was granted through the JUPITER Research and Early Access Program. JUPITER is funded by EuroHPC, the German Federal Ministry, and the Ministry of Culture and Science of North Rhine-Westphalia.
References 1. Blagojevic, N., Müller, M.: Simulation of Membrane Fabrication via Solvent Evaporation and Nonsolvent-Induced Phase Separation. ACS Appl. Mater. Interfaces 15(50), 57913–57927 (2023). 2. Busch, M., Häfner, G., Xie, J., Tacke, M., Müller, M., Cyron, C.J., Aydin, R.C.: Machine-learned domain partitioning for computationally efficient coupling of continuum and particle simulations of membrane fabrication. arXiv preprint arXiv:2510.19051 (2025) 3. Etinski, M., Corbalan, J., Labarta, J., Valero, M.: Parallel job scheduling for power constrained hpc systems. Parallel Computing 38(12), 615–630 (2012) 4. Frings, F., et al.: Supporting hpc users with llview. In: High Performance Computing. Springer Nature (2025). , 5. Häfner, G., Busch, M., Dabah, A., Xie, J., Blagojevic, N., Das, S., Happ, S., Pickartz, S., Großmann, L., Radjabian, M., et al.: Concurrently coupling particle and continuum simulations to study block copolymer membrane fabrication. The Journal of Chemical Physics 164(21) (2026) 6. Häfner, G., Müller, M.: Gpu-accelerated continuum dynamics of block copolymer blends and solutions. The Journal of Chemical Physics 164(2) (2026) 7. Herten, A., Achilles, S., Alvarez, D., Badwaik, J., Behle, E., Bode, M., Breuer, T., Caviedes-Voullième, D., Cherti, M., Dabah, A., et al.: Application-driven exascale: The JUPITER benchmark suite. In: SC24: International Conference for High Performance Computing, Networking, Storage and Analysis. pp. 1–45. IEEE (2024) 8. Mei, X., Chu, X.: Dissecting gpu memory hierarchy through microbenchmarking. IEEE Transactions on Parallel and Distributed Systems 28(1), 72–86 (2016) 9. Mei, X., Wang, Q., Chu, X.: A survey and measurement study of gpu dvfs on energy conservation. Digital Communications and Networks 3(2), 89–100 (2017) 10. Müller, M., de Pablo, J.J.: Computational approaches for the dynamics of structure formation in self-assembling polymeric materials. Annual Review of Materials Research 43(1), 1–34 (2013) 11. NVIDIA Corporation: NVIDIA Nsight Systems. (2025), accessed: 2025-11-13 12. Schneider, L., Müller, M.: Multi-architecture monte-carlo (mc) simulation of soft coarse-grained polymeric materials: Soft coarse grained monte-carlo acceleration (soma). Computer Physics Communications 235, 463–476 (2019) 13. Suarez, E., Eicker, N., Moschny, T., Pickartz, S., Clauss, C., Plugaru, V., Herten, A., Michielsen, K., Lippert, T.: Modular Supercomputing Architecture: A success story of European R&D. White paper, ETP4HPC (5 2022). 14. Uneyama, T., Doi, M.: Density Functional Theory for Block Copolymer Melts and Blends. Macromolecules 38(1), 196–205 (2005).