Content uploaded by Aresh Dadlani

Author content

All content in this area was uploaded by Aresh Dadlani on Aug 09, 2022

Content may be subject to copyright.

EVBLB: Efﬁcient Voronoi Tessellation-Based Load

Balancing in Edge Computing Networks

Vahid Sohrabi∗, Mohammad Esmaeil Esmaeili∗, Mahdi Dolati∗, Ahmad Khonsari∗†, and Aresh Dadlani‡

∗School of Electrical and Computer Engineering, University of Tehran, Tehran, Iran

†School of Computer Science, Institute for Research in Fundamental Sciences, Tehran, Iran

‡Department of Electrical and Computer Engineering, Nazarbayev University, Nur-Sultan, Kazakhstan

Emails: {vahidsohrabi.mkh, me.esmaeili, mahdidolati, a khonsari}@ut.ac.ir, aresh.dadlani@nu.edu.kz

Abstract—Edge computing (EC) is a promising solution to enable

the next-generation delay-critical network services which are not

conceivable in the traditional cloud-based architecture. EC takes

the computing and storage resources closer to the end-users at the

edge of the networks to eliminate the propagation delays caused

by geographical distances. However, due to the lack of facilities

such as cooling systems, the capacity of available resources in

the edge is far less than that in the remote clouds. So, efﬁcient

utilization of the edge resources has a profound impact on the

effectiveness of the edge computing paradigm. Load balancing is

a key factor in achieving resource efﬁciency and high utilization.

In this paper, we present the design of EVBLB, an efﬁcient load

balancing algorithm based on Voronoi tessellation (VT) that assigns

the users’ service requests to the edge servers while considering

the density of edge resources in the area and the distance of the

users from the assigned servers. Building on the notion of VT

not only allows us to achieve these goals, but is also computable

in linear time, which signiﬁcantly improves the scalability and

responsiveness of our proposed method as compared to existing

studies. Our simulation results show that EVBLB outperforms two

conventional baselines in terms of throughput, response time, task

completion time, and request blocking rate.

Index Terms—Edge computing, load balancing, Voronoi tessel-

lation, resource allocation, scalability.

I. INTRODUCTION

The overwhelming workload resulting due to the emergence

of the Internet of Things (IoT) and the rapid growth of inter-

connected networks has attracted profound attention for drastic

improvement of the current IT infrastructure. Cloud comput-

ing that mainly constitutes the backbone of the storage and

computing infrastructure is not sufﬁcient for delay-sensitive

and interactive services such as augmented and virtual re-

ality [1], transportation [2], and healthcare [3]. Speciﬁcally,

due to geographical distances, cloud computing paradigm is

unable to eliminate the propagation delay and provide the

expected response times. Contrarily, end-devices such as the

user equipment and sensors have limited computing power and

battery thus, making it impossible to run the next-generation

services on them.

Edge computing (EC) is a viable approach that people from

academia and industry believe can address the shortcomings of

the cloud computing architecture [4]. In this novel approach,

resources are placed close to the user to provide the acceptable

response time for time-sensitive services. As shown in Fig. 1,

the general architecture of EC comprises of three main layers:

Fig. 1. General edge computing network architecture.

1) the cloud layer that contains cloud servers to process

heavy requests, 2) the edge layer that constructs a complex

network of edge nodes to host the services closer to users and

reduce the response time, and 3) the device layer that consume

services through base stations (BS). Clearly, by running more

services on the edge nodes, the latency of communicating

with the cloud is avoided and the response time decreases.

Therefore, the efﬁcient usage of edge server resources is one

of the important challenges in edge networks.

Load balancing is a fundamental procedure that affects the

resource utilization of edge nodes. Studies have shown that

the load in edge networks can be signiﬁcantly uneven. Thus,

without a proper load balancing algorithm, some servers may

receive a lot of requests and are always overburdended with

heavy load, while some remain almost idle and their resources

are not utilized optimally. This load imbalance can increase

the latency of services deployed at the edge and eliminate the

beneﬁts of EC. Consequently, load balancing is instrumental

in improving the performance of edge networks so as to satisfy

the time-sensitive requirements of user applications. There

exist many works on load balancing in edge networks that

consider edge resources, the distance of servers from users,

and the resource demands [5], [6]. They however, mainly

suffer from the slow runtime that reduces the chances of

faster reactions to the demand changes and trafﬁc shifts.

Undoubtedly, this problem becomes even more challenging

as the number of users and number of requests grow in the

future generation networks.

In view of the above shortcomings, we propose a load

balancing algorithm for edge computing by exploiting Voronoi

tessellation (VT) [7] to efﬁciently assign the user requests to

the least loaded edge node and simultaneously, select the edge

nodes that are closer to the user to guarantee a low propagation

delay. Partitioning the users’ residence area with respect to the

location of the edge servers in linear time using VT yields a

quick mapping between the sets of users and edge servers.

This computed mapping incorporates the information about

the density of edge servers in the area and thus, balances the

load within the system. We then apply an iterative procedure

on the mapping to further distribute the load among the

neighboring edge servers. To optimize the runtime of the

proposed method, we carefully select two criteria, namely

number of neighbors and the distance, to efﬁciently terminate

the iterative procedure. The main contributions of our work

can be summarized as:

•Application of VT to address the problem of load bal-

ancing in edge-enables systems.

•Development of a fast iterative procedure, known as

EVBLB, that builds on top of the initial solution obtained

from the VT to further improve the system performance.

•Performance comparison of the proposed EVBLB algo-

rithm against two existing load balancing methods in

terms of throughput, response time, task completion time,

and blocking rate.

The rest of the paper is organized as follows. Section II

brieﬂy reviews related works on load balancing in edge net-

works. The system model and problem formulation are given

in Section III, followed by the proposed VT-based approach

in Section IV. Performance evaluation and comparisons based

on simulation results are discussed in Section V. Finally,

Section VI concludes the paper.

II. RE LATE D WOR KS

We now review the most relevant optimization-based studies

reported in the literature for distributed computing environ-

ments. In [8], the authors proposed CooLoad, a cooperative

scheme for balancing load over the edge network which is

modeled as a ﬁnite quasi birth-and-death (QBD) Markov

process. CooLoad employs a threshold-based method that

relies on the queue length of the neighboring servers to

migrate requests and balance the load. In order to decrease

the requests’ blocking rate, CooLoad dynamically updates the

thresholds separately in each edge server. In [9], a static task

scheduling technique based on particle swarm optimization

(PSO) [10] has been proposed. Authors showed that the

proposed method decreases the makespan of the tasks and

improves the resource utilization. In [11], a heuristic algorithm

called HEELS has been designed which is based on glowworm

swarm optimization (GSO) [12] for load balancing over the

edge networks. HEELS employs a two stage decision making,

where in the ﬁrst stage the input tasks are clustered based

on their computational intensity and transfers the heavy tasks

to the remote cloud that has more resources. In the second

TABLE I

SYS TEM NO TATION S AND DE FIN IT ION S

Notation Deﬁnition

eiEdge server i.

ciCloud server i.

biBase station i.

viThe i-th region of the Voronoi tessellation.

riUser task i.

∆TThe size of windows time to collect user’s tasks.

R∆TReceived user’s tasks in ∆T.

PeiResource capacity of edge server ei.

Pmem

eiMain memory capacity for edge server ei.

Pcpu

eiProcessor speed for edge server ei.

Pdisk

eiDisk capacity for edge server ei.

TriRequired resource for user task ri.

Tmem

riMain memory required for user task ri.

Tcpu

riProcessor cycles required for user task ri.

Tdisk

riDisk capacity required for user task ri.

QiTask queue of edge server ei.

NeiSet of neighbors of edge server ei.

uiCPU utilization of edge server ei.

Cmax Maximum number of iterations to ﬁnd neighbors of any edge

server.

νMaximum number of neighbors of any edge server.

ΨMaximum domain radius.

sStep size.

stage, the remaining tasks are distributed among the edge

servers based on a GSO algorithm that uses dynamic step

sizing based on sine and cosine that is adjusted adaptively as

time progresses.

Works reported in [13]–[15] have considered the load bal-

ancing for task ofﬂoading in vehicular edge networks (VEN).

A clustering approach has been adopted in [13] to group the

vehicles based on their positions, speeds, and directions. In

each cluster, a cluster head is then selected that distributes

the tasks intra- and inter-cluster by collecting data about the

processing power and queue length of corresponding vehi-

cles. Fiber-Wireless (FiWi) [14] and software-deﬁned network

(SDN) [16] technologies have also been employed to construct

an intelligent infrastructure consisting of cloud servers, road-

side units (RSU), edge servers, and vehicles. Then, the SDN

controller uses the network-wide telemetry data about vehicle-

to-vehicle (V2V) and vehicle-to-infrastructure (V2I) latencies

to compute the best routing path for the ofﬂoaded tasks. A joint

load balancing and task ofﬂoading algorithm is proposed in

[15], where a mixed integer non-linear programming (MINLP)

formulation, which is non-convex and NP-Hard, is given for

the problem. To solve it, a two-stage algorithm is designed that

ﬁrst selects the target edge servers based on their capacities,

and then chooses the optimal ofﬂoading decision to minimize

the processing latency of vehicle tasks.

III. SYS TE M MOD EL A ND PROBLEM DEFINI TI ON

With the system notations listed in Table I, we now introduce

the system model and problem statement in this section.

A. System Model Description

We consider an edge network composed of a set of edge

servers, denoted by E={e1, e2, . . . , en}, a set of cloud servers,

given as C={c1, c2, . . . , cm}, and a set of BSs, denoted by

B={b1, b2, . . . , bk}. We assume that each edge server ei∈E

is characterized by three types of resources: (1) Pmem

eiwhich

denotes the total capacity of the main memory in gigabytes

(GB), (2) Pdisk

eiwhich is the disk capacity in GB, and (3) Pcpu

ei

that indicates the server processing speed in gigahertz (GHz).

We assume that the system users submit their required network

services through the closest BS. Similar to [12], we assume that

the system works in an episodic manner, where the demand

of users during the intervals of length ∆Tare accumulated

in the recipient BS and at the end of each time interval, the

service requests are dispatched to appropriate computing servers

in Eor C. Such a service delivery model facilitates the system

orchestrator to achieve a higher level of load balance and service

quality. We deﬁne R∆T={r1, r2, . . . , ru}to represent the set

of users that have submitted a service request in the latest time

interval. The demand ri∈R∆Tof the i-th user is measured

in terms of three resource types: (1) Tmem

riwhich denotes the

required main memory, (2) Tdisk

riwhich represents the required

disk, and (3) Tcpu

riwhich is the required processing power. Each

edge server eihas a queue Qi={q1, q2, . . . , ql}to store the

incoming user requests in the period ∆Tand assigned them to

appropriate edge servers based on the load-balancing strategy.

The notation |Qi|shows the length of queue in edge server ei.

Note that to calculate the amount of CPU resource remaining,

the sum of the total amount of cycles required for executing all

tasks in queue Qiis subtracted from the total amount of cycles

that can be performed by the server over a ∆Ttime interval.

B. Problem Statement

In this paper, we investigate the problem of allocating the

edge and cloud resources to the requests of users in R∆T, while

balancing the load of the edge servers. Speciﬁcally, we assume

that each request should be explicitly assigned to either an edge

server or a server that residing in the cloud. To measure the

effectiveload balancing on edge servers, we deﬁne a performance

metric called the load balancing factor (LBF), similar to [15],

as follows:

LBF =v

u

u

t

1

n

n

X

i=1

(ui−¯u)2,(1)

where, uidenotes the CPU utilization of the edge server ithat

is deﬁned as ui≜min 1,P|Qi|

j=1 Tcpu

rj/(Pcpu

ei×∆T)and ¯uis

the average of all ui’s.

IV. PROPO SE D LOAD BALANCING AP PR OACH

In this section, we present the design of our load-balancing

strategy for resource allocation at the edge. To this end, we use

the VT plane partitioning scheme to efﬁciently obtain a solid

initial association of users to the available edge servers. We then

employ an iterative algorithm to cluster the edge servers and

increase the chance of using the edge servers with the highest

Fig. 2. Schematic of a simple Voronoi tessellation.

amount of available capacity without jeopardising the service

quality and acceptable latency.

A. Background: Voronoi Tessellation

Voronoi tessellation (VT) or Voronoi diagram is a fundamental

data structures in computational geometry that divides a plane

according to the nearest neighbor rule [7]. Given the set P=

{p1, p2, . . . , pn}of points, VT is a partitioning of the plane into

regions V={v1, v2, . . . , vn}where for any point in P, a point q

lies in the region corresponding to a point piif d(pi, q)< d(pj, q)

for any j=i. Fig. 2 shows that line segments that deﬁne the

regions in a VT are equidistant to the two nearest points. From

the deﬁnition of a VT, as the center points get closer, we observe

that the associated regions becomes smaller.This property allows

us to obtain a partition of the plane that is in accordance with

the density of the centering points. More details on linear-time

algorithms for VT computation can be found in [7] and [17].

B. Capacity and Load Indicators

To measure the load of users’ requests and the suitability of

computing servers, we deﬁne the metrics Triand Pei, respec-

tively, as follows:

Tri=αT mem

ri+βT disk

ri+γT cpu

ri,∀ri∈R∆T,(2)

Pei=αP mem

ei+βP disk

ei+γP cpu

ei,∀ei∈E, (3)

where α,β, and γare the coefﬁcients of memory, disk, and

processor, respectively, for normalization (without the loss of

generality we assume that α+β+γ= 1). These coefﬁcients

can either be set as constants or computed in each edge server

using machine learning techniques. As a result, the resources of

all edge servers can be computed as below:

Ptotal =

n

X

i=1

Pei.(4)

Moreover, the remaining available resource of each edge

server can be obtained using the following expression:

Prem

ei=Pei−

|Qi|

X

j=1 αT mem

rj+β T disk

rj+γTcpu

rj

∆T.(5)

Algorithm 1 Proposed EVBLB Algorithm

Input: Sets E,C,R∆T,∀ei∈E,Neiwhich has been computed

once by Algorithm 2 and by VT.

Output: Assignment of user’s tasks in R∆Tto the servers in Eor

Cwith the principal goal of minimizing objective (1).

1: Mc←maxei{Pcpu

ei}

2: Mm←maxei{Pmem

ei}

3: Md←maxei{Pdisk

ei}

4: for ri∈R∆Tdo

5: if Tcpu

ri> Mcor Tmem

ri> Mmor Tdisk

ri> Mdthen

6: Assign rito the least loaded cloud server.

7: end if

8: end for

9: for ei∈Edo

10: ek←arg maxej∈NeiPrem

ej

11: Assign all user’s tasks inside the region vito edge server ek.

12: end for

C. Proposed Approach

As outlined in Algorithm 1, the proposed EVBLB algorithm

begins by sending the largest requests to the cloud servers.

Speciﬁcally, in lines 1 to 8, requests that their CPU, memory,

or disk demands exceeds the capacity of any edge server are sent

to the cloud servers, which typically have orders of magnitude of

higher capacity. As input of the algorithm, we compute the VT,

where the set Pof input points symbolizes the location of edge

servers in the area once because the location of edge servers are

ﬁxed. This step helps to ﬁnd the closest edge servers to the end-

users, while considering the density of edge servers in the area.

The output of this step is a set of regions, each containing an edge

server. By notation Nei, we denote the neighbors of edge server

eifor any ei∈E. To do this, we deﬁne a neighbor radius,RDi,

for each edge server ei. The initial value of radius is selected to

be a very small value ϵand then is gradually increased using an

iterative algorithm (see Algorithm 2) until either the number of

neighbors reaches the value of νor the radius grows bigger than

Ψ. The following equations show the rules of determining the

set of neighbors and the value of the radius:

Nei(c+ 1) = ej|ej∈E;dist(ei, ej)≤RDn(c),(6)

RDn(c+ 1) = minnΨ,max 0, s(ν− |Nei(c)|)o,(7)

where νis the threshold for the maximum number of neighbors,

dist(·,·)measures the geographical distance of its two edge

server arguments, and sis step size of distance. To ensure that the

distance of from neighbors does not grow unreasonably, which

leads to practically unacceptable propagation delays, we further

deﬁne and impose an upper-bound for the value of the neighbor

radius that is denoted by Ψin equation (7). When Algorithm 2

terminates, a set Neiis obtained that has a set of neighboring

edge servers to eisuch that the size of the set is as close to νas

possible, which respecting the maximum distance Ψ. Note that

we call Algorithm 2 once for every edge server and each time

the execution of the procedure terminates after at most Cmax

iterations. When the set of neighbors Neiis computed, the edge

server eidistributes the received requests from its corresponding

region vito the edge servers in Neibased on the available capacity

Algorithm 2 Finding the Neighbors

Input: Edge server ei,Ψ, and Cmax.

Output: The set of neighboring servers for ei.

Initialization: Nei(0) = {ei}and RDn(0) = ϵ.

1: c←1

2: while c≤Cmax do

3: Update Nei(c)based on (6).

4: Update RDi(c)based on (7).

5: c←c+ 1

6: end while

7: return Nei(Cmax)

TABLE II

SIMULATION PA RA ME TER S

Parameter Value

|E|U(10,100)

Pmem

ei{4,8,16,32}GB

Pcpu

ei{1,1.1,...,3.9,4.0}GHz

Pdisk

ei{500,1000,2000}GB

R∆TU(100,200)

Tmem

uriU(100,500) MB

Tcpu

uriU(100,1000) MHz

Tdisk

uriU(100,1000) MB

∆T2seconds

Cmax 50

ν5

Ψ 5

s0.1

of the servers. Note that, to ﬁnd a good server, we combine the

amount of different types of resources (i.e., CPU, memory, and

disk) by applying (5) and select the best target server with regard

to that capacity indicator.

The computational time of Algorithm 2 is in the order of

O(Cmax), so the complexity of computing Neifor any ei∈Eis

upper bounded by O(|E|.Cmax), where by considering constant

value for Cmax, it will be O(|E|). Also, computing the VT takes

time O(|E|.log |E|)[17]. It should be noted that these two will

be computed only once because we assume that the location of

edge servers are ﬁxed. In Algorithm 1, the lines 4-8 and lines 9-12

exhibit complexities of O(R∆T)and O(|E|), respectively. As a

result, the complexity of this algorithm will be O(R∆T+|E|).

Therefore, the total complexity of our proposed EVBLB load

balancing algorithm is computed to be:

O(|E| · log |E|) + O(R∆T).(8)

V. PERFORMANCE EVAL UATIO N

We now evaluate the performance of the EVBLB algorithm by

comparing it with two already existing appraoches, namely the

CooLoad [8] and HEELS [11] algorithms. We consider several

edge networks with different number of edge servers in the range

[10,100]. The time interval ∆Tfor accumulating user requests is

set to 2seconds. We select user request generation rate uniformly

from the range [100,200] task per seconds. The memory and

Fig. 3. Task average response time versus number of resources.

Fig. 4. Task maximum completion time (Makespan) versus number of

resources.

processor capacity of the edge servers are selected from sets

{4,8,16,32}GB and {1,1.1,...,3.9,4.0}GHz, respectively.

The required memory of user tasks lie in range of [10,100]

MB and processing cycles are between 100 and 1000 GHz.

The simulation results are averaged over 100 runs with random

seeds. The parametric settings are summarized in Table II, where

U(a,b)denotes the uniform distribution. We assess and analyze

ﬁve performance metrics in our simulation: (1) average response

time, (2) throughput (number of completed user requests per

second), (3) maximum task completion time, (4) request blocking

rate, and (5) LBF (as deﬁned earlier in Section III-B).

Fig. 3 shows that the average response time decreases as the

number of edge servers increases. In this ﬁgure, the EVBLB

algorithm signiﬁcantly outperforms HEELS and CooLoad be-

cause of low execution complexity as well as better distribution

of tasks among the edge servers.

Moreover, it can be seen in Fig. 4 that EVBLB achieves the

minimum request completion time, i.e., 3seconds for 100 of

edge servers. Although the performance of EVBLB and HEELS

are comparable for 20 to 50 edge servers, as the number of

edge servers increases, especially for more than 50 servers, the

Fig. 5. Throughput versus time.

Fig. 6. Load balancing factor versus time.

advantages of EVBLB becomes clear. One of the main reasons

is that the GSO algorithm used in HEELS requires a signiﬁcant

number of iterations to converge to the ﬁnal solution as the

number of edge servers increases.

The throughput analysis plotted in Fig. 5 reveals that HEELS

and EVBLB exhibit similar performance, whereas CooLoad

yields a consistently lower throughput. The main reason can be

traced to the fact that CooLoad does not consider the maximum

of available resources in the edge servers during the dispatching

of user requests.

Fig. 6 compares the LBF of the three algorithms with respect

to time. According to the basic network settings, i.e., the resource

capacity of edge servers, user input rate and algorithm execution

period ∆T, from t= 1 to t= 1300 seconds due to the

distribution of requests between only high-capacity servers and

idle of edge servers with low capacity, the LBF is high and still

load balancing is not well done. After this time, with the queue

of requests for high-capacity servers being ﬁlled and hence, the

rapid allocation of incoming requests to low-capacity servers,

the LBF has been drastically reduced and the load balancing on

the network is well underway. Also, due to the involvement of

all servers to balance the load, the proposed EVBLB algorithm

Fig. 7. Blocking rate versus queue size.

performs better than HEELS since the latter often selects a

limited number of edge servers by GSO algorithm. Our long-term

simulation results show that the proposed EVBLB algorithm,

which has the best LBF performance, reaches a steady state for

LBF = 0.02, indicating that the load difference between the

servers is approximately 2% in the set, which indicates a good

load balance. However, CooLoad has the lowest LBF in the ﬁrst

1300 seconds. This is mainly because it does not account for the

edge servers with high resource capacity and hence, does not

distribute more load on these servers. That is to say, the main

contribution of the CooLoad is to reduce the blocking rate of

user’s tasks, which this is evident in the Fig. 7.

As discussed earlier, new requests will be discarded when

server queue size exceeds a threshold. These requests are called

blocked requests, so if the load is balanced properly, the blocking

rate will also fall. As seen in Section II, when the queue size of

an edge server exceeds a threshold, CooLoad transmits the extra

requests to the neighboring server. This will reduce the blocking

rate, which is illustrated in Fig. 7. To accurately investigate this

metric, we set the server queue size to 500. We observe in Fig. 7

that EVBLB has a higher blocking rate than CooLoad while

HEELS has the worst performance among the three. When the

threshold is equal to the queue size, EVBLB, CooLoad, and

HEELS drop to minimum blocking rates of 2.5%,11%, and 38%,

respectively, which indicates a signiﬁcant difference between

CooLoad and the other two counterparts. Finally, it should be

noted that the non-uniformity of the behavior at some points of

output is due to the random number and size of input tasks, but

the overall behavior over time is quite clear.

VI. CONCLUSION AND FUTURE WO RK S

In this paper, we proposed a time-efﬁcient load balancing

approach in edge computing networks which was inspired by

Voronoi tessellations. The simulation results showed the supe-

riority of our algorithm as compared to two conventional load

balancing algorithms. We examined the proposed algorithm from

different practical aspects and reported the response time, request

completion time, load balancing factor, and queue size of edge

servers. As a future line of research, we intend to incorporate

priority of users’ requests in our algorithm. Also, machine

learning techniques can be used to predict the demand in the

vicinity of edge servers and improve the load balancing factor

by accounting for future requests.

ACKNOWLEDGMENT

This work was supported by the Social Policy Grant (SPG)

funded by Nazarbayev University, Kazakhstan.

REFERENCES

[1] J. Chakareski and S. Gupta, “Multi-connectivity and edge computing

for ultra-low-latency lifelike virtual reality,” in Proc. IEEE International

Conference on Multimedia and Expo (ICME), pp. 1–6, 2020.

[2] J. Lin, W. Yu, X. Yang, P. Zhao, H. Zhang, and W. Zhao, “An edge

computing based public vehicle system for smart transportation,” IEEE

Transactions on Vehicular Technology, vol. 69, no. 11, pp. 12635–12651,

2020.

[3] L. Greco, G. Percannella, P. Ritrovato, F. Tortorella, and M. Vento,

“Trends in IoT based solutions for health care: Moving AI to the edge,”

Pattern Recognition Letters, vol. 135, pp. 346–353, 2020.

[4] W. Shi, J. Cao, Q. Zhang, Y. Li, and L. Xu, “Edge computing: Vision and

challenges,” IEEE Internet of Things Journal, vol. 3, no. 5, pp. 637–646,

2016.

[5] H. Pydi and G. N. Iyer, “Analytical review and study on load balancing

in edge computing platform,” in Proc. IEEE International Conference on

Computing Methodologies and Communication (ICCMC), pp. 180–187,

2020.

[6] M. Kyryk, N. Pleskanka, M. Pleskanka, and P. Nykonchuk, “Load

balancing method in edge computing,” in Proc. IEEE International Con-

ference on Advanced Trends in Radioelectronics, Telecommunications

and Computer Engineering (TCSET), pp. 978–981, 2020.

[7] F. Aurenhammer, “Voronoi diagrams—a survey of a fundamental geo-

metric data structure,” ACM Computing Surveys (CSUR), vol. 23, no. 3,

pp. 345–405, 1991.

[8] R. Beraldi, A. Mtibaa, and H. Alnuweiri, “Cooperative load balancing

scheme for edge computing resources,” in Proc. IEEE International

Conference on Fog and Mobile Edge Computing (FMEC), pp. 94–100,

2017.

[9] F. Ebadifard and S. M. Babamir, “A PSO-based task scheduling

algorithm improved using a load-balancing technique for the cloud

computing environment,” Concurrency and Computation: Practice and

Experience, vol. 30, no. 12, p. e4368, 2018.

[10] R. Eberhart and J. Kennedy, “A new optimizer using particle swarm

theory,” in Proc. IEEE International Symposium on Micro Machine and

Human Science (MHS), pp. 39–43, 1995.

[11] Y. Dong, G. Xu, Y. Ding, X. Meng, and J. Zhao, “A ‘joint-me’task

deployment strategy for load balancing in edge computing,” IEEE

Access, vol. 7, pp. 99658–99669, 2019.

[12] K. N. Krishnanand and D. Ghose, “Detection of multiple source

locations using a glowworm metaphor with applications to collective

robotics,” in Proc. IEEE Swarm Intelligence Symposium (SIS), pp. 84–

91, 2005.

[13] A. R. Hameed, S. ul Islam, I. Ahmad, and K. Munir, “Energy-and

performance-aware load-balancing in vehicular fog computing,” Sustain-

able Computing: Informatics and Systems, vol. 30, p. 100454, 2021.

[14] J. Zhang, H. Guo, J. Liu, and Y. Zhang, “Task ofﬂoading in vehicular

edge computing networks: A load-balancing solution,” IEEE Transac-

tions on Vehicular Technology, vol. 69, no. 2, pp. 2092–2104, 2019.

[15] Y. Dai, D. Xu, S. Maharjan, and Y. Zhang, “Joint load balancing and

ofﬂoading in vehicular edge computing and networks,” IEEE Internet of

Things Journal, vol. 6, no. 3, pp. 4377–4387, 2018.

[16] T. Mekki, I. Jabri, A. Rachedi, and L. Chaari, “Software-deﬁned

networking in vehicular networks: A survey,” Transactions on Emerging

Telecommunications Technologies, p. e4265, 2021.

[17] M. De Berg, O. Cheong, M. Van Kreveld, and M. Overmars, “Compu-

tational geometry: introduction,” Computational geometry: algorithms

and applications, pp. 151–159, 2008.