## 3 Novel Approach to Computing Infill Criteria for MOEGO
### A Brief Description of the Monte Carlo Approach
the GPU calculations. After all the calculations of the GPU side are finished, the total number of sample points that satisfy the definition of the MCHVI indicator is fetched (see Algorithm 1, line 6), and then sent back to the CPU side for the MCHVI estimation. That is, only time-consuming and suitable tasks are implemented on the GPU. Algorithm 2 presents the key code snippet of the GPU subroutine for MCHVI calculations, in which MCSP_d is the number of Monte Carlo sample points, Front_d denotes the Pareto front, and HV_d is the computed MCHVI number nq (see lines 7 and 8 in Algorithm 1). The corresponding thread hierarchy is designed as shown in Figure 5. It can be learned that a GPU thread is assigned to the calculations related to each Monte Carlo sample point. All GPU threads are organized into a queue of thread blocks inside a thread grid to be adjusted to the double-layer structure of GPU hardware [42]. In the corresponding code snippet (Algorithm 2), the thread index is first calculated using three build-in parameters, \(blockdim\), \(blockIdx\) and \(threadIdx\) (for details, see [42]). After the thread index is obtained, the locations of each Monte Carlo sample point (with the same thread index) are then compared with the existing Pareto front and current updating points. If the Monte Carlo point is located in the dominated region, an integer of 1 is added to the value of the MCHVI indicator using a build-in function of _atomicadd_ (see line 8 in Algorithm 2). ```
1 attributes(global) subroutine kernel_MCHV(MCSP_d, Front_d, HV_d)
2\(i\) = (blockIdx\(\forall\)\(\propto\)-1)*blockDim\(\forall\)\(\propto\) + threadIdx\(\forall\)\(\propto\)!thread Index
3
4 do\(j\) = 1, nFront!loop over all Pareto front points and updating point
5 if(isInvalid(MCSP_d(:,),Front_d(:,))) return!judge of domination
6 enddo
7
8 istat = atomicadd(HV_d, 1)!accumulate result to global memory
9 end subroutine
```
**Algorithm 2**Code snippet of the kernel for GPU-based MCHVI calculation

Figure 4: General framework of GPU-based MCHVI indicator value calculations. While the corresponding CPU subroutine for calling the GPU subroutine (Algorithm 2) is presented in Algorithm 3, in which MCSP is the number of Monte Carlo sample points, Front de-notes the Pareto front, and HV is the computed MCHVI number nq (See lines 7 and 8 in Algorithm 1).in which the parameters of thread hierarchy, including number of threads per thread block and total number of thread blocks, are assigned in a specific build-in symbol of \"\(<<<<>>\)\". Following our previous GPU works [40; 41], a suggested value of 64 is assigned as the number of threads per block; hence, the total number of thread blocks is equal to \(ceiling\big{(}n_{p},64\big{)}\), a rounding function to return the least integer greater than or equal to its argument, in which \(n_{p}\) is the total number of Monte Carlo sample points. The efficiency of the MOO problem could be expected to improve due to the GPU accelerated implementation, which will be addressed in the following sections. ```
1 subroutine calKernel_MCHV(MCSP, Front, HV)
2 NTPB=641 Number of threads per block
3 NBPG=ceiling(MCSP/64)! Number of blocks per grid
4
5 MCSP_d=MCSP; Front_d=Front!Copy data to GPU
7
8 call kernel_MCHV<<NBPG,NTPB>>>> (MCSP_d,Front_d,HV_d)!call the kernel
9
10 HV=HV_d!Send result back to CPU
11 end subroutine
```

**Algorithm 3** Code snippet of the CPU subroutine for calling \(kernel\_MCHV\)

### Multi-Objective EGO Method with Modified Infill Criterion

The resulting GPU accelerated Monte Carlo-based multi-objective EGO algorithm, namely GMOEGO, can be summarized as Algorithm 4, as follows. In the present work, we use the Latin Hypercube Sampling (LHS) [43] is selected as the DOE method (see step 1) for its space filling properties.