betaFeedback

WorksComputer Science

Application-Defined Abstractions to Separate Numerical Intent from Computation Orchestration

Abstract

In High-performance Computing the holy grail has been to translate numerical algorithms expressed in mathematical notation into code that performs well across a range of platforms. A variety of portability frameworks have abstracted data layout, parallelization and orchestration from application's view, however, the resulting format is still code that conforms to the idioms of the framework. Additionally, substantial refactoring is typically needed to achieve performance goals. Increasing sophistication of Large Language Models (LLMs) naturally raises the question whether they can be used to make application codes and/or solvers both portable and performant. The obstacle is the lack of correctness guarantee in LLM produced code. In this paper we pose the question differently – can we start with expressing numerical intent of the code into an immutable core arithmetic component isolated from the surrounding code such that the surrounding code can be safely generated by the LLMs? We answer this question by using Spark, a mature compressible hydrodynamics solver in Flash-X, a multiphysics software system. We use LLM assistance in devising the abstractions and embedding them in the solver. Once properly verified, the resulting solver is lowered to concrete realization deterministically with tools also built with LLM assistance. The driver of the numerics and the code for interfacing with the application are generated by the LLMs. The resulting solver is exercised within Flash-X and with a separate environment we built for this experiment. Our results show that this is a viable approach for producing correct and performance portable code.

Authors’ Contact Information: Elena Aschmann, Swiss Federal Institute of Technology, Zurich, Switzerland, [email protected]; Anshu Dubey, RIKEN Center for Computational Science, Kobe, Japan, [email protected]; Mohamed Wahib, RIKEN Center for Computational Science, Tokyo, Japan, [email protected]; Jens Domke, RIKEN Center for Computational Science, Kobe, Japan, [email protected]. CCS Concepts: • Software and its engineering → Software architectures; • Applied computing → Physics;

Introduction

For domain scientists and applied mathematicians working in high-performance computing (HPC) environments the holy grail has been to express their algorithm in purely mathematical notation that can be used to generate code that performs well across a range of platforms. The increasing sophistication of large language models (LLMs), and agents that drive them, have brought us close to achieving this goal. Figure 1 summarizes the premise and the process involved. Blue box shows how an algorithm might be presented in mathematical notation in a paper. The green box describes step-by-step arithmetic needed to implement the algorithm – a representation preferred by the domain scientists and computational mathematicians. This description is implementation independent. The yellow box shows how the representation in green box can be converted to a code with embedded abstractions that are solver or application specific. These abstractions, and the tools for lowering them to target language of the code are developed with LLM assistance. The pink box shows what corresponding traditional code might have looked like, highlighting portions that are core arithmetic versus surrounding code. The lavender box shows the core arithmetic that is translated using a verified tool and the variants of the surrounding code that are generated using LLMs. Our ultimate goal is to go from blue box to lavendar box, but for this work we begin from the green box. We start with a mature solver, extract its arithmetic into mathematical notation and use that as the basis for generating a “new” implementation. We take this approach because with a well tested solver we have a way to validate our hypothesis.

A methodology to achieve separation of the numerical intent of the solver from its surrounding code through application defined and controlled abstractions

Figure 1. A methodology to achieve separation of the numerical intent of the solver from its surrounding code through application defined and controlled abstractions

We use Spark [6], a solver for compressible hydrodynamics, embedded in a large multiphysics software system, Flash-X [10] for the experiment. We first extract the description of the algorithm in a detailed mathematical notation similar to what is shown in the green box in Figure 1. Then we convert this representation of the core arithmetic into a succinct and reusable form that is independent of the surrounding infrastructure necessary to facilitate the computation. Components of such infrastructure include data representation and movement, coordinating interactions among physics components, exposing parallelism, managing communication, and accommodating the constraints of different computing architectures. We refer to this infrastructure as surrounding code and distilled numerical component of the code as core arithmetic from here on for ease of explanation. With this exercise we wished to explore how far could we push code generation with LLMs to produce reliable code suitable for different platforms. Our finding is that it is possible to design, build and maintain application-specific abstractions that distance the core arithmetic from surrounding code up to the degree of intrusiveness acceptable to the developers.

Such a separation has long been desirable for maintainability and portability, and several efforts over the years have achieved it to varying degrees [2, 3, 5, 8, 11, 14, 21, 22]. Fully realizing this separation has not been possible because application-specific abstractions were not viable as long as every line of code had to be written by humans. The breadth and depth of expertise necessary to design, develop, and maintain abstractions is rare enough that groups engaged in these activities had to necessarily target a broad range of applications. The non-specificity resulting from this constraint led naturally to libraries that are large and complex and require significant resources to maintain and keep up to date with evolution in technology.

From the applications perspective also these solutions only provide moderate benefits. They have their own type system, data structures, and programming idioms which the application must adopt, and even then obtaining performance requires the application structure to be suitable for the target architecture. AI-assisted code development [12, 16, 17] could change this trade-off. However, even a fully validated specification cannot simply be handed over to an LLM to produce concrete code directly because of the fundamental limitations in the abilities of the models to guarantee correct outcome. The key, therefore, is to convert the mathematical notation to application specified abstractions and use LLMs to build tools that can lower the abstractions to a concrete realization in the target language. Once the abstractions and tools have been validated the translation is deterministic and by definition guaranteed to be correct up to the rigor of the verification applied to the translation. Because the abstraction boundary is controlled by the application rather than by an external framework, it can evolve with the application and can be introduced incrementally into an existing code base.

In this paper, we develop and demonstrate this approach with Spark and use two different sets of abstractions to demonstrate the range and flexibility of the approach. Computational kernels are expressed using application-defined abstractions in both versions, though at different levels of intrusiveness into the original code.

The contributions of this work are:

  • Defining abstraction boundary that guarantees reliable outcome with LLM assisted code generation.

  • A stable, infrastructure-agnostic core arithmetic component where explicit data references can be replaced by symbolic, parameterized references, creating a maintainable scientific artifact.

  • AI-assisted transformation of existing scientific software in a workflow where use of generative techniques is shifted from repeatedly generating scientifically sensitive code to performing constrained, verifiable source transformations.

  • Demonstration of correctness across independently developed infrastructures and performance on different architectures.

Premise

Large scientific simulation codes differ in important ways from conventional application software in that scientific knowledge is encoded in the implementations whose correctness has been established over many years of scientific use. This is the primary reason why LLM assisted development has not made as many inroads in scientific computing as it has elsewhere. However, the scientifically meaningful core arithmetic of the solvers on which the reliability of the obtained results hinges is typically a small fraction of the overall code. Therefore, if this core could be effectively isolated and made immutable then LLMs can be used for generating the surrounding code. Given the lack of guaranteed correctness of LLM generated code, any adoption of generative practices must be accompanied by rigorous verification.

The challenge has been that the organization of data is usually embedded in numerical source code through explicit array subscripts and derived-type component selections. Consequently, a change in the data layout requires changes throughout the code, therefore, any LLM generated surrounding code would also entangle the arithmetic. The premise behind our experiment is that completely detaching the core arithmetic from the surrounding code is possible and the exercise of detachment will result in a precise elucidation of the scientific core of the code without being contaminated by details of the infrastructure that frames it. This can be done by defining a vocabulary of symbols that have specific meanings within the context of the application. Symbols can be as limited as data references only, or they can represent arbitrarily sized code-snippets with parameterization. One then build tools to lower these symbols into the concrete source-level expression required by a particular environment. Once verified and validated, this representation becomes the enduring and stable scientific representation of the application.

The resulting development model differs from both conventional abstraction libraries and unconstrained AI code generation. The scientifically significant arithmetic remains an explicit, maintained software artifact. The application itself determines the abstraction, AI assists in creating and manipulating this representation, while deterministic code generation lowers the abstractions into infrastructure-specific source code. This division provides the basis for the approach demonstrated in the remainder of this paper.

Instruments of Experimentation

We give a brief outline of the solver and the code used in this study to facilitate the description of the methodology. Flash-X is a component-based software system for building multiphysics simulation applications where different permutations of code components generate specific instantiations capable of simulating the requisite physics. Components can have multiple alternative implementations to account for either different physical regimes or different fidelity requirements. It can be run with a uniformly discretized mesh (UG) or with adaptive mesh refinement (AMR) where higher resolution is used in the mesh only where necessary. Flash-X has a customized macro-expander [9] that became the starting point for the abstractions derived in this work. These custom macros can have multiple alternative definitions which allow them to unify code variants into one source. The expander has a built-in ability to arbitrate on which definition to use where to meet the requirements of various configurations.

Spark solves the equations of ideal MHD using finite-volume discretization and explicit time integration, although in this work we disable the magnetic field component of the solver and use only the hydrodynamics. The solver begins by performing high-order spatial reconstruction on the cell-averaged primitive variables to estimate their values at the interface between cells. Running offset stencils for this reconstruction results in two approximations for the vector of primitives at each interface. These left and right states at each interface are used as input to a Riemann solver to compute the average flux across each interface between cells. Then the interface fluxes are used to compute conservative flux divergences for the update of the field variables. Spark uses second- or third-order strong stability preserving (SSP) Runge–Kutta (RK) time integration [13, 26]. This approach requires multiple sub-stages in which the vector of conserved quantities is updated requiring that the general procedure outlined above be repeated two or three times depending on whether second- or third-order time integration is used. The default for reconstruction is fifth-order weighted essentially non-oscillatory (WENO) [25] with the smoothness indicators of [4], and the HLLD approximate Riemann solver [20]. These are the calculations that form the core arithmetic of the solver that we extract and to which we apply the abstractions.

We use three different applications in this study that are considered standard problems for exercising hydrodynamics solvers. They are, Sedov blast [23], Sod shock tube [28] and IsentropicVortex [24] shown in Figure 2.1 The Sedov blast problem initializes the domain with a pressure spike where the shock wave moves out radially. Sod produces all three types of nonlinear hydrodynamic waves (shock, contact, and rarefaction) associated with a shock, and isentropic vortex has a smooth profile with no shocks. All three applications use ideal gas equation of state.

Figure 2. Sedov blast application is initialized with a pressure spike at the center of the domain. The shock travels out in a radial direction as shown above. This figure shows pressure after the solution has evolved for 0.05 time units. Sod shock tube is initialized by establishing a planar interface at 45 degrees angle to the axes. The fluid is initially at rest on either side of the interface, with the density and pressure jumps. The shock, travels to the right while the rarefaction wave travels to the left. Isentropic vortex problem has a smooth flow-field (there are no shocks or contact discontinuities) and contains no steep gradients. Initialization places the vortex at the center of the domain. This figure shows evolution after 100 time units. General visualizations of Sedov blast, Sod-shocktube and Isentropic-vortex problems after they have evolved for a while

We used both commercially hosted and local institution hosted models for this work. The commercially hosted model were GPT-6.1-sol light with Codex as the agent and Opus-5.5 Medium. Institutionally hosted models included

DeepSeek-V4 and GLM-5.3. Our objective in this exercise is not to focus on any one model. We list all the models that we used for transparency and completeness.

Abstracting Data Layout

The most obvious abstraction, and the one embraced by various C++ based performance portability solutions such as Kokkos [11, 22, 30], is to eliminate explicit data references from the arithmetic. We use a macro-like mechanism explained in [9] for these simplest abstractions. Similar to macros, these symbols are strings with parameters that are replaced with their pre-defined expansions by the translator. For example, the code below can be translated into several different versions depending on how the symbols spc, spc_off, field, and field_off are defined.

rho(@spc(i,j,k)@) = U(@field(DENS,i,j,k)@)
flux(@spc(i,j,k)@) = &
    F(@field_off(DENS,i,+1,j,+0,k,+0)@) - &
    F(@field_off(DENS,i,-1,j,+0,k,+0)@)

Table 1 lists symbol definitions and their corresponding expansions into Fortran code. The first three columns show the symbol, its arguments and how it is referenced in the code snippet. The last two columns show how changing the definition changes the code translation and what goes into the source code. The juxtaposed arguments are concatenated so spc_off(i,+1,j,+0,k,+0) yields i+1,j+0, k+0. These examples illustrate that the symbolic representation preserves the logical identity and relative offsets of data references, while the mapping from logical indices to their physical ordering is determined entirely by how the symbols are defined. The entire transformation can be verified by asking for a set of definitions that are compatible with the original data layout of the code. Lowered to the level of assembly, the original code and the translated code with embedded symbols match exactly. Formal methods can also be applied to verify the semantic equivalence of any alternative set of definitions representing a different data layout [27], though we did not use them here because the variants are simple enough to produce bit-wise identical outputs.

SymbolArgumentsReferenceDefinitionTranslation
spcib,jb,kb@spc(i,j,k)@ib,jb,kbi,j,k
spckb,jb,ibk,j,i
spc_offib,io,jb,jo,kb,ko@spc_off(i,+1,j,-1,k,+0)@ibio,jbjo,kbkoi+1,j-1,k+0
spc_offkbko,jbjo,ibiok+0,j-1,i+1
fieldvar,ib,jb,kb@field(DENS,i,j,k)@var,@spc(ib,jb,kb)@DENS,i,j,k
fieldvar,@spc(ib,jb,kb)@DENS,k,j,i
field_offvar,ib,io,jb,jo,kb,ko@field_off(DENS,i,-1,j,+0,k,+0)@var,@spc_off(ib,io,jb,jo,kb,ko)@DENS,i-1,j+0,k+0
field_offvar,@spc_off(ib,io,jb,jo,kb,ko)@DENS,k+0,j+0,i-1

Table 1.

Table 1. Translation of application-defined symbols using two alternative definitions. For each symbol, the first row shows the original spatial index ordering and the second row shows the reversed ordering.

To apply this methodology to Flash-X we used the already existing macro expansion mechanism reported in [9]. We needed an alternative implementation of the mesh to test the mutability of the data layout handled in the solver. With AI assistance we generated an alternative implementation of Uniform Grid in the code which changes the order of indices from variable first to variable last (see § 6 for more details). We verified correctness by comparing the output against that produced by the unchanged solver running on the unchanged Uniform Grid.

Implementation from Mathematical Notation

In the next stage of exploration we pushed the abstractions deeper into the code. Here, we completely detach core arithmetic from the surrounding code.

Figure 3 summarizes the steps in the approach. We start with a reference implementation of the solver in Flash-X and use an LLM to translate each mathematically relevant step of the algorithm into a corresponding mathematical notation. Note that these are not the equations that one would encounter in an algorithm paper. They detail all the computations that must take place in the algorithm down to the smallest detail in a step-by-step exposition of the arithmetic in the solver. We need this degree of detail to fully verify the new implementation against the reference implementation. A direct implementation from this derivation can be verified against the reference implementation, and any mismatch in the derivations can be corrected in the specification.

Steps involved in algorithmic decomposition for separation of concerns, including the roles apportioned to AI and human scientists

Figure 3. Steps involved in algorithmic decomposition for separation of concerns, including the roles apportioned to AI and human scientists.

Starting from this description it becomes possible to identify reusable patterns in the solver and encode them into a condensed vocabulary of symbolic representations specific to the solver. One needs to create tools to lower the symbolized representation into a concrete form in the target language for compilation, and this is where the availability of highly capable LLMs changes the cost-benefit equation. As mentioned earlier, the existing portability solutions were constrained by the limitation of resources in the form of human developers to even entertain the idea of specialized symbolization most suitable for a single solver or application. They had to necessarily design their solutions to be general across a variety of solvers. The LLMs have largely eliminated this trade-off to the point where tools for lowering abstractions to a compilable language can be generated and verified even by developers with no compiler expertise.

As with any concrete implementation of a numerical algorithm, there is no unique way to design the vocabulary and there is no binding to any specific language when equations are the starting point. We opted to use macros for symbolizing data references as with the first example described in § 4, but we extended their role and also turned them into computational helpers. These computational helpers are templates that encode the algorithmic sequence of the solver with insertion markers for imports and declarations in the enclosing specification section. Helper definitions have a name, formal arguments, declarations when needed, and an executable body. Each of the helper also implies a scope that effectively becomes a unique namespace for the translator. Figure 4 shows an example of a helper that assembles face states. Selected color coded symbols in the figure show how the symbols are placed in the maintained abstracted code, how they are defined, and what do they look like when translated. Note that the translated symbols look very similar to how the linkers resolve symbols. The translator essentially performs a similar function, although at a much more limited scale.

Invocation in code, definitions, and expansion of a computational helper

Figure 4. An Example of a computational helper. The top left box shows how it is invoked in the code, the bottom left box shows the definitions of the macros used and the right box shows the expanded code.

The expander hoists generated declarations to these markers, placing imports where appropriate in the generated code. Scratch storage is caller-owned and reusable across calls. Layout-specific allocation is performed by the caller through backend macros. Mesh services are not called directly: the whole-step (including all stages in a multi-stage method) driver receives a provider context and the procedures that are needed to perform these services.

Verification

We evaluate the abstracted code from two perspectives: verification – whether the arithmetic layer produces the same numerical results regardless of who owns the data and drives the time integration; and performance – whether the generated surrounding code can be tailored for a target platform to obtain good performance.

Verification of symbolic data-reference

To verify the abstractions where only the explicit data-references are symbolized we use only the Sedov problem. Because the abstractions are shallow, verification with any one problem suffices. We use two alternative sets of definitions of macros that change the order of indices in the state data layout. The first set of definitions assumes the data layout to be U(field_variable,i,j,k)U(field\_variable, i, j, k) where i,j,ki, j, k are space indices and field_variablefield\_variable represents physical variables (i.e. density, pressure etc). For the same set of indices the second set of definitions assumes the layout to be U(i,j,k,field_variable)U(i, j, k, field\_variable). We refer to these definitions as variable-first and variable-last from here on. Note that Flash-X already has a built-in capability to change the order of indices during configuration because it supports two mesh packages, Paramesh [18], which assumes variable-first order, and AMReX [32], which assumes variable-last order. For the purpose of verifying the symbolic data referencing we disabled the native reordering capability in Spark and used the LLM to replace all explicit array references in the solver with appropriate symbolic representations.

This set of verification runs used a Mac M5 laptop with Tahoe 26.5 operating system. The existing mechanism for selection of alternative implementation in Flash-X was used to generate three versions of the problem shown in the figure Figure 5. The first two versions have identical data layout. Their equivalence was verified by confirming that the assembly code produced by the compiler was identical for all the relevant files. The equivalence of the second and the third versions was verified by confirming that the produced results were bit-wise identical, and also through visualization of the results.

Three configurations for the Sedov blast problem

Figure 5. Sedov blast problem run with three different configurations: the reference, abstracted with layout identical to the reference, and abstracted with a different data layout

Verification for Arithmetic Extraction

This set of experiments probe the efficacy of separating the core arithmetic of the solver from the surrounding code. We refer to the version of the code with its core arithmetic extracted as NewImpl for convenience. The questions we ask are:

Q1 Does NewImpl reproduce the results of the reference implementation when it is inserted into Flash-X?

Q2 Does NewImpl produce the same results when its data are owned and its time loop is driven by an independently developed infrastructure instead of Flash-X?

Q3 How much code has to be written to attach an independent infrastructure, and does any of it touch the arithmetic layer?

Q4 Does the arithmetic layer give the same results on a GPU?

We compare five configurations described in Figure 6. They differ in who owns the cell data (and thus also the layout in memory), who drives the time step, and which hydrodynamics implementation performs the arithmetic. Here, the reference configuration, config 1, is the unmodified Spark solver running with Flash-X’s native UG. The second configuration, config 2, embeds the core arithmetic from NewImpl in Spark’s own driver through compatibility wrappers that we developed with LLM assistance. We run this configuration on Flash-X’s single UG block, like config 1.

Figure 6. Evaluated configurations. "Data owner" is the software that allocates and lays out the cell data; "time-step driver" is the code that sequences Runge–Kutta stages, guard-cell exchange, and flux synchronisation within a time step.

The third configuration, config 3, runs with core arithmetic of NewImpl with independent infrastructure. Here, we use a mesh developed as a C library with Fortran binding that divides a uniform Cartesian domain into equal blocks with halos, and whose memory layout, dimension, and halo width are compile-time macros. NewImpl’s whole-step driver advances the solution and UniformMesh supplies the data and the mesh services through a grid provider. The host program contains no Flash-X code. It reproduces Flash-X’s initial conditions, time-step control, and output formats from Flash-X’s sources, so that its results can be compared with config 1 and config 4 using Flash-X’s own tools.

In the fourth configuration, config 4, we embed the whole of NewImpl and the independently developed mesh as a sub-unit of Spark in Flash-X. Here, Flash-X initializes the problem and controls the time step; in each step its cell data are copied into UniformMesh, advanced by NewImpl, and copied back. The configuration allows NewImpl and Spark to be verified with bit-wise identical results. The final configuration, config 5, uses OpenMP target offload to enable running the code on the GPU. In this configuration, NewImpl’s core arithmetic is embedded into the single stage face-flux calculation routine of Spark. Unlike all previous configurations, here the single stage driver for face-flux calculation needs to be modified to allow batching of blocks for offloading. This is because in AMR mode an individual block is too small for efficient use of the GPU. Several blocks must be computed in parallel on the GPU for it to be viable in production. To verify this version, the same generated source is also built for host execution (OpenMP on the CPU, "host kernels"). The mesh is a single refinement level of 4 ×\times 4 blocks of 64264^{2} cells, so it has the same 2562256^{2} resolution as the other configurations, with the periodic boundaries and flux correction. We verify this configuration against the reference configuration using with the same compiler on the same mesh.

For all of these verification runs NewImpl and Spark are taken from the same commit of Flash-X; NewImpl’s sources are not modified in any configuration, which each build verifies by recording checksums of all NewImpl inputs. All codes that have CPU only target are compiled with GNU Fortran 14.3.1 and Flash-X’s flags (-O2, 8-byte reals) and run on a single core of an AMD EPYC 7302 node, one MPI rank. Config 5 and its Spark reference are compiled with NVHPC 26.3 (-O2 -r8, -mp=gpu -gpu=cc128) and run on an NVIDIA GeForce RTX5080 attached to an Intel Xeon Max 9468, with one MPI rank. Performance measurements on the GPU were conducted on a system with NVIDIA GB200 NVL4 with NVHPC 26.3 compiler suite.

Details of the runs

We use Sod shock tube and isentropic vortex problems for the CPU only runs. All variations of these problems run in two-dimensions with periodic boundaries on 256 × 256 cells. IsentropicVortex was setup on the physical domain sized at [0,10]2[0,10]^2, advected diagonally for one period (t=10t = 10), where the exact solution is the translated initial condition. The Sod setup used a physical domain of size [0,1]2[0,1]^2 with the interface normal to xx, run to t=0.025t = 0.025. With periodic boundaries a second, mirror-image Riemann problem forms at x=0x = 0, so the exact solution is the superposition of two exact Riemann solutions until the wave systems meet, and it is symmetric about x=0.25x = 0.25. A second variant (Sod-hybrid) switches to the HLLE solver in shock-flagged cells. Two further variants switch flattening off in both solvers (Sod-noflat, Sod-hybrid-noflat), to identify differences at shocks. For the order of accuracy, the vortex is also run on 64264^2, 1282128^2, and 5122512^2 cells with the remaining parameters left identical to the other runs. 1.84×10−51.84 \times10^{-5} / 4.0×10−44.0 \times10^{-4} Two vortex variants use a fixed Δt=5×10−3\Delta t = 5 \times10^{-3} after Flash-X’s start-up step (0.1 of the CFL limit). One runs a full period (vortex-fixed, 2001 steps), the other 100 steps (vortex-short).

We run config 3 and config 4 with several decompositions of the domain into blocks of at least 8×88 \times8 cells, from strips (4 × 1, 1 × 16) to 32 × 32 blocks. Each problem uses two to six of them and each run is compared to the single block run of the same problem. 20 comparisons per configuration, 16 of them on the five main problems. The time per step is measured on vortex-short (100 steps) and Sod (30 steps), five times each on an otherwise idle node; we report the minimum.

To determine which of the Flash-X behaviours reproduced by config 3 bit-wise identity depends on, configuration 3 is rerun with one of them replaced at a time and compared with configuration 4 on vortex-short, Sod, and the vortex: Flash-X’s equation of state by the grid provider’s simpler one, or without recomputing the internal energy; no start-up step; no limit on the growth of the time step; the last step shortened to the final time; and NewImpl’s own CFL formula instead of Spark’s. To exercise storage layouts NewImpl’s own example, a one-dimensional periodic Sod problem on its built-in grid provider, is built with each of NewImpl’s three storage mappings (variable-first, spatial-first, and per-cell records) and run with SSP-RK2 and SSP-RK3 on one and four blocks; the outputs are compared byte by byte.

Metrics

  • bit-wise identity of checkpoints, compared with Flash-X’s sfocu tool at tolerance zero, and of the time series of integral quantities (which include the simulation time and thus the time-step sequence).

  • Difference between two configurations: the maximum and L1L_1 norm of the cell-wise difference of all variables (from sfocu), and its ratio to the discretisation error.

  • Error against the exact solution: L1L_1 and L∞L_\infty norms of the density error, with the exact solution evaluated at each checkpoint’s own time.

  • Mirror symmetry of the Sod solution: max⁡x∣u(x)+u(x′)∣\max_x |u(x) + u(x')|, where x′x' is the mirror image of xx about x=0.25x = 0.25; it is zero for the exact solution.

  • Number of time steps and the time-step sequence.

  • Lines of code that attach the infrastructure, and lines of the arithmetic layer changed for it.

  • Conservation: the largest relative change of the total mass, momentum, and energy over a run.

Replaced behaviourvortex-shortSodvortex
Equation of state of the grid provider3.0×10−123.0 \times10^{-12}1.2×10−131.2 \times10^{-13}2.7×10−82.7 \times10^{-8}
No recomputation of the internal energy4.4×10−134.4 \times10^{-13}3.6×10−143.6 \times10^{-14}2.3×10−82.3 \times10^{-8}
No start-up step3.3×10−33.3 \times10^{-3}–7.4×10−47.4 \times10^{-4}
No limit on time-step growth–1.1×10−21.1 \times10^{-2}1.6×10−31.6 \times10^{-3}
Last step shortened to final time–1.0×10−11.0 \times10^{-1}3.8×10−33.8 \times10^{-3}
NewImpl’s CFL formula––2.8×10−82.8 \times10^{-8}

Table 3. Ablation of configuration 3: maximum difference to configuration 4 in the hydrodynamic variables when one reproduced Flash-X behaviour is replaced; – means bit-wise identical.

  • Time per step of the hydrodynamics: Flash-X’s Hydro timer for configurations 1 and 4 (for configuration 4 including the copies into and out of UniformMesh), and NewImpl’s whole-step driver for configuration 3; and the wall time of the whole run per step.

Verification Results

We begin by comparing the reference solver with core arithmetic of NewImpl (config 1 and config 4), summarized in Table 2. For smooth flow after 100 identical steps the two solvers differ by at most 1.9×10−121.9 \times10^{-12} in single cells, with an L1L_1 difference of 2.5×10−152.5 \times10^{-15}, which can be considered as rounding errors. Over a full period the maximum difference grows to 1.3×10−81.3 \times10^{-8} with a fixed time step and 2.5×10−82.5 \times10^{-8} with the CFL-limited timestep. That is 0.003% and 0.006% of the maximum error against the exact solution. Even with the CFL-limited timestep, both solvers choose identical time-step series and have the same error against the exact solution. For smooth flow NewImpl reproduces Spark, including its time-step control, to within rounding effects (Q1).

ProblemSteps∣NewImpl−Spark∣max⁡\lvert\mathrm{NewImpl}-\mathrm{Spark}\rvert_{\max}NewImpl errorSpark error
vortex-short1001.9×10−121.9 \times10^{-12}2.25×10−62.25 \times10^{-6} / 8.9×10−58.9 \times10^{-5}same
vortex-fixed20011.3×10−81.3 \times10^{-8}1.84×10−51.84 \times10^{-5} / 4.0×10−44.0 \times10^{-4}same
vortex (CFL)18772.5×10−82.5 \times10^{-8}1.84×10−51.84 \times10^{-5} / 4.0×10−44.0 \times10^{-4}same
Sod301.6×10−131.6 \times10^{-13}3.78×10−33.78 \times10^{-3} / 8.47×10−28.47 \times10^{-2}same
Sod-hybrid301.6×10−131.6 \times10^{-13}3.79×10−33.79 \times10^{-3} / 8.54×10−28.54 \times10^{-2}same

Table 2. NewImpl on UniformMesh in Flash-X (config 4) versus the original Spark solver (config 1); 256 ×\times 256 cells, one rank. Differences are maxima over all cells and variables; errors are density errors against the exact solution (L1L_1 / L∞L_\infty). vortex-short: L1L_1 difference 2.5×10−152.5 \times10^{-15}.

On the Sod problem, NewImpl reproduces Spark to rounding. The maximum difference is 1.6×10−131.6 \times10^{-13} (with and without the hybrid HLLE solver). Both solvers take the same 30 time steps, have the same error against the exact solution and preserve the mirror symmetry of the periodic problem to max⁡∣u(x)+u(x′)∣=10−13\max\lvert u(x)+u(x')\rvert= 10^{-13}. Shock detection, both Riemann solves, flattening, artificial viscosity and the update thus agree with Spark’s implementation.

Independent infrastructure (config 3 versus 4)

Configuration 3 runs NewImpl on UniformMesh without any Flash-X code. On the same machine and compiler, its results are bit-wise identical to those of configuration 4 for all ten problems: every checkpoint (11 for each vortex run over a full period, compared with sfo-c at tolerance zero), the time series of integral quantities including the simulation time, and therefore the entire time-step sequence. This answers Q2 – the result of the arithmetic does not depend on the host program. Mimicking Flash-X’s initialization, time-step control and output by an independent implementation produces bit-wise identical results.

Native environment (Config 2 vs config 1)

Inside Spark’s own driver, NewImpl’s kernels reproduce Spark to rounding on every problem. After a full vortex period with a fixed time step the maximum difference is 1.7×10−121.7 \times10^{-12}, on the Sod problems 3.0×10−133.0 \times10^{-13} (2.4×10−132.4 \times10^{-13} with the hybrid solver), with identical step counts. The only larger difference, 3.0×10−83.0 \times10^{-8} for the CFL-limited vortex, arises because of rounding form the first steps on, so the time steps computed from them differ in the last bits and this error grows to the same order as for configuration 4 (2.5×10−82.5 \times10^{-8}). With a fixed time step the difference stays at 1.7×10−121.7 \times10^{-12} The arithmetic layer thus behaves identically in its native environment and in the independently developed infrastructure.

Different architecture (Config 5 vs config 1)

Table 4 compares the GPU configuration with Spark built with the same compiler on the same mesh. On every problem both take the same number of steps. With a fixed time step they take the identical time-step sequence. On Sod the maximum difference is 3.4×10−133.4 \times10^{-13}. Mirror symmetry is preserved to 3×10−133 \times10^{-13}, the same level as Spark itself. After 100 vortex steps the difference is 5.2×10−125.2 \times10^{-12}. To separate the kernels from the hardware, the generated kernels were also run on the host. With contraction disabled, the GPU results are bit-wise identical to the host results on all five problems. The results are also independent of the batch size (1, 3 and 32).

ProblemStepsGPU − Sparkmax L1L_1contraction offGPU vs. host
vortex-short1005.2×10−125.2 \times10^{-12}4.0×10−154.0 \times10^{-15}3.8×10−123.8 \times10^{-12}bit-wise
vortex-fixed20011.4×10−71.4 \times10^{-7}2.3×10−92.3 \times10^{-9}1.9×10−71.9 \times10^{-7}bit-wise
vortex (CFL)1877a1877^{a}6.9×10−86.9 \times10^{-8}1.0×10−91.0 \times10^{-9}8.2×10−88.2 \times10^{-8}bit-wise
Sod30a30^{a}3.4×10−133.4 \times10^{-13}7.1×10−157.1 \times10^{-15}2.4×10−132.4 \times10^{-13}bit-wise
Sod-hybrid30a30^{a}2.3×10−132.3 \times10^{-13}5.8×10−155.8 \times10^{-15}9.3×10−149.3 \times10^{-14}bit-wise

Table 4. NewImpl on a GPU (configuration 5) versus the original Spark solver, both built with NVHPC 26.3 on the same Paramesh4 mesh (4×44 \times4 blocks of 64264^2 cells, one level); one rank. Differences are maxima over all cells and variables of the final checkpoint; L1L_1 is the mean cell-wise difference. “Contraction off”: both codes built without fused multiply-add contraction. Last column: the GPU run compared with the same generated kernels executed on the host, both without contraction.

Effort to attach the infrastructure

Table 5 lists the code written to attach UniformMesh to NewImpl (Q3). The arithmetic layer, 1102 lines of NewImpl templates, helper definitions, and the grid-provider contract, is used without any changes. Two files connect NewImpl to UniformMesh. The storage mapping (61 lines) defines the field type and the cell_ref and face_ref references as a pointer into UniformMesh’s buffer, so no cell data is copied. Scratch fields remain ordinary arrays. The grid provider (194 lines) implements the four services of the contract: guard-cell exchange through UniformMesh, flux synchronisation at block borders, the global reductions (identity for one rank), and the equation of state. Everything else in Table 5 belongs to a host program, not to the attachment (the Flash-X sub-unit of configuration 4 and the standalone program of configuration 3, most of which reproduces Flash-X’s initialisation, time-step control, and output formats). Running NewImpl on a GPU required 732 lines of new code (Table 5), none of which touches the arithmetic layer.

ComponentLinesUsed by
Storage mapping (layout definitions)613, 4
Grid provider (contract implementation)1943, 4
GPU kernel template and device layout definitions1405
GPU kernel generator2005
Batching adapter (packing, transfers, launches, flux publication)3925
Flash-X sub-unit and installer5884
Standalone host program (incl. checkpoint writer)17673
UniformMesh library (C, Fortran binding, layout macros)8843, 4
NewImpl arithmetic layer, lines changed0 of 11023, 4, 5

Table 5. Lines of code (including comments) per component. Only the first two rows are needed to attach UniformMesh to NewImpl; only the rows marked 5 are needed to run NewImpl on a GPU. The GPU kernels themselves (841 lines) are generated from the unchanged NewImpl templates and are not maintained.

Performance

We analyzed the performance of the code from two perspectives, that of overheads and portability. Table 6 lists the time per step. Expressing the arithmetic through application-defined abstractions has no measurable cost. Within Flash-X, NewImpl takes 0.127 s per step on the vortex where Spark takes 0.140 s. Configuration 3 takes 0.111 s. The difference to configuration 4 is not in NewImpl: configuration 4’s timer additionally covers copying the solution between Flash-X’s array and UniformMesh in every step, which the bridge configuration needs because both own a copy of the data, and Flash-X’s general equation-of-state interface, which gathers the cell data into separate vectors; configuration 3 evaluates the same equation of state in place. Outside the hydrodynamics, Flash-X adds 0.02–0.06 s per step for time-step control and output, the standalone host almost nothing. These are single-core measurements on one machine with different timer scopes.

Configurationvortex-short Hydrovortex-short wallSod HydroSod wall
1: Spark0.1400.1590.1400.198
4: NewImpl in Flash-X, 1 block0.1270.1460.1240.183
4: NewImpl in Flash-X, 4 × 4 / 4 × 10.1310.1500.1360.195
3: NewImpl standalone, 1 block0.1110.1140.1090.113
3: NewImpl standalone, 4 × 4 / 4 × 10.1170.1210.1120.117

Table 6. Time per step in seconds (minimum of five runs), 256×256256 \times256 cells, one core. “Hydro”: Flash-X’s Hydro timer configurations 1, 4) or NewImpl’s whole-step driver (configuration 3); “wall”: whole run per step.

On a GPU the surrounding code decides how much work each kernel launch gets. Figure 7 shows the time per step on Sedov for batch sizes 1 to 64. A batch costs 1.29 ms with 1 block and 1.48 ms with 64 (Figure 8), so each launch is dominated by launch overhead rather than computation. Grouping blocks therefore cuts the GPU time almost in proportion to the batch size. The time for the whole hydrodynamics step falls from 358 ms to 30ms (11.9×). At that point it is limited by host work that batching does not reduce. About 10 ms for guard-cell exchange and about 9 ms for packing, unpacking, the equation of state and fluxes. The arithmetic layer is the same for every batch size and gives bit-wise identical results. These measurements clearly show that the surrounding code can be adapted to an architecture’s execution model.

Figure 7. Hydrodynamics time per step on the GPU for Sedov (256 blocks of 16216^{2} cells, 100 steps) versus the number of blocks per GPU batch, split into GPU kernels and transfers, host-side adapter work, guard-cell exchange, and the rest.

Figure 8. (a) Speed-up over batch size 1 of the GPU kernels and transfers and of the whole hydrodynamics step. (b) GPU time per batch, almost independent of the number of blocks in it.

Related Work

This work lies at the boundary of performance-portability abstractions for HPC applications where code-generation approaches separate numerical intent from implementation, and AI-assisted transformation of existing software. Extant performance portability approaches have concerned themselves with providing abstractions for parallel execution, memory spaces, and data access while mapping these abstractions onto architecture-specific backends [29, 30, 31]. Directive-based approaches such as OpenMP [7] and OpenACC [15] target offloading allow architecture mappings to be expressed through annotations rather than by adopting a C++ abstraction library. The commonality among them is that the portability mechanism defines the abstractions available to the application.

LLMs have introduced a new mechanism for automating software transformations that previously required substantial manual effort. However, the reliability of such transformations remains a central concern [1, 19]. This is particularly important for scientific software, where apparently small changes to arithmetic expressions, array indexing, or update ordering can silently alter numerical results.

Our study shows that a constrained use of LLMs with a robust verification framework can be used to shift the abstraction boundary to the application. The application defines a small symbolic vocabulary corresponding to its own existing computational and data-access constraints. Infrastructure-specific code generation then gives those symbols their concrete representation. Consequently, an application’s numerical implementation need not adopt the types, containers, or access syntax of a particular portability framework. It also differs from conventional source-to-source porting. Rather than transforming an application directly from one infrastructure-specific representation to another, there is an intermediate, application-controlled representation into the maintained source. Once this transformation has been performed and validated, subsequent infrastructure changes alter the lowering of the abstractions rather than the arithmetic that expresses the numerical method.

Conclusion

We have introduced a new way of thinking about abstractions where instead of conforming to the a general portability system’s requirements, the applications devise their own customized portability framework. Until the arrival of highly capable LLMs and agentic frameworks this wasn’t feasible. Each transformation had to be manually constructed and validated. The other extreme of using LLM to produce all the code is still not feasible because of reliability concerns. The central proposition of this work is not that scientific software should be regenerated whenever computing technology changes. Rather, the availability of reliable code-generation assistance allows us to reconsider where the stable boundary in scientific software should lie. By maintaining the scientifically meaningful arithmetic as a durable artifact and making its connection to infrastructure explicit through application-defined abstractions, it is possible to preserve validated scientific computation while allowing the surrounding software mechanisms to evolve with substantially less disruption. The GPU configuration tests this proposition directly. Moving the arithmetic to a GPU, and making it efficient there by batching blocks required only new surrounding code. The arithmetic layer stayed the same and reproduced the CPU results to rounding; with contraction disabled, the GPU and host executions of the generated kernels were bit-wise identical.

We have exercised this proposition by introducing two levels of abstractions into an existing, scientifically validated implementation. One is a shallow abstraction that only affects array references leaving the remainder of the implementation unaltered, while the other is a fundamentally different way of implementing an algorithm from its detailed mathematical exposition. In the second approach the role of the reference implementation is limited. It is used to extract the detailed mathematical specification of the algorithm and as a baseline for verifying the generated code. Our ultimate objective is to use LLM assistance to go from the detailed mathematical description of the algorithm to generated executable code. Here we use extraction of mathematical notation from a mature solver because having a reference implementation allows us to validate the methodology. It is also worth noting that with this approach the degree of intrusiveness of the abstractions remains firmly in control of the application developer.

References

References

  1. [1]2026. Using LLMs to Enhance Code Quality: A Systematic Literature Review. Information and Software Technology 190 (2026), 107960. doi:10.1016/j. infsof.2025.107960
  2. [2]Michael Bauer, Sean Treichler, Elliott Slaughter, and Alex Aiken. 2012. Legion: Expressing locality and independence with logical regions. In SC’12: Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis. IEEE, 1–11.
  3. [3]Mauro Bianco, Lucas Benedict, et al. 2020. GridTools. https://github.com/GridTools/gridtoolsDOI
  4. [4]R. Borges, M. Carmona, B. Costa, and W. S. Don. 2008. An improved weighted essentially non-oscillatory scheme for hyperbolic conservation laws. J. Comput. Phys. 227 (March 2008), 3191–3211.
  5. [5]Valentin Clement, Sylvaine Ferrachat, Oliver Fuhrer, Xavier Lapillonne, Carlos E Osuna, Robert Pincus, Jon Rood, and William Sawyer. 2018. The CLAW DSL: Abstractions for performance portable weather and climate models. In Proceedings of PASC. 1–10.
  6. [6]Sean M Couch, Jared Carlson, Michael Pajkos, Brian W O’Shea, Anshu Dubey, and Tom Klosterman. 2021. Towards performance portability in the Spark astrophysical magnetohydrodynamics solver in the Flash-X simulation framework. Parallel Comput. 108 (2021), 102830.DOI
  7. [7]Leonardo Dagum and Ramesh Menon. 1998. OpenMP: An Industry-Standard API for Shared-Memory Programming. IEEE Comput. Sci. Eng. 5, 1 (jan 1998), 46–55. doi:10.1109/99.660313DOI
  8. [8]Zhe Dai, Jieng Dong, YongGong Cheng, Ming Li, Jian Zhang, and Yueqing Wang. 2024. Evaluating Performance Portability of Five Shared-Memory Programming Models Using a High-Order Unstructured CFD Solver. J. Parallel and Distrib. Comput. 187 (2024), 104831. doi:10.1016/j.jpdc.2023.104831
  9. [9]Anshu Dubey, Youngjun Lee, Tom Klosterman, and Emil Vatai. 2025. A tool and a methodology to use macros for abstracting variations in code for different computational demands. Future Generation Computer Systems 173 (2025), 106937. doi:10.1016/j.future.2023.07.014
  10. [10]Anshu Dubey, Klaus Weide, Jared O’Neal, Akash Dhruv, Sean Couch, J. Austin Harris, Tom Klosterman, Rajeev Jain, Johann Rudi, Bronson Messer, Michael Pajkos, Jared Carlson, Ran Chu, Mohamed Wahib, Saurabh Chawdhary, Paul M. Ricker, Dongwook Lee, Katie Antypas, Katherine M. Riley, Christopher Daley, Murali Ganapathy, Francis X. Timmes, Dean M. Townsley, Marcos Vannella, John Bachan, Paul M. Rich, Shravan Kumar, Eirik Endeve, W. Raphael Hix, Anthony Mezzacappa, and Thomas Papatheodore. 2022. Flash-X: A Multiphysics Simulation Software Instrument. SoftwareX 19 (2022), 101168. doi:10.1016/j.softx.2022.101168DOI
  11. [11]H. Carter Edwards, Christian R. Trott, and Daniel Sunderland. 2014. Kokkos: Enabling Manycore Performance Portability through Polymorphic Memory Access Patterns. J. Parallel and Distrib. Comput. 74, 12 (2014), 3202–3216. doi:10.1016/j.jpdc.2014.07.003DOI
  12. [12]Angela Fan, Beliz Gunel, Zachary M. Hartman, Mittya Lyubarsky, Shubho Sengupta, Shin Yoo, and Jie M. Zhang. 2023. Large Language Models for Software Engineering: Survey and Open Problems. In 2023 IEEE/ACM International Conference on Software Engineering: Future of Software Engineering (ICSE-FoSE). 31–53.arxiv.org/abs/2310.03533
  13. [13]Sigal Gottlieb, David I. Ketcheson, and Chi-Wang Shu. 2009. High Order Strong Stability Preserving Time Discretizations. Journal of Scientific Computing 38, 3 (Mar 2009), 251–289.DOI
  14. [14]Tobias Gysi, Carlos Osuna, Oliver Fuhrer, Mauro Bianco, and Thomas C. Schulthess. 2015. STELLA: A domain-specific tool for structured grid methods in weather and climate models. In SC ’15: Proceedings of the international conference for high performance computing, networking, storage and analysis. 1–12. doi:10.1145/2807591.2807627DOI
  15. [15]J. A. Herdman, W. P. Gaudin, O. Perks, D. A. Beckingsale, A. C. Mallinson, and S. A. Jarvis. 2014. Achieving Portability and Performance through OpenACC. In 2014 First Workshop on Accelerator Programming using Directives. 19–26. doi:10.1109/WACPD.2014.10DOI
  16. [16]Xinyi Hou, Yanjie Zhao, Yue Liu, Zhou Yang, et al. 2024. Large Language Models for Software Engineering: A Systematic Literature Review. ACM Transactions on Software Engineering and Methodology 33, 8, Article 220 (2024), 79 pages. doi:10.1145/3695988DOI
  17. [17]Juyong Jiang, Fan Wang, Jiasi Shen, Sungju Kim, and Sunghun Kim. 2026. A Survey on Large Language Models for Code Generation. ACM Transactions on Software Engineering and Methodology 35, 2 (2026), 1–72. doi:10.1145/3747588DOI
  18. [18]Peter MacNeice, Kevin M Olson, Clark Mobarry, Rosalinda De Fainchtein, and Charles Packer. 2000. PARAMESH: A parallel adaptive mesh refinement community toolkit. Computer physics communications 126, 3 (2000), 330–354.DOI
  19. [19]Sofia Martinez, Luo Xu, Mariam Elnaggar, and Eman Abdullah Alomar. 2025. Software Refactoring Research with Large Language Models: A Systematic Literature Review. Journal of Systems and Software (2025). doi:10.1016/j.jss.2025.112762DOI
  20. [20]T. Miyoshi and K. Kusano. 2005. A multi-state HLL approximate Riemann solver for ideal magnetohydrodynamics. J. Comput. Phys. 208 (Sept. 2005), 315–344.DOI
  21. [21]Jonathan Ragan-Kelley, Connelly Barnes, Andrew Adams, Sylvain Paris, Frédo Durand, and Saman Amarasinghe. 2013. Halide: a language and compiler for optimizing parallelism, locality, and recomputation in image processing pipelines. ACM SIGPLAN Notices 48, 6 (2013), 519–530.
  22. [22]Xuanzhengbo Ren, Tetsuya Hoshino, Daichi Mukunoki, and Takahiro Katagiri. 2026. Porting NICAM Microphysics to Kokkos: A Case Study in Performance Portability for Atmospheric Models. Journal of Information Processing 34 (2026), 503–513. doi:10.2197/ipsjjip.34.503DOI
  23. [23]Leonid Ivanovich Sedov. 1993. Similarity and Dimensional Methods in Mechanics (10 ed.). CRC Press. 496 pages. doi:10.1201/9780203739730
  24. [24]Chi-Wang Shu. 1997. Essentially Non-Oscillatory and Weighted Essentially Non-Oscillatory Schemes for Hyperbolic Conservation Laws. Technical Report ICASE Report 97-65. Institute for Computer Applications in Science and Engineering, NASA Langley Research Center, Hampton, Virginia. NASA/CR-97-206253.DOI
  25. [25]C.-W. Shu. 2009. High Order Weighted Essentially Nonnoscillatory Schemes for Convection Dominated Problems. SIAM Rev. 51 (Jan. 2009), 82–126.DOI
  26. [26]C.-W. Shu and S. Osher. 1988. Efficient Implementation of Essentially Non-oscillatory Shock-Capturing Schemes. J. Comput. Phys. 77 (Aug. 1988), 439–471.DOI
  27. [27]Stephen F Siegel, Manchun Zheng, Ziqing Luo, Timothy K Zirkel, Andre V Marianello, John G Edenhofner, Matthew B Dwyer, and Michael S Rogers. 2015. CVLC: the concurrency intermediate verification language. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis. Association for Computing Machinery, New York, NY, USA, 1–12. doi:10.1145/2807591.2807635DOI
  28. [28]Gary A. Sod. 1978. A Survey of Several Finite Difference Methods for Systems of Nonlinear Hyperbolic Conservation Laws. J. Comput. Phys. 27, 1 (1978), 1–31. doi:10.1016/0021-9991(78)90023-2DOI
  29. [29]Jan Stephan, Sergei Bastrakov, Andrea Di Pilato, Sebastian Ehrig, Benjamin M. Gruber, Jan Vyskočil, René Widera, and Michael Bussmann. 2026. Performance Portability with Alpaka. Journal of Physics: Conference Series 3206, 1 (2026), 012054. doi:10.1088/1742-6596/3206/1/012054DOI
  30. [30]Christian R. Trott, Luc Berger-Vergiat, David Poliakoff, Sivasankaran Rajamanickam, Damien Lebrun-Grandie, Jonathan Madsen, Nader Al Awar, Milos Gligoric, Galen Shipman, and Geoff Womeldorff. 2021. The Kokkos Ecosystem: Comprehensive Performance Portability for High Performance Computing. Computing in Science & Engineering 23, 5 (2021), 10–18. doi:10.1109/MCSE.2021.3098509DOI
  31. [31]Erik Zenker, Benjamin Worpitz, René Widera, Axel Huebl, Guido Juckeland, Andreas Knüpfer, Wolfgang E. Nagel, and Michael Bussmann. 2016. Alpaka – An Abstraction Library for Parallel Kernel Acceleration. In 2016 IEEE International Parallel and Distributed Processing Symposium Workshops.
  32. [32]Weiqun Zhang, Ann Almgren, Vince Beckner, John Bell, Johannes Blaschke, Cy Chan, Marcus Day, Brian Friesen, Kevin Gott, Daniel Graves, Max Katz, Andrew Myers, Tan Nguyen, Andrew Nonaka, Michele Rosso, Samuel Williams, and Michael Zingale. 2019. AMReX: a framework for block-structured adaptive mesh refinement. Journal of Open Source Software 4, 37 (May 2019), 1370. doi:10.21105/joss.01370DOI

Paper details

vlnc:W_raxb87k9
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

LLM assistance

View statement
Looking for related papers…
Contents