betaFeedback

WorksComputer Science

AscendMOEA: An Ascend NPU-Accelerated Platform for Tensorized Multi-Objective Evolutionary Algorithms

Abstract

Multi-objective evolutionary optimization increasingly involves large populations, expensive problem evaluations, and diverse algorithmic structures. These workloads expose the limited parallelism of loop-based implementations, while rewrites for accelerator execution can alter selection order, tie handling, and population updates. AscendMOEA is presented as a scalable platform that executes multi-objective evolutionary algorithms (MOEAs) on Huawei Ascend neural processing units (NPUs) and conventional central processing units (CPUs). The platform represents the decision vectors, objectives, constraints, and auxiliary states as tensors and provides reusable interfaces for algorithms, problems, population operators, quality indicators, monitoring, and repeated experiments. Dense computations are executed in batches, such as dominance, distance, variation, and problem-evaluation calculations. Short recurrences with causal dependencies retain their prescribed order and consume precomputed tensor results, which preserves the behavior of the original algorithms. AscendMOEA contains 18 algorithms, 155 benchmark and application problems, 19 public operator interfaces, and 11 quality indicators. Experiments on eight Ascend NPUs and 192 physical CPU cores evaluate operator throughput, end-to-end runtime, memory consumption, numerical agreement, and implementation ablation. Tensorized operators obtain a median acceleration of 1.58 times on the NPU. At large population scales, complete algorithms achieve a median acceleration of 5.76 times while retaining the recorded quality indicators. Moreover, the results identify the workload scale and ordered computation that determine whether accelerator execution is beneficial. AscendMOEA is open-sourced at https://github.com/dqlme/AscendMOEA.

Introduction

Multi-objective optimization problems (MOPs) require a set of solutions that describes different compromises among conflicting objectives. Multi-objective evolutionary algorithms (MOEAs) provide a natural population-based approach for solving MOPs, which can approximate multiple regions of the Pareto front (PF) in one run [1]. This capability supports engineering design, resource allocation, scheduling, and data-driven applications. Recent studies address constrained multi-objective optimization problems (CMOPs), multimodal multi-objective optimization problems (MMOPs), sparse MOPs, and large-scale MOPs. These problem classes place different requirements on population representation and environmental selection. For example, MMOPs require multiple Pareto optimal sets in the decision space, and solving sparse MOPs needs to determine variable activation together with objective quality.

The expansion of algorithmic scope makes software infrastructure a substantive part of MOEA research. A reusable platform should coordinate algorithms, problems, operators, indicators, experiments, and visualization without embedding problem-specific assumptions into the execution process. Benchmarking repositories emphasize common instances and comparable settings. jMetal [2], ParadisEO-MOEO [3], and PlatEMO [4] establish broad component libraries in Java, C++, and MATLAB, respectively. Moreover, Python platforms provide direct access to scientific-computing tools. pymoo [5] separates sampling, selection, variation, termination, and decision support into independent modules. jMetalPy [6] and pagmo [7] support parallel evaluation and heterogeneous solvers. These systems substantially improve implementation reuse. Nevertheless, population operators are still commonly expressed through individual-level loops or serial comparisons, and this limitation becomes prominent when objective evaluations are inexpensive.

Modern accelerators provide extensive parallel arithmetic, but an MOEA does not become accelerator efficient by moving an unchanged loop to another device. For example, pairwise dominance and distance calculations have abundant parallelism. In contrast, frequent scalar branches, small kernel launches, and device synchronization may consume more time than the associated arithmetic. The problem becomes more difficult when an update carries an intragenerational dependency. In MOEA/D [8], a solution accepted for one subproblem can influence later subproblems in the same generation. Additionally, each deletion in distance-based truncation changes the surviving set considered by the next deletion in SPEA2 [9]. Simultaneously executing these decisions modifies the algorithm, even if the resulting code is faster.

Evolutionary systems for GPU execution address parts of this challenge. EvoJAX [10] batches neuroevolution workloads, and EvoX [11] provides a functional programming model with distributed GPU execution. EvoMO [12] formulates representative MOEAs as tensor programs and demonstrates substantial acceleration at large scales. Its experimental discussion reports that batched niche selection and simultaneous MOEA/D updates can lead to trajectories that differ from the original algorithms. Consequently, acceleration and algorithmic equivalence need to be examined together. Similar terminal means alone cannot determine whether ranking, random events, function-evaluation counts, and ordered writes remain unchanged.

Another practical gap concerns accelerator diversity. Most current evolutionary libraries target central processing units (CPUs), NVIDIA graphics processing units (GPUs), or generic distributed clusters. Huawei Ascend NPUs employ the compute architecture for neural networks (CANN) [13] and the Da Vinci AI Core [14]. Their matrix, vector, scalar, and data-movement units provide substantial throughput, while launch overhead, synchronization, operator coverage, and precision support differ from conventional GPU environments. Therefore, an MOEA platform for Ascend NPUs requires an explicit device policy rather than a direct replacement of the device string.

This study presents AscendMOEA, which is a tensorized and extensible platform for multi-objective evolutionary optimization on Ascend NPUs and conventional CPUs. The platform connects a batched problem interface with reusable population operators and tensor calculations defined for individual algorithms. Every run specifies its device, precision, random state, timing interval, monitor, and termination behavior. When an NPU is selected, all floating-point calculations adopt 32-bit floating-point precision (float32). Dense relations and population evaluations remain on the NPU. Short recurrences with causal dependencies operate on compact precomputed data and return only the resulting indices or masks. This organization reduces repeated synchronization and retains the update order of the original algorithms. Specifically, the main contributions of this study are summarized as follows:

  1. An extensible software architecture is established for multi-objective evolutionary optimization on Ascend NPUs. A common population object connects 18 MOEAs and 155 benchmark or application problems with 19 public operator interfaces and 11 quality indicators. Typed interfaces and registries allow newly developed algorithms and problems to follow the same execution, monitoring, and experiment procedure as the built-in components.

  1. A tensorization method is developed without changing the behavior prescribed by each algorithm. The method converts pairwise comparisons, reductions, selection, variation, and batched problem evaluation into tensor calculations. Validation requires exact agreement for selected indices, front numbers, masks, tie decisions, and function-evaluation counts. Numerical tolerances apply only to continuous values and are fixed according to the data type before the results are examined.

  1. An execution strategy for Ascend NPUs coordinates dense tensor calculations with short recurrences that have causal dependencies. The NPU constructs expensive relations, and each ordered recurrence consumes only the compact tensors needed for its next decision. One workflow manages device initialization, precision, synchronization, random states, population histories, memory measurements, and terminal outcomes.

  1. A matched evaluation protocol distinguishes the effects of common population operators, calculations inside each algorithm, and NPU execution. The experiments measure synchronized runtime and memory together with terminal indicators, convergence histories, and capacity outcomes. They cover unconstrained MOPs, CMOPs, MMOPs, sparse MOPs, large-scale MOPs, real-world MOPs, and combinatorial MOPs. The results identify the calculations that benefit from the NPU and the workloads that remain limited by sequential decisions.

The remainder of this article is organized as follows. Section II reviews software platforms and tensor execution for evolutionary computation. Section III describes the design and implementation of AscendMOEA. Section IV presents the experimental design, analyzes the results, and discusses their practical implications and limitations. Finally, Section V summarizes the findings and outlines future research.

Software Platforms for Multi-Objective Optimization

The design of an optimization platform determines which parts of an experiment can be reused and compared. jMetal [2] represents algorithms, problems, operators, and quality indicators through object-oriented abstractions. ParadisEO-MOEO [3] constructs fine-grained components for fitness assignment, diversity preservation, and elitism. PlatEMO [4] integrates a broad collection of MOEAs, benchmark problems, indicators, and visual experiments within a unified MATLAB environment. Its algorithm and problem classes provide an influential interface for multi-objective evolutionary research. These platforms illustrate that a stable separation between algorithm logic and problem evaluation improves both research reuse and practitioner access.

Python software follows several complementary directions. pymoo [5] provides a modular hierarchy for multi-objective optimization and decision support. jMetalPy [6] brings the jMetal design to Python and supports distributed evaluation. DEAP [15] supplies lightweight evolutionary types and operators, while pagmo [7] organizes heterogeneous optimization algorithms through an island model. PyPop7 [16] focuses on population-based black-box optimization under a unified application programming interface. Most of these systems parallelize independent evaluations or complete runs. Fine-grained population relations remain a separate computational concern.

Reproducible experiments require stable configurations, run records, and statistical analysis. SimOpt [17] separates simulation models, optimization problems, and repeated experiments. PyPRS [18] supports parallel ranking-and-selection procedures and preserves the information required to compare repeated runs. These capabilities complement component reuse because performance claims for an accelerator depend on matched workloads and synchronized measurements.

Tensor Execution for Evolutionary Computation

Parallel MOEAs are commonly organized through master–slave evaluation, islands, fine-grained populations, or hybrid structures [19]. Parallel evaluation is effective when the objective function dominates runtime. When objectives are inexpensive, non-dominated sorting, distance construction, and environmental selection can retain a quadratic serial component. Aguilar-Rivera [20] develops a vectorized implementation of NSGA-II [21] with stochastic sorting and grid-based crowding. This study demonstrates that population relations contain exploitable parallelism, although modifications to ranking and diversity rules can change the search behavior.

GPU studies extend parallelism beyond objective evaluation. Moreno et al. [22] compare the execution time and energy consumption of non-dominated sorting on GPUs and CPUs, and show that the benefit depends on the population structure and problem scale. Together with the vectorized NSGA-II study, this evidence motivates measurements of individual population operators instead of conclusions based only on the requested device.

Tensor libraries provide a concise representation of batched population calculations. EvoJAX [10] applies JAX to hardware-accelerated neuroevolution. EvoX [11] extends this direction through functional states, workflow analysis, and distributed execution with JAX or Ray. EvoMO [12] develops a general tensorization methodology and applies it to NSGA-III, MOEA/D, and HypE. Its results show that large populations can make accelerator execution highly effective. However, its tensorized MOEA/D evaluates subproblem updates as independent batches, and its tensorized NSGA-III employs batched random operations to approximate sequential niche selection. The resulting indicator values remain comparable in many experiments, but the computational process is no longer identical to the original implementation. AscendMOEA addresses a different objective. It retains the original update semantics and tensorizes the calculations that can be exchanged without changing the state transition.

PyTorch [23] provides the tensor interface of AscendMOEA, while TorchNPU [24] maps supported operations to Ascend devices through CANN [13]. NumPy [25] and SciPy [26] support host-side data preparation and reference assets. Numba [27] compiles short deterministic recurrences that have limited tensor parallelism. The Da Vinci AI Core combines matrix, vector, scalar, and data-movement units, and its effective throughput depends on arithmetic intensity and memory traffic [14]. The law formulated by Amdahl [28] limits complete-run acceleration when ordered computation remains substantial. The Roofline model [29] further explains why low-intensity kernels can remain bounded by launch or memory costs. Accordingly, AscendMOEA evaluates the complete synchronized workflow rather than reporting kernel throughput alone.

Design and Implementation

Optimization Model and Platform Structure

The architecture of AscendMOEA follows four objectives. Firstly, a problem should evaluate an entire population without knowing which algorithm requests the evaluation. Secondly, an algorithm should compose common operators without managing device initialization or measurement. Thirdly, the device policy should remain visible so that CPU and NPU experiments have an explicit precision and synchronization scope. Finally, a custom component should enter the same registry, workflow, monitoring, and experiment process as a built-in component. These objectives prevent accelerator details from being scattered throughout algorithm implementations.

A minimization MOP is formulated as follows:

min⁡x∈Ωf(x)=(f1(x),…,fM(x)),s.t.gk(x)≤0,k=1,…,K,(1)\begin{aligned} \min_{\boldsymbol{x} \in\Omega}\quad&\boldsymbol{f}(\boldsymbol{x}) = (f_1(\boldsymbol{x}), \ldots, f_M(\boldsymbol{x})),\\ \text{s.t.}\quad&g_k(\boldsymbol{x}) \le0,\qquad k=1,\ldots,K, \tag*{(1)} \end{aligned}

where x∈RD\boldsymbol{x} \in\mathbb{R}^{D} is a decision vector, DD is the number of decision variables, MM is the number of objectives, and KK is the number of inequality constraints. The feasible decision region is denoted by Ω\Omega. Constraint handling employs the total violation, which can be expressed as follows:

v(x)=∑k=1Kmax⁡{gk(x),0}.(2)v(\boldsymbol{x}) = \sum_{k=1}^{K} \max\{g_k(\boldsymbol{x}),0\}. \tag*{(2)}

A feasible solution is preferred to an infeasible solution, and two infeasible solutions are compared by vv. For two feasible solutions xa\boldsymbol{x}_a and xb\boldsymbol{x}_b, xa\boldsymbol{x}_a Pareto dominates xb\boldsymbol{x}_b when it is no worse in every objective and strictly better in at least one objective. A feasible solution that is not dominated by another feasible solution belongs to the Pareto optimal set, and its objective vector belongs to the PF.

For a population of size NN, AscendMOEA stores the core state as follows:

P=(X,F,C),\mathcal{P} = (X,F,C),
X∈RN×D,F∈RN×M,C∈RN×K.(3)X \in\mathbb{R}^{N \times D},\qquad F \in\mathbb{R}^{N \times M},\qquad C \in\mathbb{R}^{N \times K}. \tag*{(3)}

The rows of XX contain decision vectors, and the corresponding rows of FF and CC contain objective and constraint values. Every tensor shares the same first dimension. This invariant allows a population to be selected, merged, cloned, detached, or transferred between devices through one object. Figure 1 presents the layered architecture of AscendMOEA. The runtime layer configures Python, PyTorch [23], NumPy [25], SciPy [26], Numba [27], CANN [13], the Ascend adapter [24], and Kunpeng CPU execution. The operator layer exposes ranking, fitness, selection, sampling, variation, population, distance, truncation, and indicator calculations. The algorithm layer combines these operators with state transitions defined by each MOEA. The upper layer contains numerical test suites, engineering applications, combinatorial instances, and extension interfaces. A single population representation connects the layers, which reduces conversion and avoids separate CPU and NPU implementations of the same MOEA.

Figure 1. Layered architecture and component portfolio of AscendMOEA.

The Problem class defines bounds, encodings, initialization, repair, objective evaluation, constraint evaluation, and reference data. Its public evaluator accepts a decision tensor with shape (N,D)(N,D). A numerical problem returns objective and constraint tensors as follows:

(F,C)=E(X),E:RN×D→RN×M×RN×K.(4)(F,C) = \mathcal{E}(X),\qquad\mathcal{E}:\mathbb{R}^{N \times D}\rightarrow\mathbb{R}^{N \times M}\times\mathbb{R}^{N \times K}. \tag*{(4)}

Real, integer, label, binary, and permutation encodings share this entry point. The generic evaluator enforces bounds and basic encoding validity before a problem-specific repair is applied. Objective and constraint values are then packed into a new population, and the number of function evaluations is updated by the batch size.

SystemPrimary scopeSoftware organizationParallel or accelerator supportReported validation
PlatEMO [4]Evolutionary multi-objective optimizationAlgorithms, problems, indicators, experiments, and visualization in MATLABParallel evaluation through the MATLAB ecosystemAlgorithm behavior and benchmark experiments
pymoo [5]Multi-objective optimization in PythonModular sampling, selection, variation, termination, and decision supportParallel problem evaluation and vectorized numerical componentsOptimization quality and software examples
EvoX [11]General scalable evolutionary computationFunctional states, workflows, analyzers, and execution enginesDistributed GPU execution through JAX and RaySystem scalability and model performance
EvoMO [12]Tensorized evolutionary multi-objective optimizationTensor formulations of representative algorithmsLarge-population GPU executionRuntime and indicator-level comparison
AscendMOEABroad multi-objective evolutionary optimizationAlgorithms, problems, operators, indicators, monitors, and typed registriesAscend NPU and CPU execution with ordered host controlOperator equivalence, generation state, terminal indicators, runtime, and memory

Table I. Representative software for multi-objective optimization and accelerator execution. The final column summarizes the validation emphasized in the corresponding publication.

The Algorithm class retains the evolutionary while loop. Its termination method records the current population, invokes callbacks, and checks the function-evaluation budget. This arrangement preserves the control defined by each MOEA without duplicating lifecycle logic. The Workflow binds one MOEA and one MOP to a RunConfig. This configuration contains the device, random seed, CPU thread count, and synchronization policy used for timing. A HistoryMonitor can store every complete generation on the host, which prevents population histories from occupying accelerator memory. Additional monitors can process progress, diagnostics, or errors through the same lifecycle callbacks.

Typed component registries provide stable public names for algorithms and problems. A registry accepts a class directly or through a decorator, validates the component type, and creates instances from keyword arguments. The same mechanism supports third-party extensions. Consequently, a custom problem can be combined with any compatible algorithm, and a custom algorithm can directly import population operators. Both extensions inherit the standard seed, precision, monitoring, timing, and termination behavior.

Tensorized Population Calculations

Tensorization is applied only when the resulting state transition remains consistent with the original algorithm. Let GrG_r and GtG_t denote one generation of a source-consistent implementation and its tensorized implementation. Both calculations receive the same population PtP_t, scalar state sts_t, and explicit random-event tensor ξt\xi_t as follows:

(Pt+1q,st+1q)=gq(Pt,st,ξt),q∈{r,t}.(5)\left(P^{q}_{t+1},s^{q}_{t+1}\right)=g_q(P_t,s_t,\xi_t),\qquad q\in\{r,t\}. \tag*{(5)}

The function I\mathcal{I} extracts discrete outputs, including selected indices, front numbers, masks, archive membership, evaluation counts, and ordered writes. The function V\mathcal{V} extracts floating-point outputs. Semantic preservation requires

It=Ir,∥Vt−Vr∥∞≤ϵa+ϵr∥Vr∥∞,(6)\mathcal{I}_t=\mathcal{I}_r,\qquad\lVert\mathcal{V}_t-\mathcal{V}_r\rVert_{\infty}\leq\epsilon_a+\epsilon_r\lVert\mathcal{V}_r\rVert_{\infty}, \tag*{(6)}

where ϵa\epsilon_a and ϵr\epsilon_r are absolute and relative tolerances fixed for the data type before validation. A tolerance cannot justify a different tie decision, random event, feasibility state, or termination count. This distinction is essential because a small objective difference can still produce a different discrete population.

Fig. Figure 2 shows how this criterion guides implementation. The original algorithm first defines the population state and the complete state transition. Then, calculations are separated according to whether their execution order can be exchanged. Pairwise relations, sorting reductions, selection, variation, and population-level problem evaluation enter the interchangeable group. Sequential replacements, iterative truncation, stage transitions, and deterministic tie resolution enter the ordered group. This classification follows the dependency between values rather than the apparent size of a loop.

Figure 2. Execution and validation process for semantics-preserving tensorization. Interchangeable population calculations are executed as dense NPU tensors, while calculations with causal dependencies retain their prescribed order.

The interchangeable group is evaluated through dense float32 tensor kernels when an Ascend NPU is selected. The ordered group receives compact tensors that have already been constructed by the device and executes only the recurrence required by the original algorithm. Both groups contribute to one population update. The updated indices, fronts, masks, evaluation count, and history are then compared with the source transition. This process keeps validation close to the generation boundary and makes the reason for each host-controlled calculation explicit.

Many population operators compare every pair of individuals. Under minimization, the objective value of individual ii on objective mm is denoted by FimF_{im}. Reshaping FF to (N,1,M)(N,1,M) and (1,N,M)(1,N,M) allows broadcasting to construct the Pareto dominance relation employed by NSGA-II [21], which can be expressed as follows:

Dij=[⋀m=1MFim≤Fjm]∧[⋁m=1MFim<Fjm].(7)D_{ij}=\left[\bigwedge_{m=1}^{M}F_{im}\leq F_{jm}\right]\land\left[\bigvee_{m=1}^{M}F_{im}<F_{jm}\right]. \tag*{(7)}

The binary value Dij=1D_{ij}=1 indicates that individual ii dominates individual jj. Summation along the first dimension gives the domination count cj=∑iDijc_j=\sum_iD_{ij}. The first non-dominated front contains the indices for which cj=0c_j=0. After one front is labeled, the corresponding row contributions are subtracted from the remaining domination counts. The necessary loop proceeds over fronts rather than individuals, while comparisons, reductions, and mask updates remain tensor operations.

Constrained sorting first identifies infeasible individuals and calculates the sum of positive constraint violations. Their objective vectors are shifted beyond the current objective maximum according to the violation value. Then, the same dominance calculation can reproduce the feasibility rule applied

Algorithm 1 Tensorized Non-Dominated Selection

Input: F∈RN×MF \in\mathbb{R}^{N\times M} and survivor count nkeepn_{\mathrm{keep}}.

Output: Survivor index tensor ss.

  1. Broadcast FF and calculate the dominance matrix DD by Eq. (7).

  2. Calculate domination counts c←1TDc \leftarrow\mathbf{1}^{\mathsf{T}}D.

  3. Initialize ss as empty and r←cr \leftarrow c.

  4. while ∣s∣<nkeep|s|<n_{\mathrm{keep}} do

  5. &nbsp;&nbsp;&nbsp;&nbsp;Form the next front h←{j∣rj=0}h\leftarrow\{j\mid r_j=0\} by a Boolean mask.

  6. &nbsp;&nbsp;&nbsp;&nbsp;if ∣s∣+∣h∣≤nkeep|s|+|h|\leq n_{\mathrm{keep}} then

  7. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Append hh and update r←r−1TD:,hr\leftarrow r-\mathbf{1}^{\mathsf{T}}D_{:,h}.

  8. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Mark the appended entries so that they cannot enter another front.

  9. &nbsp;&nbsp;&nbsp;&nbsp;else

  10. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Calculate crowding distances within hh by stable sorting and scatter.

  11. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Append the required entries of hh in descending crowding order.

  12. &nbsp;&nbsp;&nbsp;&nbsp;end if

  13. end while

  14. Return ss in its deterministic tie order.

by the original implementation [21]. This formulation retains a single ranking operator for unconstrained and constrained populations.

Within a front F\mathcal{F}, stable sorting produces the objective order required by crowding-distance calculation [21]: f(1)m≤⋯≤f(∣F∣)mf_{(1)m}\leq\cdots\leq f_{(|\mathcal{F}|)m} for objective mm. Boundary individuals receive infinite crowding distance. The contribution of an interior individual is defined as follows:

q(i)m=f(i+1)m−f(i−1)mf(∣F∣)m−f(1)m,i=2,…,∣F∣−1.(8)q_{(i)m}=\frac{f_{(i+1)m}-f_{(i-1)m}}{f_{(|\mathcal{F}|)m}-f_{(1)m}},\qquad i=2,\ldots,|\mathcal{F}|-1. \tag*{(8)}

All objective columns are sorted together. Adjacent differences are calculated in the sorted order, and a scatter operation returns each contribution to the original individual index. Stable sorting preserves deterministic ties. Zero-range and non-finite cases follow the original behavior instead of being silently replaced by an alternative crowding rule.

Algorithm 1 summarizes how these relations support environmental selection. The loop advances by complete fronts, while every pairwise comparison and every update within one front remains a tensor calculation. Only the final front requires crowding-based truncation.

Tournament selection [21] stores TT candidates for every required parent in an index tensor with shape (T,N)(T,N). Fitness values are gathered for all tournaments, and stable sorting applies the criteria in lexicographic order. Roulette selection Algorithm 2 Batched Variation and Problem Evaluation

Input: Parent population P\mathcal{P}, parent indices pp, random tensor ξ\boldsymbol{\xi}, and Problem.

Output: Evaluated offspring population Po\mathcal{P}_{o}.

  1. Gather all parent tensors with pp.

  2. Construct crossover, mutation, and activation masks from ξ\boldsymbol{\xi}.

  3. Calculate every offspring decision vector in one batched variation call.

  4. Apply encoding-specific bounds and repair to the offspring tensor Xo\boldsymbol{X}_{o}.

  5. Evaluate (Fo,Co)←E(Xo)(F_{o}, C_{o}) \leftarrow\mathcal{E}(X_{o}) by Eq. (4).

  6. Form Po←(Xo,Fo,Co)\mathcal{P}_{o} \leftarrow(X_{o}, F_{o}, C_{o}).

  7. Increase FEFE by the number of rows in XoX_{o} and return Po\mathcal{P}_{o}.

normalizes inverse fitness forms a cumulative sum and applies searchsorted to a batch of uniform random values. Reference points are generated from simplex lattices and cached by population size, objective count, and data type.

Real-valued genetic variation processes all parent pairs simultaneously. Simulated binary crossover and polynomial mutation construct random, distribution, boundary, and activation tensors with shape (N,D)(N,D). Differential evolution batches base vectors, difference vectors, scale factors, and crossover masks [30]. Encoded variation applies column masks for integer, label, binary, permutation, and mixed decision representations. The associated repair is evaluated by batch. These calculations preserve the random-event layout so that controlled operator tests can compare offspring entry by entry.

Pairwise Euclidean distance uses direct broadcasting for moderate inputs. For larger matrices XX and YY, squared distance is calculated as follows:

∥xi−yj∥22=∥xi∥22+∥yj∥22−2xiTyj.(9)\lVert x_i-y_j\rVert_2^2=\lVert x_i\rVert_2^2+\lVert y_j\rVert_2^2-2x_i^{\mathsf{T}}y_j. \tag*{(9)}

The inputs are centered before matrix multiplication. Entries that approach the roundoff threshold are recomputed through direct element-wise differences, and small negative values are clamped to zero. This correction avoids the cancellation that changes nearest-neighbor order for nearly identical points.

Problem evaluation follows the same batching principle. Separable terms are calculated for all individuals before reduction, while constraint values form a matrix with the population as its first dimension. Multimodal test problems calculate distances from all individuals to multiple reference centers through a three-dimensional tensor. Sparse problems reuse variable masks and group indices across the population. Permutation and assignment problems apply batched gather operations over route or assignment positions. As a result, objective evaluation no longer reintroduces an individual-level Python loop after the population operators have been tensorized.

Algorithm 2 gives the common offspring procedure. Random events are generated before variation and retain the same tensor positions in reference and tensorized tests. Repair and problem evaluation then process the complete offspring population.

Ordered Updates and Device Execution

Device initialization precedes the transfer of mutable problem states. CPU processes disable automatic loading of the accelerator backend before PyTorch is imported, which prevents a CPU run from creating an unrelated NPU context. The NPU runtime is loaded only when the selected device requests it, and the active device is fixed before initialization, reference points, and problem data are generated.

The default real type is 64-bit floating-point precision (float64) on a CPU and float32 on an NPU. A matched CPU experiment can request float32. An NPU request for float64 is converted to float32 because several required Ascend kernels do not support float64. Floating-point calculations performed by host-controlled recurrences in an NPU run follow the same precision. Random seeds are propagated to Python, NumPy, PyTorch, and the active accelerator backend. Integer indices and Boolean masks retain their discrete types.

Timing follows the asynchronous execution of the NPU. The workflow synchronizes the selected device immediately before the timer starts and again after the algorithm finishes. The resulting interval includes every operation submitted by the optimization run and excludes unfinished work from an earlier calculation. Indicator calculation and result serialization are measured separately. Built-in and user-defined components share this timing interface.

Some calculations cannot be exchanged without changing the algorithmic process. MOEA/D [8] and C-MOEA/D [31] update subproblems sequentially. Once an offspring replaces one or more neighbors, a later subproblem observes the updated population. A simultaneous write would cause every subproblem to read the same population at the beginning of the generation. Therefore, AscendMOEA tensorizes weight generation, neighborhood construction, parent indexing, scalarizing values, and objective evaluation, while preserving the prescribed subproblem order.

SPEA2 [9] contains another ordered recurrence. The first deletion in distance truncation changes the neighbor sequence used to choose the second deletion. AscendMOEA calculates and stably sorts the complete distance relations on the tensor device. For an NPU run, the sorted distances and neighbor indices are transferred once to the host. Then, a Numba-compiled recurrence performs the deterministic deletions, and only the final retention mask returns to the NPU. This structure avoids one device synchronization per deletion and retains the exact truncation order.

Algorithm 3 summarizes the resulting generation process. Dense population calculations stay on the selected tensor device. Ordered control receives precomputed relations and produces compact discrete outputs. The generational while loop remains visible in every algorithm, which keeps termination, parameter schedules, and state transitions close to their mathematical definitions.

The synchronized runtime on device dd is decomposed as follows:

Td(N)=Tdfixed+Tddense(N)+Tdordered(N)+Tdmove(N),(10)T_d(N)=T_d^{\mathrm{fixed}}+T_d^{\mathrm{dense}}(N)+T_d^{\mathrm{ordered}}(N)+T_d^{\mathrm{move}}(N), \tag*{(10)}

where d∈{CPU,NPU}d\in\{\mathrm{CPU},\mathrm{NPU}\}. The term TdfixedT_d^{\mathrm{fixed}} contains launches, synchronization, and shape-specific compilation that occurs after timing begins. The dense tensor operations are represented by Tddense(N)T_d^{\mathrm{dense}}(N). The term Tdordered(N)T_d^{\mathrm{ordered}}(N) measures causally ordered host control, and Tdmove(N)T_d^{\mathrm{move}}(N) contains transfers between the tensor device and that control calculation. NPU execution becomes faster when

TCPUdense(N)−TNPUdense(N)>ΔTfixed+ΔTmove,(11)T_{\mathrm{CPU}}^{\mathrm{dense}}(N) - T_{\mathrm{NPU}}^{\mathrm{dense}}(N) > \Delta T^{\mathrm{fixed}} + \Delta T^{\mathrm{move}}, \tag*{(11)}

where each Δ\Delta is the NPU cost minus the corresponding CPU cost. The ordered term is shared when both devices execute the same recurrence. Hence, population size alone does not determine acceleration. The density of ranking, distance, variation, and problem evaluation needs to be considered together with the ordered fraction.

Image not extracted

Figure 3.

Algorithms, Problems, and Extension

The algorithm library covers four complementary categories, as summarized in Table II. The general MOEAs include NSGA-II [21], MOEA/D [8], and SPEA2 [9], which represent dominance, decomposition, and strength mechanisms. The constrained multi-objective evolutionary algorithms (CMOEAs) cover bidirectional coevolution, auxiliary tasks, staged constraint handling, and decomposition under constraints. The multimodal multi-objective evolutionary algorithms (MMOEAs) maintain diversity in the decision space and the objective space. Sparse and large-scale MOEAs manipulate variable masks, decision groups, or learned structures with fewer dimensions.

CategoryCountMOEAs or MOP suitesPrincipal tensorized calculations
General MOEAs3NSGA-II [21], MOEA/D [8], and SPEA2 [9]Dominance, fronts, crowding, scalarization, neighborhoods, strength fitness, and exact truncation
CMOEAs7BiCo [32], C-MOEA/D [31], CCMO [33], CMEGL [34], CMOEA-CD [35], CMOEA-MS [36], and EMCMO [37]Constraint violation, feasibility masks, auxiliary populations, adaptive stages, and population exchange
MMOEAs3HREA [38], CMMO [39], and CoMMEA [40]Local convergence, neighborhoods in the decision space, hierarchical ranking, epsilon relations, and archive cooperation
Sparse and large-scale MOEAs5SparseEA [41], SparseEA2 [42], TS-SparseEA [43], LMEA [44], and MOEA/PSL [45]Variable scoring, sparse masks, grouped variation, correlation, and model training
Unconstrained MOPs13ZDT1–6 [46] and DTLZ1–7 [47]Separable, disconnected, biased, degenerate, and many-objective PFs
CMOPs33CF1–10 [48], DASCMOP1–9 [49], and LIRCMOP1–14 [50]Adjustable feasibility, disconnected regions, and large infeasible barriers
MMOPs74MMF and CEC 2019 [51], IDMP [52], MMMOP [53], Polygon [54], and four multimodal applicationsEquivalent and local Pareto sets, imbalanced basins, scattered optima, and geometric regions
Sparse and large-scale MOPs17SMOP1–8 [41] and LSMOP1–9 [55]Sparse decision structures, variable linkage, and high decision dimensions
Real-world and combinatorial MOPs18RWMOP1–10 [56], sparse applications, MOTSP [57], mQAP [58], MONRP [59], and MPDMP [60]Engineering constraints, routes, assignments, release planning, and discrete decisions

Table II. Algorithm and problem portfolio of AscendMOEA.

Each MOEA remains in an independent Python module and inherits the same base class. Common operators are imported from the public operator package. Fitness, archive, and stage calculations that belong to one MOEA remain in its module, which keeps the implementation traceable to the source publication. The supplementary material provides the complete mapping between publications and tensorized calculations.

The 155 registered MOPs form five disjoint categories in Table II. Four multimodal applications are included with the MMOPs. The map-based problem [61] examines diversity maintenance through disconnected regions in the decision space. Rental location selection is introduced with a dual-population coevolutionary algorithm [62]. RLP originates from the application study of bidirectional coevolution [63], and UECLPP contains shifted local PFs [64]. The category of real-world and combinatorial MOPs adds engineering design, sparse applications, routing, assignment, release planning, and decision problems with many objectives.

Reference PFs and Pareto sets are cached after construction. Numerical problems calculate objectives and constraints in batches, and fixed application data are stored with the package. Therefore, the same problem class executes on a CPU or NPU without maintaining separate formulas. This property is particularly important for a platform study. Otherwise, an accelerated algorithm can spend most of its runtime in a loop-based objective function.

A custom problem inherits Problem, defines dimensions and bounds in setting, and implements a batched cal_obj. Optional methods provide constraints, repair, reference points, or a drawable PF. A custom algorithm inherits Algorithm, implements the evolutionary loop, and calls not_terminated at generation boundaries. Decorators register either class under a stable public name. For example, a two-objective sphere problem can calculate both objectives by column-wise reductions over one decision tensor and can then be executed by optimize(NSGAII(), problem, device="npu:0", seed=7). The same workflow returns the final population, evaluation count, device, and synchronized runtime. Detailed extension examples and public operator signatures are given in the supplementary material.

Experiments and Analysis

Experimental Design and Validation

The experiments address four research questions. RQ1 examines whether tensorized population operators preserve their reference outputs and identifies the scale at which NPU execution becomes advantageous. RQ2 evaluates the runtime and memory behavior of complete MOEAs across MOP categories and population scales. RQ3 determines whether CPU and NPU runs retain terminal indicators and convergence throughout evolution. RQ4 separates the contribution of replacing common operators from the contribution of tensorizing calculations inside each MOEA and evaluating each MOP in batches.

Three matched implementations are compared. The reference implementation retains source-consistent scalar or loop-based population calculations. The operator implementation replaces the common population operators but leaves calculations inside each MOEA unchanged. The full implementation additionally tensorizes these remaining calculations and evaluates each MOP in population batches. MOEA, MOP, seed, device, precision, and termination settings remain matched. Therefore, timing ratios can be associated with the corresponding implementation change.

Experiments run on a server with four Kunpeng 920 CPUs, 192 physical CPU cores, 1 TB host memory, and eight Ascend 910B4 NPUs. Each CPU task employs eight PyTorch [23] intra-operation threads. Independent CPU runs are scheduled as separate processes, while one persistent formal worker is bound to each NPU. Both CPU and NPU timing comparisons use float32. CPU processes disable accelerator-backend autoloading before PyTorch is imported. NPU timing synchronizes the device immediately before and after every measured interval.

ExperimentConfigurationsRepetitionsRecorded outputs
Operator stressN∈{1000,2000,5000,10000,20000}N \in\{1000, 2000, 5000, 10000, 20000\} with varied MM, DD, ties, encodings, and operator parameters5 after warmupRuntime, throughput, host memory, NPU memory, output agreement, OOM, and timeout
Standard algorithmsN=100N = 100 and FEmax⁡=10,000FE_{\max} = 10{,}000 for every compatible algorithm–problem pair20 paired seedsRuntime, complete population histories, indicators, FE, terminal state, and memory
Scale algorithms(N,FEmax⁡)(N, FE_{\max}) from (1000,1×105)(1000, 1 \times10^{5}) to (20000,2×106)(20000, 2 \times10^{6})5 paired seedsCPU-to-NPU speedup, convergence, memory growth, OOM, and timeout
Implementation ablationReference, common-operator, and full tensorized implementations under matched settings5 paired seedsReference/operator, operator/full, and reference/full timing gains

Table III. Experimental workloads and recorded evidence.

The compute interval includes the complete optimization run and excludes indicator calculation, history serialization, and file writing. Operator configurations perform an unmeasured warmup before five timed repetitions. Standard algorithm experiments contain 20 paired seeds. Scale and ablation configurations contain five paired seeds when complete. Each run records process-tree resident set size (RSS), proportional set size for concurrent CPU processes, NPU allocated and reserved memory, and process-level high-bandwidth memory. Out-of-memory (OOM), timeout, device error, invalid indicator, and interruption are stored as distinct terminal states. A run that exceeds 14 h terminates with its elapsed time, completed evaluations, latest generation, and memory samples.

Table III summarizes the evaluated workloads. Operator stress tests vary population size, objective count, decision dimension, duplicate rate, encoding, and selection configuration. The standard algorithm experiment uses N=100N = 100 and FEmax⁡=10,000FE_{\max} = 10{,}000. The scale experiment increases NN from 1,000 to 20,000 and increases FEmax⁡FE_{\max} proportionally from 1×1051 \times10^{5} to 2×1062 \times10^{6}. General MOEAs use ZDT or DTLZ problems in the scale tests. CMOEAs, MMOEAs, and sparse or large-scale MOEAs use MOPs from their corresponding suites.

Hypervolume (HV) measures the dominated objective-space volume [65]. Inverted generational distance (IGD) and modified inverted generational distance (IGD+) evaluate convergence and coverage, while inverted generational distance in the decision space (IGDX) evaluates approximation of the Pareto set [66, 67]. The reciprocal of Pareto sets proximity, denoted by 1/PSP1/\mathrm{PSP}, combines decision-space coverage and IGDX with a minimization orientation [68]. Constrained experiments additionally record feasible rate and constraint violation. Sparse experiments record the nonzero-variable ratio. Runtime and memory are summarized by medians, interquartile ranges, means, standard deviations, and 95% bootstrap confidence intervals (CIs). CPU-to-NPU speedup is calculated for each matched seed before aggregation. Statistical comparisons employ paired or unpaired Wilcoxon tests as appropriate, Holm correction [69], effect sizes, and Friedman ranks [70].

Correctness is examined at component, generation, and repeated-run levels. Each common operator is compared with an independent source-consistent implementation on fixed tensors. Front numbers, feasibility masks, selected indices, neighbor orders, and truncation masks are required to match element by element. Continuous outputs include pairwise distances, crowding values, offspring tensors, and reference points. Their absolute and relative tolerances are fixed according to float32 before the output is inspected. Dedicated fixtures cover duplicate objective vectors, equal distances, zero objective ranges, empty constraint matrices, odd population sizes, non-finite values, and boundary repair.

Problem implementations are checked against their corresponding MATLAB definitions. The input set combines Latin-hypercube samples, lower and upper bounds, known Pareto points, and independently generated random decisions. The validation record contains output shapes, finite-value ratios, maximum absolute and relative errors, and feasibility mismatches. Permutation and assignment problems additionally require valid discrete structures and identical objectives on deterministic instances. This procedure detects errors that a short optimization run may conceal, such as an ignored decision variable, an unintended constant objective, or a constraint with the wrong sign.

Algorithm validation combines controlled intermediate states with indicator distributions. If two implementations consume the same parent indices and random-event tensors, the population, fitness, fronts, archive membership, and function-evaluation count are examined after every major calculation. Different language runtimes do not always expose identical random-number streams. In this case, repeated runs use common problem settings and compare HV, IGD, IGD+, IGDX, 1/PSP1/\mathrm{PSP}, feasible rate, and runtime distributions. A substantial difference is investigated through deterministic intermediate fixtures until the first divergent operation is identified. The source mapping and validation evidence for all 18 algorithms are reported in the supplementary material.

Population Operators

Fig. 3 reports the gain obtained when the complete tensorized operator replaces its source-consistent NPU implementation. Each column represents one pressure configuration, and each row follows the standard name of a population operator. Across 122 matched configurations, the median gain is 1.58×, with an interquartile range of 1.14–6.94×. Non-dominated selection, roulette-wheel selection, differential evolution, and several batched evaluation settings show the largest improvements. Their calculations replace repeated scalar control with comparisons or reductions over complete tensors.

Some cells remain near parity because short operations contain too little arithmetic to offset launch and synchronization costs. The device comparison in the supplementary material shows a similar scale effect. Dense pairwise relations, genetic variation, differential evolution, and population evaluation increasingly favor the NPU as NN grows, while selection operators with little work per element cross over later. These results support the runtime model in Eq. (10) and show why tensorization and device acceleration need to be evaluated separately.

Performance at Different Scales

The standard experiment contains 20,100 paired float32 runs from 1,005 algorithm–problem clusters at N=100N = 100 and FEmax⁡=10,000FE_{\max} = 10{,}000. The median CPU-to-NPU ratio is 0.980×, and the interquartile range is 0.923–1.026×. The clustered-bootstrap 95% CI for the median is 0.976–0.983×. Hence, the NPU and eight-thread CPU remain close at this small workload, and the CPU has a slight median advantage. This outcome is consistent with the fixed launch and synchronization cost in Eq. (10).

The scale experiment contains 373 successful matched pairs from 77 algorithm–problem–configuration clusters. Population size ranges from 1,000 to 20,000, and FEmax⁡FE_{\max} ranges from 1×1051 \times10^{5} to 2×1062 \times10^{6}. The median CPU-to-NPU speedup reaches 5.76×, with an interquartile range of 1.72–19.14×. Resampling complete clusters gives a 95% CI of 3.26–9.09×. The population-wise results in the supplementary material show that every MOP category moves above parity as NN increases. Larger populations increase the time spent on pairwise relations and batched evaluation, which distributes fixed device costs over more useful arithmetic.

The dispersion remains wide at the three largest population sizes. At N=20,000N = 20{,}000, the aggregate first and third quartiles are 1.01× and 32.26×, respectively. Different calculation structures explain much of this range. The number of successful pairs decreases from 85–86 at the three smaller population sizes to 71 and 46 at N=10,000N = 10{,}000 and 20,000. Therefore, capacity outcomes change the composition of the aggregate groups. The supplementary analysis retains the algorithm, MOP, configuration, and seed associated with each matched pair.

Figure 4 presents the scaling process for one representative MOEA–MOP pair from each algorithm category. For each run, the synchronized solve time is divided by (FE−N)/N(FE-N)/N, which gives the number of completed population-sized updates after initialization. Each plotted device–configuration point reports the median over five float32 seeds, and the shaded region gives the interquartile range. The curves contain only observed successful runs, so a successful result from one device remains visible when the corresponding runs on the other device reach a resource limit. The CPU curves increase rapidly because pairwise relations and population calculations expand with NN. The NPU curves grow more gradually after the initial device cost is covered.

Figure 4. Representative scaling of the synchronized time per generation for four MOEA categories. Lines and shaded regions show medians and interquartile ranges over five float32 seeds. Each value is the synchronized solve time divided by (FE−N)/N(FE-N)/N. A missing device point indicates that none of its five runs finishes successfully at that configuration.

The four panels reveal that the crossover scale depends on the calculation performed by each MOEA. At the largest successful matched population for each pair, NSGA-II [21] on DTLZ2 [47], CMOEA-CD [35] on CF1 [48], CMOMEA [40] on MMF1 [51], and LMEA [44] on SMOP1 [41] reach median speedups of 31.38×, 33.56×, 21.16×, and 37.31×, respectively. The ComM​​EA panel retains the successful NPU observations at N=10,000N = 10{,}000, although all five CPU runs at this configuration reach the 14-h time limit. At N=20,000N = 20{,}000, the CPU runs reach the time limit and the NPU runs terminate with OOM, so neither device contributes a point. LMEA remains close to parity at N=1,000N = 1{,}000, whereas the gap becomes clear at larger populations. Hence, the scale advantage occurs in every MOEA category represented by the experiment, but it does not begin at one universal population size.

Figure 5 expresses the same matched runs as cumulative compute time saved. For every successful pair, the synchronized NPU time is subtracted from its CPU counterpart, and the differences are accumulated by MOP category. The total reaches 129.4 h after configurations up to N=20,000N = 20{,}000 are included. MMOPs contribute 59.0 h, and sparse or large-scale MOPs contribute 42.1 h. The remaining 28.3 h comes from unconstrained MOPs and CMOPs. This decomposition reflects the duration of each workload together with its relative speedup.

Figure 5. Cumulative synchronized compute time saved by the NPU over successful matched scale runs. Each colored area gives the contribution of one MOP category, and the black line gives the total.

Figure 3 (PDF p. 10). Timing gain of the fully tensorized NPU operators relative to their source-consistent implementations. A value above 1×1\times favors tensorization, and the configuration labels follow N∣M∣DN|M|D.

Effects of the Two Tensorization Levels

The ablation separates common population operators from calculations located inside each algorithm. On the CPU, replacing the reference operators and then tensorizing the remaining calculations produce median gains of 1.037×1.037\times and 1.067×1.067\times, respectively. Together, the two changes yield a median gain of 1.122×1.122\times. Replacing only the common operators on the NPU is approximately neutral at 0.984×0.984\times. Tensorizing the calculations inside each algorithm then raises the median gain to 1.363×1.363\times, and the complete implementation is 1.295×1.295\times faster than the reference.

Figure 6 shows the complete NPU distributions behind these medians. The wide upper ranges occur because environmental selection and batched problem evaluation dominate some MOEA–MOP combinations. Tensorizing only a shared dominance or distance function cannot remove repeated indexing, scalar decisions, or individual evaluations that remain in the surrounding algorithm. The improvement becomes clearer when common operators and the calculations inside each algorithm are transformed together.

Figure 6. NPU timing gains from common-operator replacement and tensorization inside each algorithm. Violin envelopes show the distributions, internal boxes show interquartile ranges, and zero on the log⁡2\log_{2} scale denotes parity.

Numerical Agreement and Practical Workloads

Numerical agreement is evaluated independently of runtime. Among all paired standard runs, 19,479 pairs contain finite HV values, 19,478 contain finite IGD values, and 17,023 contain finite IGD+ values. The median and maximum relative CPU–NPU differences are zero at the stored precision for all three

ExperimentPairsClustersMedian95% CI
Standard workload20,1001,0050.980×0.980\times0.9760.976–0.983×0.983\times
Scale workload373775.76×5.76\times3.263.26–9.09×9.09\times
Real-world subset2,9201460.965×0.965\times0.9590.959–0.972×0.972\times

Table IV. Aggregate synchronized timing results for the full float32 implementation.

indicators. The supplementary identity plots show paired HV, IGD, and IGD+ values over their complete numerical ranges. Terminal indicators can hide a transient difference, so complete population histories are examined. The supplementary material reports the absolute histories for NSGA-II [21], C-MOEA/D [31], HREA [38], and SparseEA [41]. These examples cover IGD+, feasible rate, IGDX, and 1/PSP. The CPU and NPU medians overlap throughout the evaluation budget, and their interquartile regions remain consistent. Therefore, the terminal comparisons and complete histories support the discrete and continuous criteria in Eq. (6) at both operator and algorithm levels.

The real-world subset contains 2,920 paired runs from 146 algorithm–problem clusters. Its median speedup is 0.965×0.965\times, with a 95% clustered-bootstrap CI of 0.9590.959–0.972×0.972\times. Most of these experiments use N=100N=100, and several engineering or combinatorial objectives contain irregular gather operations with limited arithmetic intensity. Thus, their primary contribution is problem coverage and numerical comparability. The scale experiments provide a more direct measurement of NPU throughput under dense workloads.

Memory behavior is reported with the terminal state. Among the observed scale tasks included in the capacity analysis, 2,354 terminate successfully, 127 reach the 14-h limit, and 120 terminate with OOM. OOM and timeout are retained as outcomes rather than converted into zero time or missing quality. The supplementary material reports host and NPU memory growth together with completed-run counts. These records identify the practical boundary of full pairwise relations, whose storage grows quadratically with NN.

Discussion

The experiments lead to three practical observations. Firstly, tensorization and accelerator execution are separate effects. Batched operators improve the CPU implementation as well, while an NPU provides an additional advantage only after dense computation becomes large enough to cover launch and synchronization costs. Therefore, a small standard workload remains close to parity. Secondly, complete algorithm structure matters more than the nominal problem category. Two algorithms with the same NN and FEmax⁡FE_{\max} can have different speedups because one spends more time on pairwise tensors and the other contains a longer ordered recurrence. Thirdly, numerical equivalence requires explicit control of ties, random

events, precision, and write order. Indicator similarity alone cannot reveal a changed environmental selection rule.

The Ascend execution strategy provides a useful compromise for algorithms with mixed computational structure. Dense dominance, distance, variation, and objective calculations remain on the NPU. Compact precomputed data support the short recurrences that require strict ordering. This arrangement keeps NPU tasks in float32 and limits transfers to indices, masks, or sorted relations. It avoids repeatedly launching conditional kernels with little arithmetic.

However, full pairwise relations have O(N2M)O(N^{2}M) computational and memory requirements, which restrict the largest feasible population. Some combinatorial objectives contain irregular memory access and cannot fully utilize matrix units. Float32 comparisons can be sensitive when objective or constraint values differ near machine precision, although the current validation detects changes in the resulting discrete state. The present platform targets one host with multiple Ascend devices. Distributed multi-node execution and compiler-level operator fusion offer further opportunities for scalability.

The current evidence suggests a practical selection rule.

CPU execution is appropriate for small populations, short runs, and highly ordered algorithms. Ascend NPU execution becomes preferable when a generation contains large pairwise relations, high-dimensional variation, or batched problem evaluation. The synchronized crossover should be measured for a representative workload because device labels alone do not predict performance.

Conclusion

This study presents AscendMOEA, which is a scalable platform for tensorized multi-objective evolutionary optimization on Ascend NPUs. A unified population representation connects algorithms, problems, operators, indicators, monitors, and experiments. Common calculations and the calculations defined inside each algorithm are expressed as population tensors, while updates with causal dependencies retain their prescribed sequence. The device policy provides explicit precision, seeding, synchronization, and timing behavior. The platform contains 18 MOEAs that span general MOEAs, CMOEAs, MMOEAs, and sparse or large-scale MOEAs. Its 155 MOPs cover unconstrained MOPs, CMOPs, MMOPs, sparse MOPs, large-scale MOPs, real-world MOPs, and combinatorial MOPs. Experiments show that tensorized operators obtain a median NPU gain of 1.58×. Complete algorithms remain near parity for a small standard workload and achieve a median speedup of 5.76× at larger scales. Paired terminal indicators and generation histories retain the recorded numerical behavior. These results indicate that Ascend acceleration is most effective when dense population calculations dominate the evolutionary process.

Future research can reduce the memory demand of dense pairwise relations through sparse or implicit representations that preserve the resulting dominance and selection decisions. Extending the runtime across multiple Ascend hosts is another important direction, and this execution model requires reproducible random states, coordinated synchronization, and efficient exchange of population tensors. Compiler fusion and persistent kernels can reduce launch costs for short selection and repair operations, whose arithmetic remains insufficient to occupy the NPU at small NN. For expensive engineering MOPs, batched surrogate models and asynchronous evaluation can reduce costly objective evaluations while exposing additional parallel calculations. These extensions can be examined with the operator, scale, numerical agreement, and memory criteria established in this study.

References

  1. [1]A. Zhou, B.-Y. Qu, H. Li, S.-Z. Zhao, P. N. Suganthan, and Q. Zhang, “Multiobjective evolutionary algorithms: A survey of the state of the art,” Swarm and Evolutionary Computation, vol. 1, no. 1, pp. 32–49, 2011.DOI
  2. [2]J. J. Durillo and A. J. Nebro, “jMetal: A Java framework for multi-objective optimization,” Advances in Engineering Software, vol. 42, no. 10, pp. 760–771, 2011.DOI
  3. [3]A. Liefooghe, L. Jourdan, and E.-G. Talbi, “A software framework based on a conceptual unified model for evolutionary multiobjective optimization: ParadisEO-MOEO,” European Journal of Operational Research, vol. 209, no. 2, pp. 104–112, 2011.DOI
  4. [4]Y. Tian, R. Cheng, X. Zhang, and Y. Jin, “PlatEMO: A MATLAB platform for evolutionary multi-objective optimization [educational forum],” IEEE Computational Intelligence Magazine, vol. 12, no. 4, pp. 73–87, 2017.DOI
  5. [5]J. Blank and K. Deb, “pymoo: Multi-objective optimization in Python,” IEEE Access, vol. 8, pp. 89 497–89 509, 2020.DOI
  6. [6]A. Benítez-Hidalgo, A. J. Nebro, J. García-Nieto, I. Oregi, and J. Del Ser, “jMetalPy: A Python framework for multi-objective optimization with metaheuristics,” Swarm and Evolutionary Computation, vol. 51, p. 100598, 2019.
  7. [7]F. Biscani and D. Izzo, “A parallel global multiobjective framework for optimization: pagmo,” Journal of Open Source Software, vol. 5, no. 53, p. 2338, 2020.DOI
  8. [8]Q. Zhang and H. Li, “MOEA/D: A multiobjective evolutionary algorithm based on decomposition,” IEEE Transactions on Evolutionary Computation, vol. 11, no. 6, pp. 712–731, 2007.DOI
  9. [9]E. Zitzler, M. Laumanns, and L. Thiele, “SPEA2: Improving the strength pareto evolutionary algorithm,” in Evolutionary Methods for Design, Optimization and Control with Applications to Industrial Problems, Athens, Greece, 2001, pp. 95–100.DOI
  10. [10]Y. Yang, T. Tian, and D. Ha, “EvoJAX: Hardware-accelerated neuroevolution,” in Proceedings of the Genetic and Evolutionary Computation Conference Companion. ACM, 2022, pp. 308–311.
  11. [11]B. Huang, R. Cheng, Z. Li, Y. Jin, and K. C. Tan, “EvoX: A distributed GPU-accelerated framework for scalable evolutionary computation,” IEEE Transactions on Evolutionary Computation, vol. 29, no. 5, pp. 1649–1662, 2025.arxiv.org/abs/2301.12457
  12. [12]Z. Liang, H. Li, N. Yu, K. Sun, and R. Cheng, “Bridging evolutionary multiobjective optimization and GPU acceleration via tensorization,” IEEE Transactions on Evolutionary Computation, vol. 30, no. 1, pp. 420–434, 2026.DOI
  13. [13]Huawei Ascend, “CANN Community Edition 9.0.X Developer Documentation,” https://www.hiascend.com/document/detail/en/CANNCommunityEdition/900/index/index.html, 2026, accessed September 9, 2026.
  14. [14]Y. Tang and C.-I. Wang, “Performance modeling on DaVinci AI Core,” Journal of Parallel and Distributed Computing, vol. 175, pp. 134–149, 2023.DOI
  15. [15]F.-A. Fortin, F.-M. De Rainville, M.-A. Gardner, M. Parizeau, and C. Gagné, “DEAP: Evolutionary algorithms made easy,” Journal of Machine Learning Research, vol. 13, no. 70, pp. 2171–2175, 2012. [Online]. Available: https://www.jmlr.org/papers/v13/fortin12a.html
  16. [16]Q. Duan, G. Zhou, C. Shao, Z. Wang, M. Feng, Y. Huang, Y. Tan, Y. Yang, Q. Zhao, and Y. Shi, “PyPop7: A pure-Python library for population-based black-box optimization,” Journal of Machine Learning Research, vol. 25, no. 296, pp. 1–28, 2024. [Online]. Available: https://www.jmlr.org/papers/v25/23-0386.html
  17. [17]D. J. Eckman, S. G. Henderson, and S. Shashaani, “SimOpt: A testbed for simulation-optimization experiments,” INFORMS Journal on Computing, vol. 35, no. 2, pp. 495–508, 2023.DOI
  18. [18]S. Huang, G. Jiang, and Y. Zhong, “PyPRS: A Python software package for parallel ranking and selection procedures,” INFORMS Journal on Computing, 2026, articles in Advance.DOI
  19. [19]E.-G. Talbi, “A unified view of parallel multi-objective evolutionary algorithms,” Journal of Parallel and Distributed Computing, vol. 133, pp. 349–358, 2019.DOI
  20. [20]A. Aguilar-Rivera, “A GPU fully vectorized approach to accelerate performance of NSGA-2 based on stochastic non-domination sorting and grid-crowding,” Applied Soft Computing, vol. 88, p. 106047, 2020.
  21. [21]K. Deb, A. Pratap, S. Agarwal, and T. Meyarivan, “A fast and elitist multiobjective genetic algorithm: NSGA-II,” IEEE Transactions on Evolutionary Computation, vol. 6, no. 2, pp. 182–197, 2002.DOI
  22. [22]J. J. Moreno, G. Ortega, E. Filatovas, J. A. Martínez, and E. M. Garzón, “Improving the performance and energy of non-dominated sorting for evolutionary multiobjective optimization on GPU/CPU platforms,” Journal of Global Optimization, vol. 71, no. 3, pp. 631–649, 2018.
  23. [23]A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. K. K. E. Yang, D. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala, “PyTorch: An imperative style, high-performance deep learning library,” in Advances in Neural Information Processing Systems, vol. 32, 2019, pp. 8024–8035. [Online]. Available: https://proceedings.neurips.cc/paper/2019/hash/bd0c3c8ee7f9f2b6f9f7101272740–Abstract.htmlarxiv.org/abs/1912.01703
  24. [24]Ascend Community, “TorchNPU (Ascend Extension for PyTorch),” https://github.com/Ascend/pytorch, 2026, accessed September 9, 2026.
  25. [25]C. R. Harris, K. J. Millman, S. J. van der Walt, R. Gommers, P. Virtanen, D. Cournapeau, E. Wieser, J. Taylor, S. J. Taylor, R. Nelson, J. Smith, R. Kern, M. Picus, S. Hoyer, M. H. van Kerk­wijk, M. Brett, A. Haldane, J. Fernández del Río, M. Wiebe, P. Peterson, P. Gérard-Marchant, K. Sheppard, T. Reddy, W. Weckesser, H. Abbasi, C. Gohlke, and T. E. Oliphant, “Array programming with NumPy,” Nature, vol. 585, no. 7825, pp. 357–362, 2020.
  26. [26]P. Virtanen, R. Gommers, T. E. Oliphant, M. Haberland, T. Reddy, D. Cournapeau, E. Burovski, P. Peterson, W. Weckesser, J. Bright, S. J. van der Walt, M. Brett, J. Wilson, K. J. Millman, N. Mayorov, A. R. J. Nelson, E. Jones, R. Kern, C. Larson, C. J. Carey, Ï. Polat, Y. Feng, E. W. Moore, J. VanderPlas, D. Laxalde, J. Perktold, R. Cirmman, I. Henriksen, E. A. Quintero, C. R. Harris, A. M. Archibald, A. H. Ribeiro, F. Pedregosa, and P. van Mulbregt, “SciPy 1.0: Fundamental algorithms for scientific computing in Python,” Nature Methods, vol. 17, no. 3, pp. 261–272, 2020.
  27. [27]S. K. Lam, A. Pitrou, and S. Seibert, “Numba: A LLVM-based Python JIT compiler,” in Proceedings of the Second Workshop on the LLVM Compiler Infrastructure in HPC. ACM, 2015, pp. 1–6.DOI
  28. [28]G. M. Amdahl, “Validity of the single processor approach to achieving large scale computing capabilities,” in Proceedings of the Spring Joint Computer Conference. ACM, 1967, pp. 483–485.DOI
  29. [29]S. Williams, A. Waterman, and D. Patterson, “Roofline: An insightful visual performance model for multicore architectures,” Communications of the ACM, vol. 52, no. 4, pp. 65–76, 2009.DOI
  30. [30]R. Storn and K. Price, “Differential evolution—a simple and efficient heuristic for global optimization over continuous spaces,” Journal of Global Optimization, vol. 11, no. 4, pp. 341–359, 1997.DOI
  31. [31]H. Jain and K. Deb, “An evolutionary many-objective optimization algorithm using reference-point based nondominated sorting approach, part II: Handling constraints and extending to an adaptive approach,” IEEE Transactions on Evolutionary Computation, vol. 18, no. 4, pp. 602–622, 2014.
  32. [32]Z. Liu, B. Wang, and K. Tang, “Handling constrained multiobjective optimization problems via bidirectional coevolution,” IEEE Transactions on Cybernetics, vol. 52, no. 10, pp. 10163–10176, 2022.DOI
  33. [33]Y. Tian, T. Zhang, J. Xiao, X. Zhang, and Y. Jin, “A coevolutionary framework for constrained multiobjective optimization problems,” IEEE Transactions on Evolutionary Computation, vol. 25, no. 1, pp. 102–116, 2021.DOI
  34. [34]K. Qiao, J. Liang, Z. Liu, K. Yu, C. Yue, and B. Qu, “Evolutionary multitasking with global and local auxiliary tasks for constrained multi-objective optimization,” IEEE/CAA Journal of Automatica Sinica, vol. 10, no. 10, pp. 1951–1964, 2023.DOI
  35. [35]Z. Liu, F. Han, Q. Ling, H. Han, and J. Jiang, “Constraint-pareto dominance and diversity enhancement strategy-based evolutionary algorithm for solving constrained multiobjective optimization problems,” IEEE Transactions on Evolutionary Computation, vol. 29, no. 6, pp. 2771–2784, 2025.DOI
  36. [36]Y. Tian, Y. Zhang, Y. Xu, X. Zhang, K. C. Tan, and Y. Jin, “Balancing objective optimization and constraint satisfaction in constrained evolutionary multiobjective optimization,” IEEE Transactions on Cybernetics, vol. 52, no. 9, pp. 9559–9572, 2022.DOI
  37. [37]K. Qiao, K. Yu, B. Qu, J. Liang, H. Song, and C. Yue, “An evolutionary multitasking optimization framework for constrained multitask optimization problems,” IEEE Transactions on Evolutionary Computation, vol. 26, no. 2, pp. 263–277, 2022.DOI
  38. [38]W. Li, X. Yao, T. Zhang, R. Wang, and L. Wang, “Hierarchy ranking method for multimodal multiobjective optimization with local pareto fronts,” IEEE Transactions on Evolutionary Computation, vol. 27, no. 1, pp. 98–110, 2023.DOI
  39. [39]F. Ming, W. Gong, L. Wang, and L. Gao, “Balancing convergence and diversity in objective and decision spaces for multimodal multi-objective optimization,” IEEE Transactions on Emerging Topics in Computational Intelligence, vol. 7, no. 2, pp. 474–486, 2023.DOI
  40. [40]W. Li, X. Yao, K. Li, R. Wang, T. Zhang, and L. Wang, “Coevolutionary framework for generalized multimodal multi-objective optimization,” IEEE/CAA Journal of Automatica Sinica, vol. 10, no. 7, pp. 1544–1556, 2023.DOI
  41. [41]Y. Tian, X. Zhang, C. Wang, and Y. Jin, “An evolutionary algorithm for large-scale sparse multiobjective optimization problems,” IEEE Transactions on Evolutionary Computation, vol. 24, no. 2, pp. 380–393, 2020.DOI
  42. [42]Y. Zhang, Y. Tian, and X. Zhang, “Improved SparseEA for sparse large-scale multi-objective optimization problems,” Complex & Intelligent Systems, vol. 9, no. 2, pp. 1127–1142, 2023.
  43. [43]J. Jiang, F. Han, J. Wang, Q. Ling, H. Han, and Y. Wang, “A two-stage evolutionary algorithm for large-scale sparse multiobjective optimization problems,” Swarm and Evolutionary Computation, vol. 72, p. 101093, 2022.DOI
  44. [44]X. Zhang, Y. Tian, R. Cheng, and Y. Jin, “A decision variable clustering-based evolutionary algorithm for large-scale many-objective optimization,” IEEE Transactions on Evolutionary Computation, vol. 22, no. 1, pp. 97–112, 2018.
  45. [45]Y. Tian, C. Lu, X. Zhang, K. C. Tan, and Y. Jin, “Solving large-scale multiobjective optimization problems with sparse optimal solutions via unsupervised neural networks,” IEEE Transactions on Cybernetics, vol. 51, no. 6, pp. 3115–3128, 2021.DOI
  46. [46]E. Zitzler, K. Deb, and L. Thiele, “Comparison of multiobjective evolutionary algorithms: Empirical results,” Evolutionary Computation, vol. 8, no. 2, pp. 173–195, 2000.pubmed.ncbi.nlm.nih.gov/10843520
  47. [47]K. Deb, L. Thiele, M. Laumanns, and E. Zitzler, “Scalable multi-objective optimization test problems,” in Proceedings of the 2002 Congress on Evolutionary Computation, vol. 1. IEEE, 2002, pp. 825–830.DOI
  48. [48]Q. Zhang, A. Zhou, S. Zhao, P. N. Suganthan, W. Liu, and S. Tiwari, “Multiobjective optimization test instances for the CEC 2009 special session and competition,” University of Essex and Nanyang Technological University, Tech. Rep. CES-487, 2009.
  49. [49]Z. Fan, W. Li, X. Cai, H. Li, C. Wei, Q. Zhang, K. Deb, and E. Goodman, “A novel multiobjective and scalable constrained multiobjective test problem toolkit,” Evolutionary Computation, vol. 28, no. 3, pp. 339–378, 2019.DOI
  50. [50]Z. Fan, W. Li, X. Cai, H. Huang, Y. Fang, Y. You, J. Mo, C. Wei, and E. D. Goodman, “An improved epsilon constraint-handling method in MOEA/D for CMOPs with large infeasible regions,” Soft Computing, vol. 23, no. 23, pp. 12491–12510, 2019.arxiv.org/abs/1707.08767
  51. [51]J. Liang, B. Qu, D. Gong, and C. Yue, “Problem definitions and evaluation criteria for the CEC 2019 special session on multimodal multiobjective optimization,” Zhengzhou University, Tech. Rep., 2019, technical report. [Online]. Available: https://www.zzu.edu.cn/eiclab/info/1036/1163.htmDOI
  52. [52]Y. Liu, H. Ishibuchi, G. G. Yen, Y. Nojima, and N. Masuyama, “Handling imbalance between convergence and diversity in the decision space in evolutionary multimodal multiobjective optimization,” IEEE Transactions on Evolutionary Computation, vol. 24, no. 3, pp. 551–565, 2020.DOI
  53. [53]C. Yue, B. Qu, K. Yu, J. Liang, and X. Li, “A novel scalable test problem suite for multimodal multiobjective optimization,” Swarm and Evolutionary Computation, vol. 48, pp. 62–71, 2019.DOI
  54. [54]Y. Liu, H. Ishibuchi, Y. Nojima, N. Masuyama, and K. Shang, “A double-niched evolutionary algorithm and its behavior on polygon-based problems,” in Parallel Problem Solving from Nature—PPSN XV, ser. Lecture Notes in Computer Science. Springer, 2018, vol. 11101, pp. 262–273.DOI
  55. [55]R. Cheng, Y. Jin, M. Olhofer, and B. Sendhoff, “Test problems for large-scale multiobjective and many-objective optimization,” IEEE Transactions on Cybernetics, vol. 47, no. 12, pp. 4108–4121, 2017.DOI
  56. [56]A. Kumar, G. Wu, M. Z. Ali, Q. Luo, R. Mallipeddi, P. N. Suganthan, and S. Das, “A benchmark-suite of real-world constrained multi-objective optimization problems and some baseline results,” Swarm and Evolutionary Computation, vol. 67, p. 100961, 2021.DOI
  57. [57]D. W. Corne and J. D. Knowles, “Techniques for highly multiobjective optimisation: Some nondominated points are better than others,” in Proceedings of the Genetic and Evolutionary Computation Conference. ACM, 2007, pp. 773–780.
  58. [58]J. Knowles and D. Corne, “Instance generators and test suites for the multiobjective quadratic assignment problem,” in Evolutionary Multi-Criterion Optimization, ser. Lecture Notes in Computer Science. Springer, 2003, vol. 2632, pp. 295–310.DOI
  59. [59]Y. Zhang, M. Harman, and S. A. Mansouri, “The multi-objective next release problem,” in Proceedings of the Genetic and Evolutionary Computation Conference. ACM, 2007, pp. 1129–1137.DOI
  60. [60]M. Köppen and K. Yoshida, “Substitute distance assignments in NSGA-II for handling many-objective optimization problems,” in Evolutionary Multi-Criterion Optimization, ser. Lecture Notes in Computer Science. Springer, 2007, vol. 4403, pp. 727–741.DOI
  61. [61]H. Ishibuchi, N. Akedo, and Y. Nojima, “A many-objective test problem for visually examining diversity maintenance behavior in a decision space,” in Proceedings of the Genetic and Evolutionary Computation Conference. ACM, 2011, pp. 649–656.DOI
  62. [62]Z. Li, H. Rong, S. Yang, X. Yang, and Y. Huang, “A dual-population coevolutionary algorithm for balancing convergence and diversity in the decision space for multimodal multi-objective optimization,” Applied Soft Computing, vol. 162, p. 111770, 2024.DOI
  63. [63]M. Li, H. Peng, Z. Cai, and D. Peng, “Bi-directional coevolution for multimodal multiobjective optimization with local pareto sets,” IEEE Transactions on Evolutionary Computation, pp. 1–1, 2025, early access.DOI
  64. [64]Y. Zhang and W. Hu, “Block optimization and switchable hybrid clustering for multimodal multiobjective evolutionary optimization with shifted local Pareto front,” Swarm and Evolutionary Computation, vol. 98, p. 102151, 2025.DOI
  65. [65]E. Zitzler and L. Thiele, “Multiobjective optimization using evolutionary algorithms: A comparative case study,” in Parallel Problem Solving from Nature—PPSN V. Springer, 1998, pp. 292–301.DOI
  66. [66]H. Ishibuchi, H. Masuda, and Y. Nojima, “A study on performance evaluation and ability of a modified inverted generational distance indicator,” in Proceedings of the 2015 Annual Conference on Genetic and Evolutionary Computation. ACM, 2015, pp. 695–702.DOI
  67. [67]M. Li and X. Yao, “Quality evaluation of solution sets in multiobjective optimisation: A survey,” ACM Computing Surveys, vol. 52, no. 2, pp. 1–38, 2019.DOI
  68. [68]C. Yue, B. Qu, and J. Liang, “A multiobjective particle swarm optimizer using ring topology for solving multimodal multiobjective problems,” IEEE Transactions on Evolutionary Computation, vol. 22, no. 5, pp. 805–817, 2018.DOI
  69. [69]S. Holm, “A simple sequentially rejective multiple test procedure,” Scandinavian Journal of Statistics, vol. 6, no. 2, pp. 65–70, 1979. [Online]. Available: https://www.jstor.org/stable/4615733DOI
  70. [70]J. Derrac, S. García, D. Molina, and F. Herrera, “A practical tutorial on the use of nonparametric statistical tests as a methodology for comparing evolutionary and swarm intelligence algorithms,” Swarm and Evolutionary Computation, vol. 1, no. 1, pp. 3–18, 2011.DOI

Paper details

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

views · 10

downloads · 0

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

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents