At a Glance
| Code / tool | GPU-parallel Method of Moving Asymptotes (MMA); MMApdip and MMAdip variants |
| Technical area | GPU-resident optimisation; parallel scalability; topology optimisation |
| Challenge | Avoiding CPU-side design-update communication overhead and maintaining optimiser performance as the number of design variables grows |
| CEEC contribution | Developed and benchmarked a fully GPU-parallel MMA implementation |
| Key achievement | Optimiser contribution below 1% of runtime in reported large-scale benchmark cases; approximately 80% parallel efficiency from 32 to 256 GPUs in a separate benchmark |
| Impact | More efficient design updates and support for topology optimisation at very large problem sizes |
The Challenge
Topology optimisation improves a design by repeatedly adjusting how material is distributed within a given space to achieve a desired objective. Unlike conventional parametric optimisation, which adjusts a limited number of geometric dimensions, topology optimisation can involve millions of design variables describing where fluid or solid material should be placed.
The Method of Moving Asymptotes (MMA) is an optimisation algorithm used to update these design variables. When the flow simulation runs on GPUs but the MMA optimiser runs on the CPU, transferring data between the two processor types can introduce additional communication overhead. As the number of design variables grows, the CPU-based optimisation step can also become a significant computational bottleneck.
Because topology optimisation may require hundreds of iterations, even a modest overhead in each update can add up. An efficient GPU-based simulation workflow therefore also needs an optimiser that can exploit GPU parallelism and efficiently update large numbers of design variables.
The CEEC Solution
CEEC developed a fully GPU-parallel implementation of MMA, keeping the design-update computation on the GPU rather than relying on a CPU-based optimiser. The implementation was then evaluated in two ways: within topology-optimisation workflows and in dedicated optimiser benchmarks. The complete workflows tested the optimiser as part of a larger computational process, while the separate benchmarks isolated its runtime and parallel-scaling behaviour.
The team also compared GPU-based implementations with a CPU-based MMA implementation and assessed how the optimiser’s contribution changed as the number of design variables increased. Moreover, the performance and scalability of two GPU implementations, MMApdip and MMAdip, were investigated as more GPUs were added. These two implementations differ in how they solve the underlying approximated optimisation subproblem. MMAdip uses a reduced dual formulation, which can result in lower computational costs, particularly for problems with relatively few constraints. MMApdip, on the other hand, can be advantageous for problems involving a larger number of constraints.
In addition to the static-mixer application, the team conducted two dedicated benchmarks to evaluate the GPU-based optimisers. The first isolated the computational performance of the optimiser from the other components of the simulation workflow. The second evaluated the scalability of the implementations in a topology-optimisation problem involving an extremely large number of design variables.
Results
The test case results show that the GPU-based implementations kept the optimiser’s contribution to runtime low for the problem sizes tested. In a benchmark test spanning design spaces from approximately 216 million to 1.73 billion design variables, the CPU-based optimiser’s contribution to overall runtime increased from around 2% to 8% of the computation. By comparison, the MMAdip GPU implementation kept the design-update step below 1% of total runtime across the reported cases.
The team also assessed the parallel efficiency of the two GPU-based implementations in a dedicated optimiser benchmark with approximately 197 million design variables. As the GPU count increased eightfold, from 32 to 256 GPUs, both tested GPU variants maintained around 80% parallel efficiency. For this particular benchmark, which involved relatively few constraints, MMAdip was approximately 2.3 times faster than MMApdip.
Together, these results provide evidence that the GPU-based optimisers can keep their runtime contribution low even at large problem sizes and make efficient use of additional GPUs. The two variants also offer complementary advantages: MMAdip is more efficient for problems with relatively few constraints, while MMApdip can perform better when the number of constraints is larger.


Impact on the Code
The GPU-based MMA implementation reduces the computational overhead associated with updating large sets of design variables and helps prevent the optimiser from becoming a bottleneck as problem size increases. This is particularly relevant to workflows that combine GPU-accelerated simulations with repeated optimisation steps. Keeping the optimiser on the GPU reduces the need to transfer optimisation data between CPU and GPU for the design update and allows the algorithm to use GPU parallelism directly.
The implementation complements CEEC’s work on in-situ compression of flow history. Compression addresses the cost of managing the time-dependent data required by adjoint simulations, while the GPU-based MMA implementation addresses the design-update stage. Together, they target separate sources of overhead in the broader topology-optimisation workflow.
The measured results demonstrate the performance of the GPU-based optimisers for the tested configurations. They do not imply that an entire simulation-and-optimisation run becomes 2.3 times faster, merely that when comparing the two optimiser variants in the dedicated benchmark, MMAdip is that much faster for optimisation problems with just a few constraints.
Contribution to the State of the Art
CEEC’s key advance is the implementation and evaluation of a GPU-parallel MMA optimiser that keeps the design-update step computationally inexpensive while scaling across multiple GPUs. This advances the scalability of topology optimisation by keeping the design-update step below 1% of runtime in the reported benchmark cases with the implemented GPU-based MMA optimiser. This optimiser further maintained around 80% parallel efficiency as the GPU count increased from 32 to 256 in a separate benchmark test.
The results support the use of GPU-based optimisation for large design spaces. They also show why performance should be evaluated at both the component and the workflow level: the optimiser is one part of a larger process whose overall scalability also depends on simulation cost, sensitivity analysis, and data management.

Comments
One response to “A GPU-Parallel MMA Algorithm for Topology Optimisation”
[…] Second, CEEC developed a GPU-parallel implementation of the Method of Moving Asymptotes (MMA), the algorithm used to update the design at each iteration. Keeping the design update on the GPU reduced CPU–GPU data transfers and helped prevent the optimiser from becoming a bottleneck as the number of design variables increased. In the reported benchmark cases, the design-update step accounted for less than 1% of total runtime. Separate benchmarks demonstrated scalability to very large numbers of design variables, as described in more detail in the success story “A GPU-Parallel MMA Algorithm for Topology Optimisation”. […]