Edge Server Deployment Strategy Based on Queueing Search Meta-Heuristic Algorithm

Abstract

Edge computing, characterized by its proximity to users and fast response times, is considered one of the key technologies for addressing low-latency demands in the future. An appropriate edge server deployment strategy can reduce costs for service providers and improve the quality of service for users. However, most previous studies have focused on server coverage or deployment solution consumption time, often neglecting the most critical aspect: minimizing user-request response latency. To address this, we propose an edge deployment strategy based on the queuing search algorithm (QSA), which models the edge deployment problem as a multi-constrained nonlinear optimization problem. The QSA mimics the logic of human queuing behavior and has the ability to perform faster global searches while avoiding local optima. Experimental results show that, compared to the genetic algorithm, simulated annealing algorithm, particle swarm optimization, and other recent algorithms, the average number of “hopping” iterations in QSA is 0.1 to 0.6 times fewer than in the other algorithms. Additionally, QSA is particularly suitable for edge computing environments with a large number of users and devices.

1. Introduction

With the iteration of the Internet and the continuous upgrading and remodeling of communication technology, the use of mobile devices is becoming increasingly convenient. The statistical report on the development of China’s Internet network shows that as of December 2023, the number of Internet users in China reached 1.091 billion, with an increase of 25.62 million users compared to December 2022. Moreover, the proportion of Internet users accessing the Internet through mobile phones was 99.9% [1]. However, mobile terminal devices face many limitations, such as battery life, limited computing power, and more. To address these issues and improve the performance of mobile applications, it is common practice to forward requests from mobile terminals to cloud computing centers for processing. Cloud computing connects a large number of independent computing units through high-speed networks, providing users with high-performance computing resources or services at any time [2]. However, cloud computing centers are often located far from users, making it difficult to promptly respond to requests from mobile terminal devices. In scenarios such as drones and autonomous driving, where latency requirements are extremely stringent, cloud computing gradually fails to meet user demands. To effectively address this issue, mobile edge computing (MEC) has emerged. MEC can be understood as operating a cloud server at the edge of a mobile network, which handles tasks that traditional network infrastructures cannot, such as machine-to-machine (M2M) gateways, control functions, intelligent video acceleration, etc. MEC operates at the edge of the network and does not logically rely on the rest of the network, which is crucial for applications with high-security requirements. MEC servers possess high computing power, which is suitable for analyzing and processing large amounts of data. At the same time, because MECs are geographically close to users, network response times to users are reduced, and the possibility of network congestion in the transmission and core networks is minimized. MECs located at the edge of the network can also obtain the base station’s identity document (ID), available bandwidth, and other network- and user-related information in real time, enabling link-aware adaptation, which greatly enhances the user’s quality of service experience [3]. With the increasing interest in MEC research in both academia and industry in recent years, a large number of research results have emerged [4]. However, most existing studies focus on summarizing MEC research from a single aspect, such as computation offloading, resource allocation, security and privacy, etc. Yet, MEC is a distributed computing architecture with a relatively low-cost budget, so its computational and storage resources cannot be scaled up indefinitely. Therefore, MEC-related research still faces many challenges, such as how to allocate limited resources to maximize user efficiency and designing a reasonable task placement strategy along with resource allocation and server placement locations [5]. In mobile edge computing, an effective edge server placement strategy is key to solving the problem of limited resources at edge servers, such as network, computation, and cache, as well as the diversity and differences in users’ demands. These factors can lead to unbalanced loads on mobile edge servers and a degradation of the users’ quality of service.

Based on the aforementioned analysis, this study proposes a server deployment optimization strategy based on the queuing search algorithm (QSA). This strategy innovatively employs the number of network hops as an abstract representation of latency, aiming to minimize the number of hops to optimize user request forwarding. Under ideal conditions, where factors such as transmission latency in real-world network environments are not considered, this strategy can effectively determine the optimal deployment scheme for minimizing user latency. Experimental results demonstrate that the deployment scheme optimized by the QSA algorithm can reduce the average number of hops by 0.1–0.6 compared to traditional heuristic algorithms. This study provides a new theoretical foundation and methodological guidance for reducing average user latency, offering significant practical value for enhancing network service quality.

2. Related Works

The server deployment problem in dynamic edge computing has received extensive attention in recent years, and scholars at home and abroad have carried out in-depth research from different perspectives. According to the differences in research objectives and methods, the existing works can be broadly classified into the following categories: deployment optimization based on task scheduling, edge server deployment based on drones, deployment strategies based on cost and load balancing, and deployment methods based on multi-objective optimization.

In terms of task scheduling-based deployment optimization, reference [6] proposes a demand-responsive edge node deployment approach that considers service reliability and achieves high-quality task scheduling through rational planning of edge node deployment. However, this type of approach mainly focuses on task allocation and fails to fully consider the latency optimization of user requests. In terms of UAV-based edge server deployment, references [7,8] utilize UAVs as edge server nodes to provide computational offloading services for ground users, which significantly reduces the task response time. Despite the advantages of such approaches in complex terrain or emergency response scenarios, their deployment cost is high, and the greedy algorithm used makes it difficult to guarantee a globally optimal solution. Reference [9] further proposes a deployment algorithm based on K-means clustering, which takes the average system completion time as the performance index, but in edge computing scenarios, the completion time is not the most important core concern of users.

In terms of deployment strategies based on cost and load balancing, references [10,11] propose authentication-based cloud service deployment methods focusing on cost optimization, while reference [12] implements a load-balancing deployment scheme through genetic algorithms. However, none of these studies consider user request latency as a priority optimization objective. In terms of deployment methods based on multi-objective optimization, reference [13] transforms the edge server deployment problem into a multi-objective optimization problem, which balances factors such as operator’s revenue, server provisioning cost, latency, and load balancing; references [14,15,16,17] further combine online and offline policies, generate a deployment scheme by sensing the user mobility, and optimize the system by using improved genetic algorithms’ and artificial bee colony algorithms’ response times. Although these approaches have made significant progress in multi-objective optimization, they fail to adequately consider the impact of dynamic changes in user location and network heterogeneity on deployment results. In addition, references [18,19] proposed deployment methods based on overlapping dominance chains and particle swarm optimization to minimize the deployment cost while maximizing the robustness of edge services but failed to delve into the collaborative mechanism of computational offloading among nodes.

Although the above studies have made significant progress in edge server deployment, the following shortcomings still exist: (1) existing approaches mostly focus on task scheduling, cost optimization, or load balancing and fail to take user request latency as the core optimization objective; (2) in dynamic environments, the impacts of user mobility and network heterogeneity on the deployment strategy have not yet been adequately investigated; and (3) most of the heuristic algorithms (e.g., the genetic algorithm, particle swarm algorithm, etc.) have limitations in terms of global search capability and computational efficiency, making it difficult to quickly find an approximate optimal solution in complex networks.

In this paper, we propose an edge server deployment strategy based on queuing search algorithm (QSA) to address the above problems. Compared with existing heuristic algorithms, the innovations of this paper’s approach are (1) the user request delay is abstracted into the number of hops, and delay optimization is achieved by minimizing the number of hops; (2) the QSA algorithm is inspired by human queuing behavior, and demonstrates stronger global search capability by simulating the queuing process to avoid the local optimal solution; and (3) in dynamic environments, the QSA algorithm is able to quickly adapt to network changes and significantly reduce the average user delay. Through simulation experiments, this paper verifies the superiority of the proposed method in terms of delay optimization and computational efficiency.

3. Problem Modeling

This section focuses on the system modeling based on the number of hops and the problem formulation. The main symbols and their meanings are presented in

Table 1. Important symbols and significance.

Symbols	Meanings
$G$	Network diagram
$B,U,E$	Base station aggregation, user aggregation, edge server aggregation
$b,u,e$	Number of base stations, number of users, number of edge Servers
$B_{den}$	Base station network density
$C$	Matrix of information about users covered by base stations
$C_{jk}$	Whether user j is covered by base station k
$B_{jk}$	Number of hops between base station j and base station k
$B_{conn}$	Base station interconnection information matrix
$S$	The shortest path between base stations’ information matrix
$ho{p}_t$	Total number of hops
$H_{ave}$	Number of hops per capita
${\mathrm{business}}_{1,2,3}$	Business 1, 2, 3
$N$	Total number of customers
$X_i$	Status of customer i
$X_{ij}$	Customer i for operation j
$X_i^{new}$	Status update pattern of customer i
$q_{in}$	Number of people in queue n for operation i
$Q$	Number of search agents
$T_{mn}$	Service time for employee n to process operation m
$A_{mn}$	Capacity of employee n to process operation m
$F_{11},F_{12}$	Fluctuation
$\alpha$	Random numbers generated between [−1, 1] that control the direction of fluctuations
$E$	D-dimensional vector generated based on Erlang distribution
$f_i$	State complexity of customer i
$rank(f_i)$	State complexity of customers in descending order
${\mathrm{Pr}}_i$	Probability of handling operation i
$e$	Random numbers based on Erlang distribution
$N_i$	Number of customers that need to process operation i

.

3.1. Network Modeling

In this paper, we consider the edge server (ES) deployment problem. To reduce costs, we aim to select a subset of the base stations (BSs) that have already been deployed and use them as potential sites for deploying edge servers. In this paper, the average number of hops is used as a proxy for average latency to evaluate the effectiveness of deployment strategies. As shown in [20,21], replacing average latency with hop count has been demonstrated as a feasible approach. Moreover, the proposed method is not restricted to this specific latency model; by replacing the delay model, it can be adapted to a wider range of scenarios. Designing more realistic network latency models and evaluation methods to further extend the applicability of our approach will be a key direction of our future work.

The ES deployment problem can be modeled as a connected undirected graph $\mathrm{G}=(B\cup \mathrm{S}, \mathrm{E})$, as shown in Figure 1, consisting of mobile terminal devices, base stations, and potential deployment locations for edge servers. Here, $B=\{b_1,\dots ,b_2,\dots ,b_n\}$ represents the set of base stations, $\left|B\right|=\mathrm{b}$, and $E=\{e_1,\dots ,e_i,\dots ,e_k\}$ represents the set of ES deployment locations, $\left|E\right|=e$. The edge computing network model diagram is shown in Figure 1.

In the considered edge computing scenario, the number of users is denoted by u. The locations of users and base stations are generated randomly, and ${\mathrm{B}}_{den}$ is used to represent the base station network density. The network density between base stations is given by the following equation:

$$B_{den}={\displaystyle \frac{b(b-1)}{2}},$$

(1)

where b denotes the number of base stations. Base station information is generated according to the network density between base stations, and a matrix is used to represent the interconnection information between the base stations. Matrix C represents the user coverage information by base stations, where $U=\{u_{11},\cdots ,u_{ij},\cdots ,u_{mn}\}$, and $u_{jk}=1$ denotes that user $U_j$ is covered by base station $B_k$. The Floyd algorithm is applied to calculate the shortest distance between any two base stations, represented by the matrix S. For example, $S_{[j][k]}=2$ indicates that two hops are required for a request to be sent from base station $B_j$ to $B_k$.

3.2. Latency Modeling

Since this paper addresses the server deployment problem, not the network transmission problem, we assume that the request sent by the user will not be affected by the channel delay and the processing time of the base station during the transmission process; this assumption is made to simplify the model and focus on analyzing the request’s hopping path and efficiency in the base station network. The hop count schematic is shown in Figure 2.

Specifically, when a request is made by an end device j, the request is first transmitted to the base station k covering the end device, i.e., $C_{jk}=1$, a process defined as a hop count. The calculation of the hopping number is based on the transmission path of the request from the user device to the base station; we assume that the channel delay and the base station processing time are ignored, so the hopping number mainly depends on the physical distance between base stations and the network topology. If the base station is an MEC base station, then the request from the end device will be considered to have been successfully forwarded to the edge server without additional hops; assuming that the end device is not covered by an MEC base station, the number of hops for the user can be expressed as:

$$H_u=1+H_{b_u,e_u},$$

(2)

where $H_u$ denotes the number of hops of the terminal device u, $b_u$ denotes the base station covering the terminal device u, $e_u$ denotes the base station mounted on the edge server nearest to the base station $b_u$, and $H_{b_u,e_u}$ denotes the number of hops required between the base station $b_u$ and the MEC station $e_u$, and for a non-MEC base station $b_u\notin E$, the shortest number of hops to the nearest MEC base station is defined as follows:

$$H_{b_u,e_u}=\underset{e_u\in E}{\min }D(b_u,e_u),$$

(3)

$D(b_u,e_u)$ denotes the iterative computation by Dijkstra’s algorithm:

$$D(b_u,e_u)=\arg \underset{k}{\min }[M_{b_u,b_k}+M_{b_k,e_u}],\forall k\in B,$$

(4)

$D(b_u,e_u)$ denotes the shortest path calculated by Dijkstra’s algorithm, $M_{b_u,b_k}$ denotes the number of hops from base station $b_u$ to base station $b_k$, and $M_{b_k,e_u}$ denotes the number of hops from base station $b_k$ to MEC station $e_u$. We can derive the total number of hops for a single user u, and $H_u$ can be expressed by the following segmentation function:

$$H_u=\left\{\begin{array}{l}1,\varphi (u)\in e\\ 1+H_{\varphi (u),e},\varphi (u)\notin e\end{array}\right.,$$

(5)

In Equation (1), $\varphi (u)\in E$ indicates that user u is covered by the MEC base station, and $\varphi (u)\notin E$ indicates that user u is not covered by the MEC base station and a hopping operation is required. The total number of hops can be expressed as the following:

$$ho{p}_t={\mathrm{H}}_{\mathrm{total}}={\displaystyle \sum _{u\in U}{H}_u=\left|\right\{u|\varphi (u)\in E\}|}+{\displaystyle \sum _{\varphi (u)\notin E}(1+H_{\varphi (u),e})},$$

(6)

The average number of hops per user terminal can then be expressed as follows:

$$T_{ave}=\overline{H}={\displaystyle \frac{1}{\left|u\right|}}{H}_{total}={\displaystyle \frac{U_{direct}}{\left|u\right|}}+{\displaystyle \frac{1}{\left|u\right|}}{\displaystyle \sum _{b\in B}{U}_b}(1+H_{b,e}),$$

(7)

where $U_{direct}$ denotes the number of users directly connected to the MEC base station, $U_b$ denotes the number of users covered by base station b, and the average number of hops is the total number of hops divided by the total number of terminal devices.

The problem is transformed into a single-objective multi-constrained optimization problem, which can be expressed as follows:

$$\min T_{ave},$$

(8)

$$s.t.(1)-(7)$$

4. QSA-Based EDGE Deployment Approach

The Edge Site Deployment Problem (ESDP) is inherently NP-hard, as it involves optimizing the placement of edge servers while minimizing user request latency under complex constraints. NP-hard problems are computationally intractable for large-scale instances, as the solution space grows exponentially with the number of users and potential server locations. Therefore, finding the global optimal solution is impractical for real-world applications, especially in dynamic environments where user requests and network conditions change frequently.

Given the computational complexity of the ESDP, heuristic algorithms provide a practical and efficient alternative for finding high-quality approximate solutions within a reasonable time frame. While heuristic algorithms do not guarantee global optimality, they are widely used in both academia and industry to solve large-scale optimization problems, particularly in edge computing and network design [22,23]. The proposed queuing search algorithm (QSA) is designed to balance solution quality and computational efficiency, making it suitable for real-time deployment scenarios.

The primary goal of the ESDP model is not to find the global optimal solution but to provide a feasible and efficient deployment strategy that significantly reduces user request latency in practical scenarios. By abstracting latency as the number of hops and minimizing the average hop count, the model captures the core challenge of edge server deployment while remaining computationally tractable. This approach aligns with the real-world requirements of edge computing, where near-optimal solutions are often sufficient to achieve significant performance improvements. The QSA algorithm offers several advantages over traditional optimization methods.

Scalability: QSA can handle large-scale instances of the ESDP, which are common in real-world edge computing environments.

Adaptability: QSA is designed to dynamically adjust to changes in user requests and network conditions, making it suitable for dynamic environments.

Efficiency: QSA achieves a balance between solution quality and computational cost, enabling real-time decision-making.

4.1. QSA-Based EDGE Site Deployment Algorithm

QSA simulates human behavior and its interactions during queuing in human society. In daily human activities, such as shopping and waiting for checkout, customers typically follow the more capable employees to receive services. Stronger employees are able to process each customer more quickly, and when all queues are of the same length, the queue with the strongest employees will shorten the fastest. As a result, customers tend to select the shorter queue to be served. Based on this principle, the customer population represents the search agents, while the employees guide the search direction of the agents. The algorithmic process of QSA consists of three phases, namely business1, business2, and business3, as shown in Figure 3. Employees are defined in business1 and business2, and since there is only one completely unordered queue in business3, only one employee is defined in that phase. Suppose the total number of customers is N, and the ith customer is denoted as customer i. The state vector of customer i is represented by vector $X_i$, where $X_i=[X_{i,1},X_{1,2},\cdots ,X_{i,D}]$ is the state information of the customer.

4.1.1. Business1

In Business1, there are three queues represented by $queu{e}_{1n}(n=1,2,3)$. According to the principle that the better the employee, the more customers they serve at the same time, the number of customers q_1n in each queue is given by the following equation:

$$q_{1n}=Q\times {\displaystyle \frac{\frac{1}{T_{1n}}}{\frac{1}{T_{11}}+\frac{1}{T_{12}}+\frac{1}{T_{13}}}},n=1,2,3,\cdots ,$$

(9)

In the above equation, Q denotes the number of search agents, and T denotes the fitness value (i.e., service time) of the selected employees, assuming that the order of each queue in operation 1 is strictly maintained, which means that customers do not interact with each other in this operation. Then, define two state update patterns for customer i, which are denoted as follows:

$${\mathit{X}}_{\mathit{i}}^{\mathit{n}\mathit{e}\mathit{w}}=A+F_{11},i=1,2,\cdots ,N,$$

(10)

$${\mathit{X}}_{\mathit{i}}^{\mathit{n}\mathit{e}\mathit{w}}=X_i+F_{12},i=1,2,\cdots ,N,$$

(11)

$F_{11}$ and $F_{12}$ in Equations (10) and (11) are fluctuations, and since the order of each queue in Service 1 is strictly maintained, update fluctuations may be caused by the customers themselves or by the corresponding staff. The fluctuations $F_{11}$ and $F_{12}$ are defined and denoted as follows:

$$F_{11}=\beta \times \alpha \times (E·|A-X_i|)+(e\times A-e\times X_i),$$

(12)

$$F_{12}=\beta \times \alpha \times (E·|A-X_i|),$$

(13)

Equations (12) and (13) are where a random number is generated with equal probability to control the direction of fluctuations. e is a D-dimensional vector of D random numbers generated based on the Erlang distribution. The symbol “·” denotes the dot product, and “||” denotes the absolute value of a number.

The algorithm flow of business1 is shown in

Table 2. The pseudocode for the algorithm of business1.

1:	for $i=1:N$
2:	$\mathrm{if} i\le q_{11}$
3:	$\mathrm{if} i=1;$ case = 1; end if
4:	${A=A}_{11}$
5:	$\mathrm{else} \mathrm{if} i>q_{11}$ and $i\le q_{11}+q_{12}$
6:	$\mathrm{if} i=q_{11}+1$; case = 1; end if
7:	$A=A_{12}$
8:	else
9:	$\mathrm{if} i=q_{11}+q_{12}+1$; case = 1; end if
10:	$A=A_{13}$
11:	end if
12:	$\mathrm{Update} \beta$
13:	$\mathrm{if} case=1;$
14:	$\mathrm{Obtain} X_i^{new}$ based on Equation (4)
15:	$\mathrm{if} X_i^{new}$ obtains a better fitness function vales
16:	$\mathrm{Replace} X_i$  $\mathrm{with} X_i^{new}$
17:	case = 1;
18:	else
19:	case = 2;
20:	end if
21:	else
22:	$\mathrm{Obtain} X_i^{new}$ based on Equation (5)
23:	$\mathrm{if} {state}_i^{new}$ obtains a better fitness function values
24:	$\mathrm{Replace} X_i$ $\mathrm{with} X_i^{new}$;
25:	case = 2
26:	else
27:	case = 1;
28:	end if
29:	end if
30:	end for

below.

4.1.2. Business2

In Business2, there are three queues denoted by $\mathrm{q}ueu{e}_{2n}(n=1,2,3)$, and some customers need to process the operation. The state complexity of all customers is ranked in descending order and denoted by $rank(f_i)$, and the customer $custome{r}_i$ obtains probability ${\mathrm{Pr}}_i$ by the following equation:

$${\mathrm{Pr}}_i={\displaystyle \frac{rank(f_i)}{N}},i=1,2,\cdots ,N,$$

(14)

To determine whether $custome{r}_i$ will handle business2, a random number is generated from $[0,1]$ based on a uniform distribution. If the random number is less than ${\mathrm{Pr}}_i$, $custome{r}_i$ will handle the business2. The number of customers in the queue $q_{2n}$ is calculated as shown in Equation (15):

$$q_{2n}=Q\times {\displaystyle \frac{\frac{1}{T_{2n}}}{\frac{1}{T_{21}}+\frac{1}{T_{22}}+\frac{1}{T_{23}}}},n=1,2,3,$$

(15)

Define the update status of customer i in Business2 as follows:

$$X_i^{new}=X_i+e\times (X_{r1}-X_{r2}),r<c_v,i=1,2,\cdots ,N_2,$$

(16)

$$X_i^{new}=X_i+e\times (A-X_{r1}),r>c_v,i=1,2,\cdots ,N_2,$$

(17)

In Equations (16) and (17), $N_2$ denotes the number of customers that need to process operation 2, $e$ represents a random variable based on the Erlang distribution, and the probability density function (PDF) of a k-order Erlang distribution is formulated in the following equation:

$$f(t)=\left\{\begin{array}{l}{\displaystyle \frac{k\mu {(k\mu t)}^{k-1}}{(k-1)!}}{e}^{-k\mu t},t>0\\ 0,t\le 0\end{array}\right.,$$

(18)

where k is the order of the Erlang distribution, and $\mu$ is the frequency of an event. Because the random number is independently generated in one business, k is set to 1. The mean value of the Erlang distribution is $k\mu$. Then, $\mu$ is set to 0.5 in order to obtain the Erlang distribution with the mean value of 0.5. Under these settings of k and $\mu$ in the Erlang distribution, the probability of simulating a random number in the interval [0, 1] will reach 86.5%. $X_{r1}$ and $X_{r2}$ denote the states of two randomly selected customers. A represents the leader (employee) of each queue, and $c_v$ denotes the degree of confusion, which is used to control the probability of selecting the two update modes. The degree of confusion is calculated as follows:

$$c_v={\displaystyle \frac{T_{21}}{T_{22}+T_{23}}},$$

(19)

According to Equation (18), as the value of $c_v$ increases, the probability of selecting the first update mode will become higher. As a result, the influence between customers will increase, and the state of the customer will be updated based on the state of other customers.

The algorithm flow of business2 is shown in

Table 3. Pseudo code of update procedure in business 2.

1:	$\mathrm{for} i=1:N$
2:	$\mathrm{if} i\le q_{21}$
3:	$A=A_{21}$
4:	$\mathrm{else} \mathrm{if} {i>q}_{21}$ and $i\le q_{21}+q_{22}$
5:	$A=A_{22}$
6:	else
7:	$A=A_{23}$
8:	end if
9:	$\mathrm{if} rand<{Pr}_i$
10:	$\mathrm{Randomly} \mathrm{select} \mathrm{two} \mathrm{individuals} X_{r1}$ and $X_{r2}$
11:	$\mathrm{if} rand<C_v$
12:	$\mathrm{Obtain} X_i^{new}$ based on Equation (10)
13:	else
14:	$\mathrm{Obtain} X_i^{new}$ based on Equation (11)
15:	end if
16:	$\mathrm{Accept} X_i^{new}$ if it obtains a better fitness function value
17:	end if
18:	end for

below.

4.1.3. Business3

In Business 3, it is assumed that the queue is completely unorganized, meaning that interactions between customers will be intense. As a result, the update process is influenced by other customers, and fluctuations are caused either by the customers themselves or by other customers. The state update model for customer i in Business 3 is defined as follows:

$$X_i^{new}=X_{r1,d}+(e\times X_{r2,d}-e\times X_{i,d}),i=1,2,\cdots ,N_3,$$

(20)

where $N_3$ denotes the number of customers requiring service 3. $X_{r1}$ and $X_{r2}$ represent the states of two randomly selected customers. From the above equation, it can be observed that the service process of customer $i$ is greatly influenced by other customers.

The algorithm flow of business3 is shown in

Table 4. Pseudo code of update procedure in business 3.

1:	$\mathrm{for} i=1:N$
2:	$\mathrm{for} d=1:D$
3:	$\mathrm{if} rand>{Pr}_i$
4:	$\mathrm{Randomly} \mathrm{select} \mathrm{two} \mathrm{individuals} X_{r1}$ and $X_{r2}$
5:	$\mathrm{Obtain} X_i^{new}$ based on Equation (13)
6:	end if
7:	end for
8:	$\mathrm{Accept} X_i^{new}$ if it obtains a better fitness function value
9:	end for

below.

5. Experimental Assessment

5.1. Simulation Parameterization

To evaluate the performance of the QSA algorithm, a series of simulation experiments are conducted in this paper. The coordinates of users and base stations are randomly generated in a 10 km × 10 km area and follow a uniform distribution. Meanwhile, to ensure the repeatability of the experiments, a fixed random seed is used. The assumption of uniform distribution is representative of many real-world scenarios, and it can effectively model the uniform coverage of users and base stations in a given area. Generating user and base station information in this way helps to verify the robustness and applicability of QSA in dealing with complex computational problems.

The performance evaluation metric for the experiment is the hop count of the user request. A lower hop count indicates that a user request is forwarded through the network less often, thus enabling lower transmission and processing delays in the absence of channel noise interference. Therefore, the placement of base stations in this experiment is random, without considering physical proximity, but ensuring that all users are covered by at least one base station.

The experimental software environment consists of PyCharm 2022.3.3 (community edition) and Python 3.9.13. The hardware environment consists of an Intel i7-12700H processor (Santa Clara, CA, USA), 16 GB RAM, and an NVIDIA RTX 3050 GPU (Santa Clara, CA, USA). In the simulation experiments, the number of users, the number of base stations, and the number of edge servers are preset, and the locations of users and base stations are known. Other experimental parameters are shown in

Table 5. Simulation parameters.

Parameter Setting	Value Range
Number of users	1000~6000
Number of base stations	100~180
Base station network density	0.02~0.1
Number of edge servers	20~70
Number of iterations	1000
Population size	20~80

.

The ranges of the input data are mainly set based on reasonable assumptions of actual application scenarios, along with the typical scale of edge computing deployments, to ensure the feasibility and representativeness of the experiments. The following is the basis for determining the range of different parameters:

• Number of users (1000–10,000)

Setting a range of 1000–10,000 can cover small to medium-scale MEC deployments, both to demonstrate the fast convergence of the algorithm on small-scale problems and to test its scalability in large-scale scenarios.

2.

Number of base stations (80–200)

The number of base stations depends on the subscriber density and coverage area, and usually, operators deploy more base stations in high-density areas (e.g., cities) to provide better quality of service. The range of 80–200 is in line with the typical cellular network deployment model and ensures that sufficient base station resources can still be provided when the subscriber number changes.

3.

BTS network density (0.01–0.1)

In reality, base station density is typically higher in urban environments and lower in suburban areas, so setting 0.01–0.1 simulates different types of deployment environments.

4.

Number of MEC servers (10–80)

In small-scale scenarios (e.g., a small campus), only a small number of MEC servers may be needed, so the lower limit is set to 10.

In a large-scale MEC deployment (e.g., an entire city), the number of servers may be larger, so the upper bound is set to 80 to accommodate larger-scale optimization problems.

5.

Number of iterations (1000)

Multiple experiments have shown that QSA and other meta-heuristic algorithms usually stabilize after 500–1000 iterations, so set 1000 to ensure that all algorithms have sufficient search space to find a better solution.

6.

Population size (20–70)

In meta-heuristic optimization algorithms, the population size affects the search capability and computational complexity of the algorithm.

The range of 20–70 is chosen to strike a balance between search accuracy and computational time: smaller populations may lead to local optimization, while larger populations increase computational cost.

5.2. Analysis of Simulation Results

In order to evaluate the performance of the QSA algorithm in edge deployment environments, this paper conducts multiple simulation experiments to capture the randomness of user and base station locations. The main performance metric of the QSA algorithm is still the hop count; the smaller its value, the better the global search capability is, and the lower the end-to-end latency of the user request.

The initial populations for all algorithms were generated using the numpy.random 2.1.0 library in Python. To ensure the repeatability of the experiments and fairness of the comparisons, we fixed the sequence of random seeds to ensure that all algorithms used the same set of initial populations. For each experiment, we generated five different initial populations using different seeds and applied the same set of seeds to all algorithms in the comparative analysis. This approach allowed us to focus on the effect of algorithmic differences while controlling for initial population variability.

To ensure the statistical significance of the experimental results, each experimental configuration was repeated for 10 runs. Each run used a different initial population that was generated by a fixed sequence of random seeds. By increasing the number of repetitions, we were able to more accurately assess the performance of the algorithm and reduce the impact of randomness on the results.

All experimental results are averaged over 10 independent runs, and error bars indicate standard deviation. This treatment ensures the reliability of the results and provides a clear description of the variation in algorithm performance. Specifically, each experimental configuration uses 10 different seeds, each corresponding to one independent experimental run. This approach ensures that different algorithms are compared under the same initial conditions, thus eliminating the effect of initial seed differences on the results.

To validate the superior performance of QSA, it is compared with five classical metaheuristic algorithms: GA [24], SA [25], AEO [26], GWO [27], and PSO [28], as well as two newer metaheuristic algorithms, POA [29] and WarSO [30].

5.2.1. Overall Performance Comparison

Each set of experiments was conducted seven times, and the results are presented using line graphs. Figure 4 illustrates the fitness function trends for each algorithm. It can be observed that QSA’s fitness function curve declines rapidly, reaching the optimal value in fewer iterations. This results in a lower average number of hops compared to other methods. Specifically, QSA achieves an average hop count reduction of 0.1 to 0.6 times, demonstrating its superior performance in global optimization.

Next, we compare the computational time required by each algorithm with the results presented in Figure 5. The experiments were conducted on a system equipped with Windows 11, a 12th Gen Intel^® Core™ i7-12700H CPU, and 16 GB of RAM. As shown in Figure 5, QSA requires 1.2 to 6 times more computational time than other algorithms. Most of this time is spent in the search process, where QSA’s “employees” explore optimal solutions through three distinct operations. However, this additional time investment can be worthwhile in certain scenarios. For example, when service providers optimize edge computing infrastructure, achieving better deployment solutions is often more valuable than reducing computation time. In such cases, user feedback plays a crucial role, and providers may prefer investing more time to ensure improved service quality.

5.2.2. Performance Trend Analysis with the Number of Users

Figure 6 shows the performance comparison of different algorithms under varying user scales using bar charts with error bars. Each bar represents the average hop count of an algorithm for a specific number of users, ranging from 1000 to 6000. The error bars indicate the standard deviation of 10 independent runs, reflecting the degree of variability in the performance of the algorithms. Smaller error bars suggest that the algorithms perform more consistently under different initial populations, while larger error bars indicate higher sensitivity to initial conditions.

The number of users presents a more rigorous test of algorithm performance. In this experiment, we evaluate different algorithms as the number of users increases from 1000 to 6000, with the results shown in Figure 6 and Figure 7.

As illustrated in Figure 6, the average hop count varies across different user scales, with each algorithm’s performance represented by a distinct bar. QSA consistently achieves the lowest average hop count across all user scales, demonstrating its superior performance in minimizing delay. Furthermore, the error bars for QSA are notably smaller than those of other algorithms, indicating that QSA’s performance is more stable and less sensitive to variations in initial conditions. This stability suggests that QSA can effectively achieve optimization goals across different user scales, highlighting its strong scalability.

Figure 7 further reveals that as the number of users increases, the computational time required by all algorithms also increases. This is because each user must be processed individually to compute the hop count. These results highlight QSA’s ability to scale efficiently while maintaining its effectiveness in solving edge deployment problems across various user densities.

5.2.3. Performance Trend Analysis with the Number of Base Stations

The performance of various algorithms is evaluated based on the average number of hops for user requests as the number of base stations increases from 100 to 180. The results are presented in Figure 8 and Figure 9 using bar charts with error bars. Each bar represents the average hop count of an algorithm for a specific number of base stations, and the error bars indicate the standard deviation of 10 independent runs, reflecting the variability in algorithm performance due to different initial conditions.

As shown in Figure 8, the average number of hops for each algorithm decreases as the number of base stations increases. This is primarily because, with the increase in the number of base stations, the likelihood of a user being covered by a closer base station rises, reducing the number of hops needed to forward the user’s request to the edge server (ES). The bar chart clearly demonstrates that QSA consistently achieves the lowest average hop count across all base station densities, with smaller error bars compared to other algorithms. This indicates that QSA not only performs better in minimizing user request delays but also exhibits greater stability under varying initial conditions.

To further assess how the number of base stations (BSs) affects algorithm performance, we evaluate the average number of hops as the BS count increases from 100 to 180. The results, presented in Figure 8 and Figure 9, show that QSA maintains its superior performance regardless of the BS density. The smaller error bars for QSA suggest that its performance is less sensitive to variations in initial populations, further confirming its robustness and reliability in edge server deployment scenarios.

Figure 9 shows that computational time increases linearly with the number of base stations. This is because a larger number of base stations expands the solution space, requiring more time for the algorithms to explore and identify optimal deployment solutions.

5.2.4. Performance Trend Analysis with BTS Network Density

The impact of BTS network density on algorithm performance is examined by increasing the BTS density from 0.02 to 0.1, with the results shown in Figure 10 and Figure 11 using bar charts with error bars. Each bar represents the average hop count of an algorithm for a specific BTS network density, and the error bars indicate the standard deviation of 10 independent runs, reflecting the variability in algorithm performance due to different initial conditions.

As shown in Figure 10, the average hop count for all algorithms decreases as the BTS network density increases. When the density reaches 0.06 to 0.08, the hop count for all algorithms converges to 1, indicating that nearly all BTS pairs become interconnected. Despite this convergence, QSA consistently achieves a lower hop count across different densities, with smaller error bars compared to other algorithms. This reaffirms QSA’s efficiency in reducing latency and its robustness under varying network conditions.

Figure 11 shows that as BTS density increases, the computational time required by all algorithms generally decreases. This suggests that both QSA and other clustering-based optimization approaches adapt well to varying BTS densities, demonstrating strong scalability and flexibility in edge network deployments.

5.2.5. Performance Trend Analysis with the Number of Edge Servers

The performance of different algorithms is analyzed as the number of ESs increases from 20 to 70, with the results presented in Figure 12 and Figure 13 using bar charts with error bars. Each bar represents the average hop count of an algorithm for a specific number of ESs, and the error bars indicate the standard deviation of 10 independent runs, reflecting the variability in algorithm performance due to different initial conditions.

As seen in Figure 12, the average hop count decreases as the number of ESs grows, eventually stabilizing at 1. This occurs because when the number of ESs matches the number of base stations, each base station hosts an ES, allowing user requests to be processed locally. QSA consistently achieves the lowest average hop count across all ES counts, with smaller error bars compared to other algorithms. This demonstrates that QSA is the best-performing algorithm for minimizing network latency while also exhibiting greater stability under varying initial conditions.

Figure 13 shows that as the number of ESs increases, computational time decreases. This is because a higher number of ESs reduces the complexity of the solution space, accelerating convergence. Once ESs are fully deployed at all base stations, every feasible solution is optimal, significantly reducing the required search time.

5.2.6. Analysis of Performance Trends with Population Size

Figure 14 and Figure 15 illustrate how algorithm performance varies as the population size increases from 20 to 80, using bar charts with error bars. Each bar represents the average hop count of an algorithm for a specific population size, and the error bars indicate the standard deviation of 10 independent runs, reflecting the variability in algorithm performance due to different initial conditions.

From Figure 14, we observe that the average hop count fluctuates as the population size increases. This fluctuation is due to the trade-off between exploration and exploitation:

A larger population enhances global search capability, potentially leading to better solutions.

However, an excessively large or small population can cause instability and over-fitting, resulting in suboptimal performance.

QSA consistently achieves a lower average hop count compared to other algorithms across all population sizes, with smaller error bars indicating greater stability. Based on these observations, a population size of 40 is chosen as the optimal setting for the simulation experiments, as it balances exploration and exploitation while minimizing hop count and computational time.

As depicted in Figure 15, computational time generally increases with population size. While a moderate population size (20–60) maintains an efficient runtime, exceeding 60 significantly increases computational overhead. The lowest time consumption is observed when the population size is 40, making it the optimal choice from both performance and efficiency perspectives.

5.3. Summary of Findings

QSA outperforms other algorithms in minimizing hop count, making it highly effective for delay-sensitive applications.

QSA requires more computational time due to its extensive search operations, but this trade-off is justified in scenarios demanding high deployment quality.

QSA maintains stable performance as the number of users, base stations, and ESs increases, showcasing strong scalability.

An optimal population size exists (~40) to balance performance and efficiency.

These results validate QSA’s effectiveness in optimizing edge computing deployment, providing robust, scalable, and high-performance solutions for dynamic network environments.

6. Discussion

6.1. Summary of Key Findings

The experimental results demonstrate that QSA consistently outperforms other algorithms in minimizing the number of hops across various scenarios. Specifically, QSA achieves an average hop reduction of 0.1 to 0.6 times compared to other methods, indicating its strong global optimization capability. Additionally, QSA maintains stable performance across different user scales, base station densities, and edge server configurations, proving its robustness and scalability.

6.2. Comparison with Other Algorithms

Compared with traditional heuristic algorithms, such as PSO, GA, and GWO, QSA exhibits faster convergence in fitness function optimization, leading to lower hop counts. However, the computational time of QSA is 1.2 to 6 times longer than that of other algorithms due to its multi-phase search process. While this increases computational cost, it ensures higher-quality solutions, making it particularly suitable for deployment scenarios where solution quality is prioritized over execution speed.

6.3. Factors Influencing Performance

Several factors impact the effectiveness of QSA.

User distribution and density: When users are densely distributed, the performance gap between QSA and other algorithms becomes more evident.

Base station placement: A higher number of base stations generally reduces hop counts, but QSA consistently finds better deployment solutions.

Parameter settings: The population size and iteration count significantly affect QSA’s execution time and optimization ability. A carefully tuned parameter set can improve efficiency without sacrificing accuracy.

6.4. Limitations and Future Work

Despite its advantages, QSA has some limitations.

High computational cost: The prolonged execution time may be a bottleneck in real-time decision-making scenarios. Future work could explore acceleration techniques, such as parallel computing or distributed optimization.

Scalability in ultra-large networks: While QSA performs well up to 6000 users and 180 base stations, its scalability in larger-scale deployments remains an open question. Future studies could investigate adaptive mechanisms to balance efficiency and accuracy.

Dynamic environments: This study considers static user and infrastructure conditions. Future research could extend QSA to dynamic edge computing environments, where user mobility and network load fluctuate over time.

7. Summary and Prospects

The structure of this paper is organized as follows: Section 2 introduces related work; Section 3 elaborates on the problem model; Section 4 provides a detailed description of the queuing search algorithm (QSA); Section 5 presents the experimental results and analysis; and finally, Section 6 summarizes this paper and outlines future research directions.

This paper addresses the Edge Site Deployment Problem (ESDP) with the objective of minimizing user request latency to enhance user experience and provide effective solutions for service providers. The proposed solution, based on the queuing search algorithm (QSA), optimizes the deployment process by reducing the number of hops in the network, representing the latency of user requests. The QSA, inspired by human queuing behaviors, efficiently avoids local optima and demonstrates superior global search capabilities. Simulation experiments validate its effectiveness, showing improved performance in comparison to traditional methods. This work not only offers a novel approach for ESDP but also contributes to the broader field of edge computing by advancing optimization techniques for resource allocation and deployment strategies. Although this study has achieved certain results, factors such as user mobility and server heterogeneity have not yet been considered. Future research will focus on the following directions:

• User mobility modeling: Incorporate user dynamic mobility into the optimization framework to more realistically reflect actual application scenarios;
• Server heterogeneity analysis: Study the performance differences of different types of servers and their impact on deployment strategies;
• Load balancing: The number of jumps is random, and more realistic network models are studied to better achieve load balancing effects.