Integrated Computational Framework

• Integrated Computational Framework is a modular, extensible system that unifies simulation, numerical analysis, and data management via interoperable modules.
• It employs interrupt-driven workflows, nonblocking MPI communication, and multi-hierarchical fidelity management to ensure rapid, responsive user interactions.
• The framework supports legacy and third-party codes with minimal modifications, enabling scalable high-performance computing for diverse scientific applications.

An integrated computational framework is a modular, extensible system that unifies algorithmic, numerical, and data management tools into a seamless workflow for advanced simulation, analysis, or optimization tasks. Rather than relying on monolithic codes or ad hoc scripts, such frameworks abstract key computational tasks—such as problem parameterization, hierarchical fidelity management, data exchange, and interactive steering—into interoperable modules, typically operated via well-defined APIs or system calls. The unification of these components serves to maximize flexibility, real-time responsiveness, and user interactivity while minimizing invasive code changes, facilitating high-performance computing across distributed, parallel architectures (Knežević et al., 2018).

1. Modular Architecture and Core Components

The archetype for an integrated computational framework in computational engineering comprises four key components:

• Simulation Core: Executes the user’s scientific code (e.g., finite element, CFD, transport solvers), modified only at designated hook points where the framework API intervenes. The core is typically left intact to avoid intrusive rewriting, supporting legacy and third-party codes.
• Scheduler / Steering Layer: Mediates user-supplied updates (e.g., boundary conditions or solver parameters) via an asynchronous message-passing interface (MPI). By registering Unix-style interrupt handlers (SIGALRM), it enables periodic preemption and injection of new configuration data, mapping human input to state variables at runtime.
• Communication Layer: Implements bidirectional, nonblocking communication between simulation and front-end GUI processes via MPI calls (MPI_Iprobe, MPI_Irecv, MPI_Bcast_nonblocking). To avoid bottlenecks, hierarchical broadcast trees are employed, supporting scalable O(log P) propagation of updates to all parallel ranks.
• Visualization / GUI Module: Runs as a separate process (often using toolkits like wxWidgets or ImageVis3D) and visualizes scalar, vector, or volumetric outputs in near real time. Changes to visualization are trigered only on receipt of updated data, and dynamic level-of-detail adjustments minimize render latency.

This modularity enables the seamless replacement or extension of any subsystem, as well as robust integration with distributed-memory parallelism and high-throughput user interaction (Knežević et al., 2018).

2. Interactive Steering, Interrupt Handling, and Asynchronous Updates

A defining innovation is the interrupt-driven workflow, which structures simulation progress into atomic time slices (∆t). At each interval, the registered signal handler preempts the simulation to poll for pending user commands. If updates are present, state variables such as loop bounds, boundary conditions, or discretization parameters are atomically replaced and the simulation unwinds to the outer loop for re-initialization.

The algorithmic skeleton is:

void steering_handler(int signum) { if (Framework_Iprobe(&cmd)) { Framework_Recv(&cmd); update_sim_state(cmd); restart_flag = 1; } Framework_SetAlarm(interval_ms); }

And the main simulation loop is augmented to:

while (not converged) { for (...) { for (...) { compute_kernel(...); if (restart_flag) { restart_flag = 0; goto while-top; } } } }

This scheme allows user-driven steering with minor code modifications (typically only in parameter declarations and nested loop controls), and can be implemented with 2–8 hours of effort for most codes. Critical best practices include minimizing the atomic computation size guarded by interrupts and judiciously selecting the alarm interval (typically 2–5 ms) to ensure negligible overhead (<5%) (Knežević et al., 2018).

3. Multi-Hierarchical Model Fidelity Management

Interactive computing imposes conflicting demands for rapid feedback during frequent user updates and high-accuracy solutions when idle. The framework addresses this by simultaneously maintaining multiple model discretization levels (e.g., coarse/fine grids, angular quadrature levels, polynomial orders) and dynamically switching fidelity based on the measured user interaction rate:

• Define a rate $r$ = (number of user events) / $T_{window}$.
• If $r > r_{high}$, run only the fastest/coarsest configuration; if $r < r_{low}$, run highest fidelity; otherwise, persist at the current level.

Transitions exploit coarse-to-fine solution initialization, e.g., interpolating the coarse grid solution to the fine grid:

$u_{\ell+1}^0 = I_h^{2h} u_{\ell}$

with prolongation operator $I_h^{2h}$. The error reduction observed in practical cases is significant (e.g., relative $L^2$ errors $\epsilon_{150\times 150} \approx 4.5\%$, $\epsilon_{75\times 75} \approx 14.6\%$). Switching empirically yields up to a 2$\times$ speedup in response times during heavy steering without a persistent loss in accuracy (Knežević et al., 2018).

Application	Coarse Level	Fine Level	Error (Fine)	Error (Coarse)
Heat/CFD	75×75	300×300	4.5%	14.6%
Neutron Transp	9 angles	36 angles	$-$	$-$

4. Real-Time Communication and Latency

Efficient, nonblocking MPI communication is employed throughout:

• Front end: user interface threads send commands asynchronously (MPI_Isend) and listen on result channels.
• Back end: signal-handling worker thread probes for messages (MPI_Iprobe, cost $\tau_{probe}\sim$ μs scale). If an update is flagged, parameters are received (MPI_Irecv), incorporated, and then broadcast using a hierarchical tree.

For $P=32$ ranks, messages of 64 B, and reasonable network parameters, the one-cycle overhead is $\lesssim 20\,\mu$s. Avoiding a centralized master node and propagating via a tree structure ensures no single point of failure or bandwidth bottleneck (Knežević et al., 2018).

5. Performance Benchmarks and Engineering Case Studies

Empirical validation in multiple domains demonstrates low framework overhead and dramatic improvements in user interaction speeds:

• Overhead: 6–12% for large-scale heat, FEM, and biomedical simulations with 1 ms alarm interval (see Table 1 in the original paper).
• Restart latency: 0.8 s (300×300 grid) down to 0.05 s (75×75 grid) in heat studies; neutron transport restarts <1 s even in 500 s full sweeps; update rates 20–0.5 Hz depending on polynomial order in p-FEM.
• Speedup: Multi-hierarchy switching yields up to 2× throughput with no loss in overall simulation fidelity.

Table: Overhead vs. core count for three benchmarks:

Benchmark	1 Core	2 Cores	4 Cores
Heat conduction (300×300)	6.3%	7.1%	9.4%
SCIRun CG solver	12.1%	10.5%	12.8%
Biomedical FCM (p=4)	10.8%	11.7%	11.3%

In all cases, steering-induced restarts incur only modest costs compared to the full simulation time (Knežević et al., 2018).

6. Guidelines for Integration and Extensibility

The framework can be retrofitted to legacy codes or wrapped around new simulators with minimal friction:

• Parameter and delimiter variables must be declared global/volatile to permit runtime mutation.
• Simulation code is instrumented only at loop boundaries and interrupt points via the provided C API.
• Visualization backends only require linking to receive and render the simulation snapshot payloads.
• The broadcast-based communication layer ensures scalability for massively parallel and distributed environments.
• Practitioners should adapt the alarm interval and restrict the atomicity of interrupt-protected code regions to comply with solver-specific loads and parallel scaling behavior.

The modular architecture accommodates the addition of further fidelity levels, alternative message-passing libraries, and enhanced GUI front-ends without entangling domain-specific logic (Knežević et al., 2018).

7. Impact and Broader Significance

This paradigm enables true interactive high-performance scientific computing, with immediate user feedback, responsive steering, and persistent visualization even at extreme scale. It is generalizable to a wide range of engineering applications, from heat transfer to neutron transport to biomedical simulations, accelerating convergence and exploration in design and analysis loops while preserving core simulation fidelity and code integrity. The ability to couple human input dynamically into distributed simulations is essential for next-generation in-the-loop optimization, uncertainty quantification, and digital twin frameworks (Knežević et al., 2018).