A Novel Meta-Heuristic Edge Server Placement Algorithm for Improving Service Quality

Abstract

Edge server placement (ESP) is a critical determinant of service quality in edge–cloud computing systems, yet existing solutions often neglect the inherent collaboration between edge and cloud, leading to suboptimal performance under dynamic workloads. To address this gap, this paper proposes a novel meta-heuristic edge server placement algorithm based on the Coati Optimization Algorithm (COA). We first formulate the ESP problem as a constrained binary nonlinear programming model that explicitly incorporates edge–cloud collaboration, aiming to minimize the average request processing delay. The proposed COA-based solver features a compact one-dimensional encoding scheme that simultaneously represents server placement and request offloading decisions, a tailored boundary correction mechanism to enforce coverage and atomicity constraints, and a balanced exploration–exploitation strategy inspired by coatis’ natural hunting and escape behaviors. Extensive simulations are conducted, comparing the proposed algorithm against ten representative heuristic and meta-heuristic algorithms, including GA, PSO, DE, GWO, and their variants. The experimental results demonstrate that our algorithm significantly outperforms all compared methods in terms of the mean, minimum, and standard deviation of the overall average processing delay. Specifically, it achieves a 98.2% reduction in the mean delay relative to suboptimal algorithms while maintaining near-zero variance, confirming its effectiveness, efficiency, and robustness. The proposed algorithm provides a promising solution for service providers to enhance quality of service through optimal edge server deployment and request offloading under edge–cloud collaboration.

1. Introduction

In recent years, with the rapid development of technologies such as the Internet of Things (IoT) and 5G, a plethora of latency-sensitive applications have emerged, posing significant challenges to the traditional cloud computing paradigm. Edge computing, which deploys computational and storage resources at the network edge, enables low-latency, high-bandwidth services near data sources and has become a critical infrastructure supporting novel applications [1]. In an edge computing environment, the physical placement of edge servers directly impacts user request processing delay, server load balancing, and operational costs. However, the edge does not exist in isolation; its ability to collaborate with cloud centers is a core factor determining service quality. Therefore, how to scientifically deploy edge servers while considering edge–cloud collaboration has become a key issue for both academia and industry.

The edge server placement problem (ESPP) is typically modeled as selecting an optimal subset from candidate locations to deploy servers, subject to constraints such as server capacity and coverage range, with the objective of minimizing the average processing delay of user requests [2]. This problem is inherently a discrete combinatorial optimization problem with an NP-hard nature [3]. However, existing research often models the edge layer as an independent system, focusing solely on the processing delay of requests handled locally at edge servers. This approach overlooks the collaborative scenario where requests must be offloaded to the cloud center for processing when edge servers are overloaded or have insufficient resources. This simplification leads to a disconnect between placement decisions and the actual operational mechanism of edge–cloud collaboration. Consequently, the placement solutions derived from such models are often suboptimal in practice, failing to achieve theoretical optimality during real-world operation. Therefore, integrating edge–cloud collaboration mechanisms into the problem modeling phase to construct an optimization model that more accurately reflects actual operational patterns is a critical breakthrough point for enhancing the practicality of server placement solutions.

Recently, researchers have proposed various heuristic algorithms (e.g., greedy algorithms, simulated annealing) and meta-heuristic algorithms (e.g., Particle Swarm Optimization, Genetic Algorithms, Ant Colony Optimization) to address ESPP. While these methods can achieve relatively good solutions to some extent, they suffer from two main shortcomings. First, some algorithms converge slowly, are prone to getting trapped in local optima, and exhibit significant performance degradation when handling large-scale instances. Second, the vast majority of studies neglect the edge–cloud collaboration mechanism when designing optimization objectives. They fail to accurately model the complete path delay for requests that cannot be processed at the edge and must be offloaded to the cloud center. As a result, the solutions derived from these algorithms perform poorly under actual edge–cloud collaborative operations. Hence, there is an urgent need to investigate new optimization algorithms that can incorporate edge–cloud collaboration characteristics to overcome the performance bottlenecks of existing methods.

The Coati Optimization Algorithm (COA) is a novel meta-heuristic algorithm proposed in recent years, inspired by the cooperative hunting and predator evasion behaviors of coatis in nature [4]. By simulating the exploration and exploitation processes of a coati population within the search space, COA offers advantages such as few parameters, a simple structure, fast convergence, and strong global search capability. It has demonstrated excellent performance on various classic benchmark functions and engineering optimization problems. Based on this, this paper makes the first attempt to apply COA to the edge server placement problem. Innovatively, we incorporate the edge–cloud collaboration mechanism into the problem modelling phase by integrating the full-path delay into the optimization objective, encompassing both local edge processing and cloud center processing for offloaded requests. The aim is to leverage COA’s powerful optimization capabilities to solve this more practically relevant combinatorial optimization challenge, thereby reducing end-to-end request processing delay and enhancing service quality. Comparative experimental results validate that the proposed COA-based placement strategy, which integrates edge–cloud collaboration, consistently outperforms solutions from ten representative heuristic and meta-heuristic algorithms across various scenarios, demonstrating its effectiveness and potential. In summary, the main contributions of this paper are as follows:

• The ESPP is formally modelled as a binary nonlinear programming problem that incorporates edge–cloud collaboration, aiming to minimize the average request processing delay under practical constraints such as server capacity and coverage range.
• The Coati Optimization Algorithm (COA) is adapted and applied to solve the edge server placement problem for the first time. To the best of our knowledge, this study represents the initial attempt to employ COA in this domain, thereby broadening the algorithm’s application scope and offering a novel perspective on edge server placement optimization.
• Extensive simulations are carried out to evaluate the performance of COA against ten representative heuristic and meta-heuristic algorithms across a variety of scenarios. The experimental results consistently show that COA outperforms the compared methods in terms of solution quality, demonstrating its effectiveness and robustness for edge server placement.

The remainder of this paper proceeds as follows. In Section 2, we formulate the edge server placement problem. Section 3 details the COA-based optimization method. Section 4 presents and discusses the experimental results. Section 5 surveys related work, and finally, Section 6 concludes the paper.

2. Problem Formulation

In this paper, we consider an edge–cloud system as depicted in Figure 1, which comprises multiple user devices (UDs), several edge computing centers (ECs), and a central cloud. Each EC is equipped with a base station (BS) and may host one or more edge servers (ESs). Note that, due to the one-to-one correspondence between ECs and BSs, the terms EC and BS are used interchangeably throughout this paper. Requests generated by UDs can be processed either at an EC equipped with at least one ES or by the remote cloud. The core problem addressed in this paper is two-fold: determining the optimal placement of ESs and deciding where each request should be processed. This is precisely the decision-making process that service providers face when establishing or upgrading their edge computing infrastructure.

Figure 1. The environment of edge–cloud. (BS—base station; EC—edge computing center; ES—edge server; UD—user device).

2.1. System Model

In the edge–cloud system under consideration, there are U (UDs) and B BSs. To establish or upgrade the infrastructure, the service provider has procured E ESs to be placed at a subset of the B BSs. For the i-th UD, its request is characterized by an input data size of $d_i$ and requires $m_i$ computing resources for processing. In this paper, we assume that each user device (UD) generates one request at any given time. This assumption is commonly adopted in edge computing research to simplify modeling and analysis without the loss of generality. Moreover, the assumption does not compromise applicability, as scenarios involving multiple requests can be handled by treating them as sequential arrivals or by logically representing a UD with concurrent requests as multiple virtual UDs. The j-th BS provides a wireless data transfer rate $b_j$ for receiving data from UDs. Due to the limited wireless coverage of each BS, a UD can only transmit its request to a BS within its communication range. We use a binary indicator $a_{i,j}$ to denote the coverage relationship between BSs and UDs, where $a_{i,j}=1$ indicates that the i-th UD is covered by the j-th BS, i.e., the distance between them is less than the maximum wireless transmission range of the BS; otherwise, $a_{i,j}=0$. For the E edge servers, the computing capacity of the k-th ES is denoted by $c_k$. The cloud, on the other hand, is assumed to provide a data transfer rate of W and a computing resource amount of C for each request processed.

In this paper, we assume that each UD generates exactly one request at any given time. This assumption is common in static edge server placement studies to simplify modeling and focus on the core optimization problem. As noted by the reviewer, this may oversimplify scenarios with bursty or concurrent traffic patterns. However, this assumption does not fundamentally restrict the applicability of our model: a scenario where a single UD issues multiple concurrent requests can be equivalently transformed by treating each request as originating from an independent virtual UD that shares the same location and coverage constraints. This transformation preserves the combinatorial structure of the problem while keeping the formulation tractable. Therefore, our model can be extended to more general workloads without changing the underlying optimization framework.

A solution to the edge server placement problem (ESPP) involves two key decisions: determining the BS with which each ES is associated, and deciding whether each request is processed at the edge (by an EC) or by the cloud. To formally represent a solution, we introduce two sets of binary variables, denoted by $x_{j,k}$ and $y_{i,j}$. The variable $x_{j,k}$ indicates whether the k-th ES is placed at the j-th EC, as defined in Equation (1). The variable $y_{i,j}$ specifies whether the request from the i-th UD is processed at the EC associated with the j-th BS, as defined in Equation (2).

$$x_{j,k}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}k\mathrm{th}\mathrm{ES}\mathrm{is}\mathrm{placed}\mathrm{in}j\mathrm{th}\mathrm{BS}\hfill \\ 0,\hfill & \mathrm{else}\hfill \end{array}\right.$$

(1)

$$y_{i,j}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}i\mathrm{th}\mathrm{UD}’\mathrm{s}\mathrm{request}\mathrm{is}\mathrm{processed}\mathrm{in}j\mathrm{th}\mathrm{EC}\hfill \\ 0,\hfill & \mathrm{if}i\mathrm{th}\mathrm{UD}’\mathrm{s}\mathrm{request}\mathrm{is}\mathrm{forward}\mathrm{to}\mathrm{the}\mathrm{cloud}\hfill \end{array}\right.$$

(2)

For each ES, it can be placed at only one EC. Therefore, the constraint in (3) must be satisfied for the k-th ES, meaning that only one variable in the set $\left\{x_{j,k}\right|j=1,\dots ,B\}$ can take the value of one.

$${\displaystyle \sum _{j=1}^B}{x}_{j,k}=1$$

(3)

Meanwhile, each request generated by a UD can be processed either at exactly one EC or at the cloud. Thus, inequality (4) holds for the i-th UD. Specifically, when a request is offloaded to the cloud, we have $y_{i,j}=0$ for all j, i.e., ${\sum }_{j=1}^B{y}_{i,j}=0$.

$${\displaystyle \sum _{j=1}^B}{y}_{i,j}\le 1$$

(4)

Moreover, at the edge side, a request can be processed by an EC only if that EC is equipped with at least one ES. Consequently, Equation (5) imposes the following condition for the i-th UD and j-th EC: $y_{i,j}$ must be zero when no ES is placed at the j-th EC (i.e., ${\sum }_{k=1}^E{x}_{j,k}=0$), and can be either zero or one when at least one ES is present (${\sum }_{k=1}^E{x}_{j,k}\le 1$).

$$y_{i,j}\le {\displaystyle \sum _{k=1}^E}{x}_{j,k}$$

(5)

In addition, a request can only be offloaded to an EC that covers the corresponding UD. Hence, Equation (6) enforces that for the i-th UD and j-th EC, $y_{i,j}=0$ if $a_{i,j}=0$ and $y_{i,j}\le 1$ if $a_{i,j}=1$.

$$y_{i,j}\le a_{i,j}$$

(6)

2.2. Delay Model

Each request can be processed either at the edge or in the cloud. In what follows, we formulate the processing delay for these two cases, respectively.

2.2.1. Processing in Edge

When a request is offloaded to and processed at an EC, its processing delay consists of two components: the data transmission delay from the UD to the EC, and the computing delay incurred at the ESs hosted by that EC. For the j-th EC, the requests to be processed originate from the set of UDs $\{i-\mathrm{th}\mathrm{UD}\mid y_{i,j}=1\}$. In this paper, we assume that the wireless networks of BSs employ Orthogonal Frequency Division Multiplexing (OFDM), ensuring that data transmissions from different UDs do not interfere with one another. The total amount of data to be transmitted from UDs to the j-th EC is ${\sum }_{i=1}^U(y_{i,j}·d_i)$. Consequently, the accumulated transmission delay for all requests processed by the j-th EC is given by ${\sum }_{i=1}^U(y_{i,j}·d_i)/b_j$.

The computing capacity of the k-th ES is denoted by $c_k$. The set of ESs placed at the j-th EC is $\{k-\mathrm{th}\mathrm{ES}\mid x_{j,k}=1\}$, and thus the total computing capacity available at the j-th EC is ${\sum }_{k=1}^E(x_{j,k}·c_k)$. Since the accumulated computational workload of requests processed at the j-th EC is ${\sum }_{i=1}^U(y_{i,j}·m_i)$, the accumulated computing delay for these requests is ${\sum }_{i=1}^U(y_{i,j}·m_i)/{\sum }_{k=1}^E(x_{j,k}·c_k)$.

By combining these two components, the total delay $l_j^{\left(E\right)}$ incurred by processing all requests offloaded to the j-th EC can be formulated as in Equation (7).

$$l_j^{\left(E\right)}={\displaystyle \frac{{\sum }_{i=1}^U(y_{i,j}·d_i)}{b_j}}+{\displaystyle \frac{{\sum }_{i=1}^U(y_{i,j}·m_i)}{{\sum }_{k=1}^E(x_{j,k}·c_k)}}$$

(7)

2.2.2. Processing in the Cloud

When an EC experiences an excessive number of requests, its limited computing resources may lead to degraded service quality. In such cases, some requests can be offloaded to the cloud to take advantage of its abundant resource capacity. For a request offloaded to the cloud, its processing delay also consists of two components: the data transmission delay and the computing delay. The data transmission delay is the time required to transfer the input data from the corresponding UD to the cloud, which is given by $d_i/W$ for the request from the i-th UD. The computing delay for processing this request in the cloud is $m_i/C$. Benefiting from the virtually unlimited resources of the cloud, all requests are processed without mutual interference. Note that when the request from the i-th UD is offloaded to the cloud, we have $y_{i,j}=0$ for all $j=1,\dots ,B$, which is equivalent to ${\prod }_{j=1}^B(1-y_{i,j})=1$. Therefore, for all requests processed in the cloud, the accumulated data transmission delay is ${\sum }_{i=1}^U({\prod }_{j=1}^B(1-y_{i,j})·d_i)/W$, and the accumulated computing delay is ${\sum }_{i=1}^U({\prod }_{j=1}^B(1-y_{i,j})·m_i)/C$. Consequently, the total processing delay $l^{\left(C\right)}$ for all requests offloaded to the cloud can be formulated as in Equation (8).

$$\begin{array}{ccc}\hfill l^{\left(C\right)}=& {\displaystyle \frac{{\sum }_{i=1}^U({\prod }_{j=1}^B(1-y_{i,j})·d_i)}{W}}\hfill & + {\displaystyle \frac{{\sum }_{i=1}^U({\prod }_{j=1}^B(1-y_{i,j})·m_i)}{C}}\end{array}$$

(8)

2.2.3. Overall Delay

Based on the two cases discussed above, the overall average processing delay in the edge–cloud system is formulated as in Equation (9), where ${\sum }_{j=1}^S{l}_j^{\left(E\right)}$ denotes the accumulated delay of requests processed at the edge, and $l^{\left(C\right)}$ denotes that of requests processed in the cloud. Therefore, the total accumulated delay for all requests in the system is given by ${\sum }_{j=1}^S{l}_j^{\left(E\right)}+l^{\left(C\right)}$.

$$L={\displaystyle \frac{1}{U}}·({\displaystyle \sum _{j=1}^B}{l}_j^{\left(E\right)}+l^{\left(C\right)})$$

(9)

2.3. Problem Model

Based on the above formulations, the edge server placement problem (ESPP) is modeled as the optimization problem in Equation (10), which minimizes the overall average processing delay to enhance service quality. Constraint (11) ensures that each edge server is placed at exactly one base station (or edge computing center). Constraint (12) guarantees that each request is processed either at exactly one EC or offloaded to the cloud. Constraints (13) and (14) specify that a request can be processed at an EC only if the corresponding base station covers the user device and the EC is equipped with at least one edge server. Finally, Constraints (15) and (16) define the binary nature of the decision variables for server placement and request offloading.

$$\begin{array}{cc}\hfill & \mathrm{minimizing}L,\hfill \end{array}$$

(10)

$$\begin{array}{cc}\hfill & {\displaystyle \sum _{j=1}^B}{x}_{j,k}=1,k=1,\dots ,E,\hfill \end{array}$$

(11)

$$\begin{array}{cc}\hfill & {\displaystyle \sum _{j=1}^B}{y}_{i,j}\le 1,i=1,\dots ,U,\hfill \end{array}$$

(12)

$$\begin{array}{cc}\hfill & y_{i,j}\le {\displaystyle \sum _{k=1}^E}{x}_{j,k},i=1,\dots ,U,j=1,\dots ,B,\hfill \end{array}$$

(13)

$$\begin{array}{cc}\hfill & y_{i,j}\le a_{i,j},i=1,\dots ,U,j=1,\dots ,B,\hfill \end{array}$$

(14)

$$\begin{array}{cc}\hfill & x_{j,k},\in \{0,1\},j=1,\dots ,B,k=1,\dots ,E,\hfill \end{array}$$

(15)

$$\begin{array}{cc}\hfill & y_{i,j}\in \{0,1\},i=1,\dots ,U,j=1,\dots ,B.\hfill \end{array}$$

(16)

Obviously, the ESPP is a binary nonlinear programming problem, which is generally NP-Hard. Deriving the optimal solution would require exponential time complexity, making it impractical for real-world scenarios with large-scale deployments. Therefore, an efficient approximation or meta-heuristic approach is essential. In the next section, we employ the Coati Optimization Algorithm (COA), a state-of-the-art meta-heuristic, to solve the ESPP in a polynomial time complexity. The Coati Optimization Algorithm is particularly well-suited for this problem due to its strong global search capability, fast convergence speed, and simplicity in parameter tuning. Inspired by the cooperative behaviors of coatis in nature, COA effectively balances exploration and exploitation during the optimization process, enabling it to escape local optima and find high-quality solutions in complex solution spaces. These advantages make COA a promising candidate for addressing the combinatorial complexity inherent in the ESPP.

2.4. Formulation Extension

The binary nonlinear programming model presented previously captures the core ESPP under static conditions with edge–cloud collaboration. However, practical deployments often involve dynamic user mobility, time-varying workloads, multiple conflicting objectives, and heterogeneous edge resources. The current formulation can be extended along several dimensions without altering its essential structure.

2.4.1. Dynamic User Mobility and Time-Varying Requests

Let $a_{i,j}\left(t\right)$ denote the coverage indicator at time t, and $d_i\left(t\right)$ and $m_i\left(t\right)$ the request characteristics. The system then evolves over a finite horizon $t=1,\dots ,T$. A natural extension is to adopt a receding horizon control framework: at each decision epoch $\tau$, the operator solves the static ESPP using the predicted parameters for the next window $[\tau ,\tau +\delta ]$. The solution (placement and offloading decisions) is applied for that window, after which the problem is re-solved with updated predictions. The same COA solver can be used repeatedly, optionally warm started from the previous solution to reduce computation. Alternatively, a multi-timescale formulation can separate slow (server placement) and fast (request offloading) decisions, similar to the stochastic programming framework in [5].

2.4.2. Multi-Objective Optimization

Service providers often need to balance delay against other criteria such as energy consumption, capital expenditure (CAPEX), operational cost (OPEX), or load fairness. The current model can be extended to a multi-objective formulation by replacing the scalar objective (average delay) with a vector $F=(f_{delay},f_{energy},f_{cost},\dots )$. For example, energy consumption can be expressed as

$$f_{energy}={\displaystyle \sum _{j=1}^B}(P_{base}·1_{[{\sum }_k{x}_{j,k}>0]}+{\displaystyle \sum _{k=1}^E}{x}_{j,k}·P_k^{server})+\sum _{i,j}{y}_{i,j}·P^{tx}·{\displaystyle \frac{d_i}{b_j}}$$

(17)

where $P_{base}$ is the fixed power of an active base station, $P_k^{server}$ the server power, and $P^{tx}$ the transmission energy per bit. The overall objective becomes $minF$, with Pareto optimality as the solution concept. The COA encoding remains unchanged; only the fitness evaluation is replaced by a Pareto based ranking (e.g., non-dominated sorting) combined with crowding distance. This yields a multi-objective optimization problem where the Pareto frontier captures the fundamental trade-offs among conflicting objectives (e.g., delay, energy consumption, and deployment cost).

2.4.3. Heterogeneous Edge Devices

The current model already allows servers to have different capacities $c_k$. To capture further heterogeneity (e.g., different power profiles, memory, specialized accelerators), we can assign each server a type with corresponding attributes $(c_k,P_k^{server},memor{y}_k,GP{U}_k)$. The encoding and constraints are unchanged, but the objective can incorporate a preference for more efficient devices, e.g., by adding a term that penalizes energy inefficient server activation.

All extensions preserve the core binary decision variables and the COA operator design, making them incremental rather than disruptive. We leave these extensions as promising for future work and focus in this paper on the static, single-objective, homogeneous device case to clearly demonstrate the benefits of COA for edge–cloud collaborative ESPP.

3. Method

This section presents the proposed Coati Optimization Algorithm (COA) for solving the edge server placement problem (ESPP). We first describe the encoding scheme used to represent candidate solutions, followed by the fitness function, the detailed algorithmic steps, and finally the complexity analysis.

3.1. Solution Representation

A candidate solution for the ESPP must encode two types of decisions: (1) the placement of each edge server (ES) to a base station (BS), and (2) the offloading decision for each user equipment (UD) request. To efficiently represent these decisions while naturally satisfying the problem constraints, we adopt a one-dimensional vector of length $E+U$, where E is the number of ESs and U is the number of UDs. The structure is detailed as follows.

3.1.1. Placement Part (First E Dimensions)

For the k-th ES ($k=1,\dots ,E$), the value $p_k\in \{1,2,\dots ,B\}$ denotes the index of the BS where this ES is deployed. This encoding directly corresponds to the binary decision variables $x_{j,k}$ by setting $x_{j,k}=1$ if and only if $p_k=j$. Since each ES must be placed at exactly one BS, this representation inherently satisfies the atomicity constraint ${\sum }_{j=1}^B{x}_{j,k}=1$.

3.1.2. Offloading Part (Last U Dimensions)

For the i-th UD ($i=1,\dots ,U$), the value $q_i\in \{0,1,\dots ,B\}$ indicates where the request is processed:

• $q_i=0$: The request is offloaded to the cloud.
• $q_i=j$ (with $j\in \{1,\dots ,B\}$): The request is processed at the edge computing center (EC) associated with BS j, i.e., $y_{i,j}=1$.

The encoding must respect the coverage constraint: a request can only be processed at BS j if $a_{i,j}=1$. Therefore, the feasible set for $q_i$ is $\left\{0\right\}\cup \{j\mid a_{i,j}=1\}$. This ensures that the corresponding binary variables $y_{i,j}$ satisfy ${\sum }_{j=0}^B{y}_{i,j}=1$ (with $y_{i,0}$ representing cloud processing) and $y_{i,j}=0$ when $a_{i,j}=0$.

This representation avoids invalid solutions and reduces the need for complex repair mechanisms during optimization.

We note that the proposed encoding scheme can be readily extended to multi-objective formulations. For example, additional objectives such as deployment cost, energy consumption, or load fairness can be incorporated by constructing a composite fitness function (e.g., weighted sum or Pareto dominance) while keeping the same decision variables (server placement and request offloading). This flexibility enhances the practical relevance of our approach. A systematic multi-objective investigation, including the selection of appropriate Pareto-based ranking and diversity preservation mechanisms, is left as a promising exploration for future work.

3.2. Fitness Function

The fitness of a candidate solution is evaluated as the overall average processing delay defined in Equation (9). Given a specific placement and offloading decisions, we first compute the accumulated delay at each EC j as $l_j^{\left(E\right)}$ using Equation (7) and the cloud delay $l^{\left(C\right)}$ using Equation (8). The average delay is then

$$fitness={\displaystyle \frac{1}{U}}·({\displaystyle \sum _{j=1}^B}{l}_j^{\left(E\right)}+l^{\left(C\right)})$$

(18)

Since the objective is to minimize the average delay, a lower fitness value indicates a better solution.

3.3. The COA Algorithm for ESPP

The Coati Optimization Algorithm (COA) is a meta-heuristic inspired by the cooperative foraging and predator evasion behaviors of coatis. It maintains a population of N individuals (solutions) and iteratively improves them through two main phases: exploration (mimicking hunting) and exploitation (mimicking escape from predators). The algorithm adapts COA to handle the discrete search space of the ESPP, as outlined in Algorithm 1 and detailed as follows.

The proposed COA-based solver for the ESPP follows an iterative population-based search procedure inspired by the cooperative behaviors of coatis. The algorithm begins by initializing a population of N candidate solutions, each represented as a vector of length $E+U$ according to the encoding scheme described in Section 3.1. For each individual, the first E dimensions are randomly assigned integer values from one to B, representing the BS indices where each ES is placed. The remaining U dimensions are randomly assigned feasible offloading decisions, where each $q_i$ is drawn uniformly from the set $0\cup j\mid a_{i,j}=1$, ensuring that coverage constraints are satisfied from the outset. After initialization, the fitness of every individual is evaluated using the average processing delay defined in Equation (18), and the global best solution $X_{\mathrm{best}}$ is recorded.

The main loop of the algorithm runs for a predefined number of iterations $T_{max}$. Each iteration consists of two sequential phases: exploration (hunting) and exploitation (escape), mimicking the natural behavior of coatis.

In the exploration phase, the current population is randomly partitioned into two groups: hunters and prey. For each hunter individual $X_h$, a prey individual $X_{\mathrm{prey}}$ is randomly selected from the prey group. The hunter then updates its position according to the following rule:

$$X_h^{new}=X_h+r·(X_{prey}-I\odot X_h)$$

(19)

where r is a random number uniformly distributed in $[0, 1]$, I is a vector of the same dimension as $X_h$ with each element randomly chosen from the set $1,2$, and ⊙ denotes element-wise multiplication. This update mechanism allows the hunter to move toward the prey while incorporating stochastic perturbations, promoting global exploration of the search space. After computing the new position, a boundary correction procedure is applied to ensure that all dimensions lie within their feasible domains. Specifically, for placement dimensions $p_k$, the value is rounded to the nearest integer and clamped to $[1, B]$; for offloading dimensions $q_i$, the real value is mapped to the nearest feasible discrete option: if the value is close to zero, it is set to zero and otherwise it is set to the closest BS index j for which $a_{i,j}=1$ (with ties broken randomly). The fitness of the corrected new position is then evaluated, and if it is better than the original hunter’s fitness, the hunter is replaced; otherwise, the hunter remains unchanged.

Algorithm 1 COA-based ESPP Solver

Require:  Population size N, max iterations $T_{max}$, problem parameters (B, E, U, $a_{i,j}$, $d_i$, $m_i$, $c_k$, $b_j$, W, C) Ensure:  Best solution $X_{\mathrm{best}}$ and its fitness $f_{\mathrm{best}}$                                          ▷Initialization:   1: Generate initial population $\mathcal{P}=\{X_1,\dots ,X_N\}$ with random feasible encodings:   2: for $k=1$ to E do   3:    $p_k\leftarrow \mathrm{Uniform}\{1,\dots ,B\}$   4: end for   5: for $i=1$ to U do   6:    $q_i\leftarrow \mathrm{Uniform}\left\{0\right\}\cup \{j\mid a_{i,j}=1\}$   7: end for   8: Evaluate fitness $f\left(X\right)$ for each $X\in \mathcal{P}$ using Equation (18)   9: $X_{\mathrm{best}}\leftarrow arg{min}_{X\in \mathcal{P}}f\left(X\right)$, $f_{\mathrm{best}}\leftarrow f\left(X_{\mathrm{best}}\right)$ 10: for $t=1$ to $T_{max}$ do 11:      Randomly shuffle $\mathcal{P}$ and split into two equal groups: hunters $\mathcal{H}$ and prey ${\mathcal{P}}_{\mathrm{prey}}$            ▷ Exploration phase (hunting) 12:     for each $X_h\in \mathcal{H}$ do 13:         Select a distinct $X_{\mathrm{prey}}\in {\mathcal{P}}_{\mathrm{prey}}$ (without replacement) 14:         Generate random vector I of length $E+U$ with entries $\in \{1,2\}$ uniformly 15:         $r\sim \mathcal{U}(0,1)$ 16:         for $d=1$ to $E+U$ do 17:             $X_h^{\mathrm{new}}\left[d\right]=X_h\left[d\right]+r·(X_{\mathrm{prey}}\left[d\right]-I\left[d\right]·X_h\left[d\right])$ 18:         end for 19:         Apply boundary correction to $X_h^{\mathrm{new}}$ 20:         Evaluate $f\left(X_h^{\mathrm{new}}\right)$ 21:         if $f\left(X_h^{\mathrm{new}}\right)<f\left(X_h\right)$ then 22:            $X_h\leftarrow X_h^{\mathrm{new}}$, update fitness 23:         end if 24:     end for                                      ▷Exploitation phase (escape) 25:     for each $X_n\in \mathcal{P}$ do 26:         Define neighborhood $\mathcal{N}\left(X_n\right)$ as the three nearest individuals in $\mathcal{P}$ (Euclidean distance) 27:         $X_{\mathrm{local}}=arg{min}_{X\in \mathcal{N}\left(X_n\right)\cup \left\{X_{\mathrm{best}}\right\}}f\left(X\right)$ 28:         $r\sim \mathcal{U}(0,1)$ 29:         for $d=1$ to $E+U$ do 30:            $X_n^{\mathrm{new}}\left[d\right]=X_n\left[d\right]+(1-2r)·(X_{\mathrm{local}}\left[d\right]-X_n\left[d\right])$ 31:         end for 32:         Apply boundary correction to $X_n^{\mathrm{new}}$ 33:         Evaluate $f\left(X_n^{\mathrm{new}}\right)$ 34:         if $f\left(X_n^{\mathrm{new}}\right)<f\left(X_n\right)$ then 35:            $X_n\leftarrow X_n^{\mathrm{new}}$ 36:         end if 37:     end for                                         ▷Global best update 38:     $X_{\mathrm{cur}}=arg{min}_{X\in \mathcal{P}}f\left(X\right)$ 39:     if $f\left(X_{\mathrm{cur}}\right)<f_{\mathrm{best}}$ then 40:        $X_{\mathrm{best}}\leftarrow X_{\mathrm{cur}}$, $f_{\mathrm{best}}\leftarrow f\left(X_{\mathrm{cur}}\right)$ 41:     end if 42: end for 43: return$X_{\mathrm{best}}$, $f_{\mathrm{best}}$

In the exploitation phase, each individual $X_n$ in the population (including those updated in the exploration phase) attempts to improve its position by moving toward a local best solution $X_{\mathrm{local}}$, which can be either the best individual in its neighborhood or the global best $X_{\mathrm{best}}$ found so far. The update rule for this phase is

$$X_n^{new}=X_n+(1-2r)·(X_{local}-X_n)$$

(20)

where r is again a random number in $[0, 1]$. This formulation allows the individual to explore positions around the local best, effectively refining the solution in promising regions. After the update, the same boundary correction and fitness evaluation are performed, and the individual is replaced if the new position yields a lower (better) fitness value.

Following the exploitation phase, the global best solution $X_{\mathrm{best}}$ is updated if any individual in the current population achieves a fitness value lower than the current best. The algorithm then proceeds to the next iteration until the maximum number of iterations $T_{max}$ is reached. Finally, the best found solution $X_{\mathrm{best}}$ is returned as the output, representing the optimal or near-optimal ES placement and request offloading decisions for the given ESPP instance.

This iterative process balances exploration and exploitation through the two distinct phases, enabling the COA to effectively navigate the complex combinatorial search space of the ESPP while maintaining feasibility through the dedicated boundary correction mechanism.

3.3.1. Boundary Correction

For placement dimensions ($p_k$), if the updated value is not an integer in $[1, B]$, we round it to the nearest integer and clamp it to $[1, B]$. For offloading dimensions ($q_i$), we map the real value to the nearest feasible discrete option: if the value is close to zero, set $q_i=0$; otherwise, find the closest j with $a_{i,j}=1$ (ties broken randomly). This ensures feasibility after each update.

3.3.2. Time Complexity

The initialization phase requires $O(N·(E+U\left)\right)$ operations to randomly generate feasible solutions for all individuals. Within each iteration, both the exploration and exploitation phases incur $O(N·(E+U\left)\right)$ time, as each individual update involves vector operations of length $E+U$. The fitness evaluation, which computes accumulated edge delays $l_j^{\left(E\right)}$ and cloud delay $l^{\left(C\right)}$, can be optimized by precomputing aggregated sums, resulting in $O(U+E)$ per evaluation. Since each individual undergoes fitness evaluation in both phases, the total per-iteration complexity remains $O(N·(E+U\left)\right)$. Therefore, over $T_{max}$ iterations, the overall time complexity of the proposed COA-based solver is $O(T_{max}·N·(E+U))$, demonstrating linear scalability with respect to problem size and population.

Note that while the asymptotic complexity is linear in the problem dimension, the absolute runtime grows with $E+U$. For extremely large instances (e.g., $U>{10}^5$), further optimizations such as sparse fitness evaluation or dimension reduction may be required.

4. Performance Evaluation

To evaluate the performance of the proposed COA-based algorithm, extensive simulations are conducted under a realistic edge–cloud environment, referring to related works [6,7,8,9]. The simulation parameters are configured as follows. The network comprises $B=50$ BSs and one cloud. The service provider plans to deploy $E=10$ ESs across these BSs. A total of $U=1000$ UDs are randomly distributed within the coverage area, and each UD generates a single request at a time. The input data size of each request, denoted by $d_i$, is uniformly drawn from the range $[1, 3]$ MB, while the required computing workload $m_i$ follows a uniform distribution between 1 and 100 million instructions (MI). The computing capacity of each ES, $c_k$, is randomly assigned between 10 and 100 million instructions per second (MIPS). The cloud is assumed to have abundant resources, providing a computing capacity $C=100$ MIPS and a data transfer rate $W=10$ Mbps for each request. Each BS provides a wireless data rate $b_j$ uniformly distributed between 10 and 100 Mbps for receiving uplink data from UDs. Every UD is randomly covered by a BS.

We compare the proposed COA with a set of representative heuristic and meta-heuristic algorithms, which are briefly described as follows:

• AllCloud: All requests are offloaded to the cloud for processing, without using any edge servers.
• AllEdge: All requests are processed at the edge, assuming sufficient edge resources are always available (though this may lead to overload).
• RAND: A random search method that generates random feasible solutions. It serves as a baseline to demonstrate the effectiveness of iterative improvement in meta-heuristics.
• MLF (Most Load First): A greedy heuristic that prioritizes placing ESs on the BSs with the highest total computational load from the UDs they cover.
• GA (Genetic Algorithm): A classic evolutionary algorithm using selection, crossover, and mutation.
• DE (Differential Evolution): A population-based stochastic optimization method that uses vector differences.
• PSO (Particle Swarm Optimization): A swarm intelligence algorithm inspired by social behavior of birds.
• GWO (Grey Wolf Optimizer) [10]: A meta-heuristic mimicking the leadership hierarchy and hunting mechanism of grey wolves.
• GWOA (Hybrid Grey Wolf–Whale Optimization Algorithm) [11]: A hybrid algorithm combining GWO and Whale Optimization Algorithm.
• MGTO (Modified Gorilla Troops Optimizer) [12]: An improved version of the Gorilla Troops Optimization algorithm.
• FOX [13]: A novel meta-heuristic inspired by the foraging behavior of foxes.
• PSOGA [14]: A hybrid algorithm that integrates PSO and GA to balance exploration and exploitation.

For all meta-heuristic algorithms (including COA, GA, DE, PSO, GWO, GWOA, MGTO, FOX, and PSOGA), we set the population size to $N=100$ and the maximum number of iterations to $T_{max}=100$ to ensure a fair comparison. Other algorithm-specific parameters are adopted from their default configurations in the MEALPY 3.0.3 library [15,16,17], a well-established toolbox for meta-heuristic optimization. Each experiment is repeated 20 independent times with different random seeds, and the results are reported in terms of the mean and standard deviation of the overall average request processing delay. This setup allows a comprehensive evaluation of the proposed COA against a wide range of state-of-the-art algorithms under identical conditions.

To comprehensively evaluate the performance of the proposed algorithm, we design the following experimental procedure. In each run, an edge–cloud simulation system is first randomly generated according to the aforementioned parameter setting. Subsequently, all comparison algorithms, including AllCloud, AllEdge, RAND, MLF, GA, DE, PSO, GWO, GWOA, MGTO, FOX, PSOGA, and the proposed COA, are executed on the same generated environment, and the overall average processing delay achieved by each algorithm is recorded. To ensure statistical reliability, this process is independently repeated 20 times, each with a different random seed to generate varying simulation environments. For each algorithm, we compute three key metrics from the 20 experimental results: the mean reflects the average solution quality and is used to evaluate effectiveness; the minimum (i.e., the best result among the 20 runs) indicates the algorithm’s optimization potential under ideal conditions, serving as a measure of efficiency, and the standard deviation captures the fluctuation across different environments, which assesses stability. By comparing these metrics comprehensively, we can systematically validate the superiority of the proposed COA method in solving the edge server placement problem.

The detailed experimental results under the configuration of 10 ESs, 50 BSs, and 1000 UDs are shown in Table 1, while the mean, minimum, and standard deviation of the measured overall average processing delay are visualized in Figure 2, Figure 3, and Figure 4, respectively. As shown in these results, the proposed COA algorithm outperforms all compared algorithms across all three evaluation metrics. Specifically, COA achieves the lowest average delay, minimum delay, and standard deviation, whereas the corresponding metrics of other algorithms are generally higher and exhibit greater fluctuations. This overall trend preliminarily indicates that COA possesses outstanding solution capability and stability when addressing the complex combinatorial optimization problem of edge server placement.

Table 1. Processing delays (seconds) for 20 repeated executions under the configuration of 10 ESs, 50 BSs, and 1000 UDs.

	AllCloud	AllEdge	RAND	MLF	GA	DE	PSO	GWO	GWOA	MGTO	FOX	PSOGA	COA
1	0.6997	0.2561	0.4539	0.2379	0.0888	0.3565	0.3912	0.3994	0.4051	0.2913	0.3902	0.0888	0.0024
2	0.7008	0.2852	0.5366	0.2462	0.1129	0.3537	0.4290	0.4218	0.4115	0.2885	0.4222	0.1129	0.0015
3	0.6981	0.2415	0.4606	0.2197	0.0894	0.3514	0.3934	0.3951	0.3697	0.3018	0.3511	0.0894	0.0010
4	0.7103	0.2200	0.5239	0.2379	0.0938	0.3450	0.4062	0.4151	0.4206	0.2135	0.3626	0.0938	0.0014
5	0.6995	0.2278	0.4580	0.2256	0.0922	0.3437	0.3913	0.3695	0.3998	0.2695	0.3859	0.0922	0.0018
6	0.6924	0.2847	0.4555	0.2352	0.1042	0.3559	0.4007	0.4208	0.4035	0.2984	0.4126	0.1042	0.0020
7	0.6919	0.2474	0.4179	0.2381	0.0925	0.3544	0.3969	0.3798	0.3913	0.3222	0.3413	0.0925	0.0015
8	0.7199	0.1254	0.4629	0.2300	0.1011	0.3621	0.3863	0.4093	0.4027	0.2808	0.4089	0.1011	0.0018
9	0.6966	0.2458	0.5074	0.2326	0.1001	0.3580	0.3972	0.3978	0.4100	0.3292	0.3905	0.1001	0.0016
10	0.6944	0.2859	0.4666	0.2371	0.0933	0.3680	0.4013	0.3979	0.4017	0.2408	0.4181	0.0933	0.0019
11	0.6995	0.1958	0.4150	0.2154	0.0834	0.3424	0.3693	0.3902	0.3872	0.2845	0.3392	0.0834	0.0021
12	0.7064	0.2800	0.5030	0.2273	0.0996	0.3463	0.4032	0.4209	0.4102	0.2993	0.3218	0.0996	0.0018
13	0.7008	0.2214	0.4658	0.2237	0.0924	0.3358	0.3830	0.3922	0.3758	0.3564	0.3200	0.0924	0.0014
14	0.6975	0.2918	0.5468	0.2523	0.0954	0.3449	0.4144	0.4375	0.4403	0.3086	0.3517	0.0954	0.0023
15	0.6954	0.1449	0.4153	0.2332	0.1079	0.3396	0.3980	0.4036	0.3924	0.3261	0.3445	0.1079	0.0013
16	0.6937	0.2977	0.4156	0.2478	0.0959	0.3385	0.4037	0.4154	0.4292	0.3042	0.3310	0.0959	0.0013
17	0.7060	0.3047	0.5547	0.2477	0.1153	0.3564	0.3795	0.4243	0.4360	0.3910	0.4083	0.1153	0.0018
18	0.7126	0.2322	0.4791	0.2445	0.0926	0.3622	0.4239	0.4026	0.4033	0.2780	0.3377	0.0926	0.0015
19	0.6910	0.2468	0.4700	0.2310	0.1060	0.3502	0.4042	0.3920	0.3682	0.3665	0.3981	0.1060	0.0018
20	0.7097	0.2566	0.4780	0.2462	0.0986	0.3541	0.4101	0.4109	0.4250	0.3129	0.3372	0.0986	0.0021
avg	0.7008	0.2446	0.4743	0.2355	0.0978	0.3510	0.3991	0.4048	0.4042	0.3032	0.3686	0.0978	0.0017
min	0.6910	0.1254	0.4150	0.2154	0.0834	0.3358	0.3693	0.3695	0.3682	0.2135	0.3200	0.0834	0.0010
std	0.0075	0.0465	0.0419	0.0098	0.0080	0.0085	0.0139	0.0161	0.0196	0.0395	0.0341	0.0080	0.0004

Figure 2. The mean overall average delay over 20 independent experimental runs.

Figure 3. The minimum overall average delay over 20 independent experimental runs.

Figure 4. The standard deviation of the overall average delay across 20 independent experimental runs.

Figure 2 presents the mean overall average delay of each algorithm over 20 independent runs. COA achieves a mean delay of only 0.0017 s, significantly lower than that of the suboptimal algorithms GA and PSOGA (both 0.0978 s), and more than two orders of magnitude lower than the traditional heuristic MLF (0.2355 s) and the baseline AllEdge (0.2446 s). Notably, while GA and PSOGA exhibit similar average performance, COA reduces the mean delay by approximately 98.2% relative to them. This substantial performance gain can be attributed to three key design features of COA: (1) a compact encoding scheme that directly enforces atomicity and coverage constraints, eliminating the need for repair heuristics that waste search effort; (2) a boundary correction mechanism that guarantees all individuals remain feasible, thus avoiding exploration of invalid regions; and (3) a balanced exploration–exploitation strategy derived from the cooperative hunting and escape behaviors of coatis, which enables COA to efficiently escape local optima and converge to high-quality solutions. This result clearly demonstrates the superiority of the proposed algorithm in solution quality, indicating that COA effectively explores the solution space to identify better server placement and request offloading strategies, thereby substantially reducing the average system processing delay.

Figure 3 illustrates the best (minimum) delay achieved by each algorithm across the 20 runs. The minimum value of COA is 0.0010 s, again far lower than those of other algorithms, among which GA and PSOGA achieve a minimum of 0.0834 s, while AllCloud reaches as high as 0.691 s. These data indicate that COA possesses exceptionally strong optimization capability, enabling it to approach the global optimal solution even in a single run, which reflects its efficiency. In contrast, although other meta-heuristic algorithms can obtain relatively good solutions, they still lag behind COA by an order of magnitude.

Figure 4 displays the standard deviation of the delay for each algorithm, which measures their stability across different environments. The standard deviation of COA is merely 0.0004, nearly zero, indicating that the algorithm is insensitive to initial conditions and environmental variations, consistently delivering high-quality solutions across diverse simulation scenarios. In contrast, the standard deviations of other algorithms are generally large: for instance, AllEdge exhibits a standard deviation of 0.0465, RAND 0.0419, and MGTO 0.0395, demonstrating significant performance fluctuations and poor reliability. Although GA and PSOGA achieve favorable mean values, their standard deviations reach 0.008, still far exceeding that of COA. Therefore, COA exhibits strong advantages in terms of stability.

In summary, the proposed COA algorithm comprehensively outperforms all compared algorithms across the three dimensions of the mean, minimum, and standard deviation. Compared with baseline schemes, COA significantly reduces processing delay. Compared with classical meta-heuristic algorithms (such as GA, PSO, and DE), COA not only finds superior solutions but also demonstrates exceptional stability. Even when compared with the hybrid algorithm PSOGA, COA exhibits clear and consistent advantages. These results provide strong evidence for the effectiveness, efficiency, and robustness of COA in solving the edge server placement problem, establishing it as a highly promising new method for this domain.

To further validate the statistical significance of the observed performance differences, we conducted paired t-tests and Wilcoxon signed-rank tests between COA and each baseline algorithm over the 20 independent runs. The resulting p-values are summarised in Table 2. For all comparisons, both tests produced p-values far below the conventional significance level of 0.001 (e.g., the largest p-value is on the order of ${10}^{-9}$). These extremely low p-values provide strong statistical evidence that the improvements achieved by COA are not due to random chance. In particular, the Wilcoxon signed-rank test gave a consistent p-value of $1.91\times {10}^{-6}$ for every pair because COA outperformed the other algorithms in every single run. Together with the mean delay reduction of 98.2% and the near-zero variance, these statistical results firmly confirm the superiority, robustness, and reliability of the proposed COA-based solver for edge server placement.

Table 2. Statistical significance tests between COA and baseline algorithms (paired t-test and Wilcoxon signed-rank test p-values).

Compared Algorithm (vs. COA)	Paired t-Test p-Value	Wilcoxon Signed-Rank p-Value
AllCloud	$2.01\times {10}^{-12}$	$1.91\times {10}^{-6}$
AllEdge	$9.03\times {10}^{-9}$	$1.91\times {10}^{-6}$
RAND	$4.51\times {10}^{-12}$	$1.91\times {10}^{-6}$
MLF	$5.11\times {10}^{-12}$	$1.91\times {10}^{-6}$
GA	$1.89\times {10}^{-10}$	$1.91\times {10}^{-6}$
DE	$1.36\times {10}^{-12}$	$1.91\times {10}^{-6}$
PSO	$1.45\times {10}^{-11}$	$1.91\times {10}^{-6}$
GWO	$2.18\times {10}^{-11}$	$1.91\times {10}^{-6}$
GWOA	$1.97\times {10}^{-11}$	$1.91\times {10}^{-6}$
MGTO	$6.00\times {10}^{-9}$	$1.91\times {10}^{-6}$
FOX	$4.87\times {10}^{-11}$	$1.91\times {10}^{-6}$
PSOGA	$1.89\times {10}^{-10}$	$1.91\times {10}^{-6}$

5. Related Work

The edge server placement problem (ESPP) has attracted considerable research attention due to its critical role in determining the quality of service in edge computing systems. Existing studies have approached this problem from various perspectives, employing diverse optimization techniques ranging from evolutionary algorithms to mathematical programming and machine learning.

A large body of research focuses on evolutionary and meta-heuristic algorithms. Surayya et al. [18] conducted a comprehensive evaluation of several evolutionary algorithms for solving the ESPP, considering both delay and energy consumption optimization objectives. The compared algorithms included Genetic Algorithm (GA), Non-Dominated Sorting Genetic Algorithm II (NSGA-II), Particle Swarm Optimization (PSO), Ant Colony Optimization (ACO), and Teaching–Learning-Based Optimization (TLBO). Their experimental results demonstrated that ACO achieves superior performance among the evaluated methods. Lü et al. [19] proposed an adaptive rank-based coevolutionary learning Particle Swarm Optimization (PSO) algorithm that combines multiple PSO subpopulations with adaptive parameter control, achieving strong performance on edge server placement benchmarks. Focusing on delay and energy consumption optimization in ESPP, Moorthy et al. [20] proposed a nonlinear decreasing convergence factor to slow down convergence in early stages while accelerating it in later stages, thereby improving solution quality. Ghasemzadeh et al. [21] developed an NSGA-II-based approach to reduce workload variance and latency through optimal edge server placement. Xie et al. [22] proposed a directed-evolution Non-Dominated Sorting Genetic Algorithm (DNSGA) that eliminates conventional crossover operations and incorporates two problem-specific heuristics: a K-means-based task assignment module to reduce latency, and an efficiency-driven load migration strategy to balance server-side workloads. Given the demonstrated effectiveness of ACO, several studies have enhanced this approach. Havas et al. [23] proposed a multi-objective ant colony optimization algorithm incorporating a semi-greedy strategy to enhance efficiency, accelerate convergence, and reduce the search space during initial population generation. Zarei et al. [9] developed an ACO-based algorithm specifically designed to ensure balanced load distribution among servers, introducing two complementary heuristic algorithms: one for selecting the most suitable server for incoming workloads, and another for scheduling requests on each server based on their urgency and importance.

Beyond single-objective and single-algorithm designs, multi-objective optimization frameworks have also been explored. Kontos et al. [24] proposed a novel adaptation of the Multi-Objective Evolutionary Algorithm by Decomposition (MOEA/D) for edge server placement, embedding a heuristic algorithm to assist in chromosome fitness calculation. Their method leverages the similarity among neighboring subproblems in a multi-objective framework to efficiently approximate the underlying Pareto frontier, enabling balanced optimization of multiple conflicting objectives.

Clustering- and learning-based methods offer another orthogonal direction. Zhou and Abawajy [25] proposed a hybrid edge server placement approach combining Improved Spectral Clustering (ISC) and Q-Learning. In the first stage, ISC clusters base stations based on geographic distribution and connected user count to identify preliminary deployment locations. The second stage employs Q-Learning to dynamically refine these initial placements, ultimately determining optimal server locations. Wang et al. [26] developed an Advanced K-Means method that improves upon traditional K-means clustering to accommodate users with diverse requirements within a fixed area, aiming to maximize system profitability across different time periods. Zhang, Yu and Hu [27] presented a graph clustering-based edge server placement method that groups base stations according to geographic proximity and user density, then deploys servers at cluster centers; this reduces the number of candidate locations and improves scalability.

Finally, stochastic, uncertainty-aware and mobility-aware frameworks have been proposed to handle dynamic environments. Liu et al. [5] proposed a multi-timescale stochastic programming framework for edge server placement that distinguishes between strategic and tactical decision layers. Their approach operates on a large timescale (period) for strategic-layer decisions and a small timescale (slot) for tactical-layer adjustments. They designed a Lyapunov-based algorithm to solve the tactical-layer problem at each time slot, and a Markov approximation algorithm to address the strategic-layer problem in every time period, enabling adaptive placement decisions under dynamic conditions. Tran et al. [28] addressed deployment under uncertainty by formulating a stochastic model that captures fluctuating request rates and using robust optimization to guarantee service quality. Li [29] considered mobility-aware server placement and power allocation for randomly walking users, deriving analytical bounds on expected latency and energy consumption, and providing a framework that jointly optimizes server locations and transmission power.

Despite the significant contributions of these studies, several limitations remain. First, most existing works model the edge layer in isolation, neglecting the inherent collaboration between edge and cloud that characterizes real-world deployments. This oversight can lead to suboptimal solutions when edge resources are insufficient and requests must be offloaded to the cloud. Second, while various meta-heuristic algorithms have been applied to ESPP, the recently proposed Coati Optimization Algorithm (COA), which has demonstrated strong performance in other combinatorial optimization domains, has not yet been explored for edge server placement. Third, many existing approaches require complex parameter tuning or problem-specific heuristics, limiting their generalizability. To address these gaps, this paper explicitly incorporates edge–cloud collaboration into the problem formulation and presents the first application of COA to ESPP, with tailored encoding and boundary correction mechanisms that efficiently handle the discrete combinatorial search space while maintaining feasibility.

6. Conclusions

This paper addressed the edge server placement problem (ESPP) by incorporating edge–cloud collaboration into the optimization framework. We formulated the ESPP as a binary nonlinear program minimizing average processing delay and proposed a Coati Optimization Algorithm (COA)-based solver with tailored encoding and boundary correction. Simulations over 20 random environments show COA outperforms ten compared algorithms in mean, minimum, and standard deviation of delay, achieving a 98.2% reduction over suboptimal methods with near-zero variance, validating its effectiveness, efficiency, and robustness for enhancing edge service quality.

We acknowledge several limitations. The current model assumes static user locations and request patterns, whereas real-world edge systems face dynamic mobility and time-varying workloads. The binary nonlinear programming formulation may also face scalability challenges in extremely large deployments. To address these, we have outlined concrete future work directions, including the following: (i) extending the formulation to handle user mobility and time-varying requests via a receding-horizon or multi-timescale framework; (ii) developing multi-objective COA variants that consider energy consumption, deployment cost, and load fairness; (iii) incorporating heterogeneous edge devices with different power and accelerator profiles; (iv) performing ablation studies and sensitivity analyses across problem scales and workload distributions; and (v) validating the approach on real-world testbeds and large-scale simulators with detailed network protocols. We believe that the current work provides a solid foundation for these future investigations and offers a practical, high-performance solution for edge server placement under edge–cloud collaboration.