An Efficient Genetic Algorithm for Service Placement in Fog Computing
Dihia Bendjenahi, Chadia Moumeni and Malika Bessedik
Higher National School of Computer Science, Algiers, Algeria
Keywords:
Fog Computing, IoT, Service Placement Problem, Meta-heuristic Optimization Approach, Resource
Allocation.
Abstract:
The FSPP (Fog Service Placement Problem) involves the allocation of fog and cloud resources to IoT appli-
cations while meeting specific application requirements, including deadlines and minimizing response time.
This paper addresses the FSPP in heterogeneous fog-cloud computing environments using a genetic algorithm
(GA) approach. Our proposed GA aims to jointly maximize total resource utilization while respecting appli-
cation deadlines. The paper presents a detailed system model, problem formulation, and the proposed GA
methodology. Experimental results demonstrate the effectiveness of the GA approach in optimizing resource
allocation and meeting Quality of Service (QoS) requirements when compared to the first-fit heuristic and to
the random approach.
1 INTRODUCTION
In a rapidly evolving world shaped by technological
advancements, inter-connected devices have seam-
lessly integrated into various domains, including in-
dustry, education, healthcare, manufacturing, and
more, the IoT (Internet of Things) consequently
emerged as a dynamic and swiftly advancing field,
gaining popularity and demonstrating effectiveness
in providing many services to its users (Apat et al.,
2023).
During the initial stages of IoT development,
cloud computing served as the primary processing
layer, due to the limitations of computing capabilities
within IoT devices, which did not allow it to perform
all the operations required by IoT applications (Ali,
2015).
Cloud computing is an environment that offers
different computing resources to users with a pay-as-
you-go model. It consists of globally distributed data
centers, offering an economically viable alternative
to investing in physical infrastructure (Ahmad et al.,
2017). However, the evolution of IoT applications to-
wards increased criticality and complexity revealed
a need for real-time processing and rapid responses.
Cloud computing architectures which are centralized
in nature, struggled to satisfy the real-time demand of
IoT applications (Minh et al., 2017). This challenge
pushed researchers to introduce an innovative com-
puting architecture known as fog computing.
Fog computing was introduced by Cisco in 2012
(Bonomi et al., 2012) as an intermediate layer be-
tween end users and the cloud where the adoption
of fog computing for IoT applications significantly
improved the system’s performance, since process-
ing devices, or fog nodes, are now geographically
proximate to IoT devices. However, the limitations
of fog devices necessitated continued reliance on
cloud computing for complex and resource-intensive
tasks. This introduced a crucial challenge, known as
the FSPP (Fog Service Placement Problem) (Skar-
lat et al., 2017). The FSPP involves the allocation
of fog and cloud resources to IoT applications while
meeting specific application requirements, including
deadlines, minimizing response time, and managing
energy consumption. The complexity of this task
arises from the heterogeneous nature of fog devices,
each with varying processing capabilities, and the di-
verse computing resource demands of IoT applica-
tions. The main challenges of service placement in
the fog computing landscape are to improve the per-
formance of IoT applications as well as develop more
efficient and optimized algorithms for mapping appli-
cation modules or services to fog nodes (Salaht et al.,
2021). However, these challenges may require sig-
nificant research efforts and may not have straightfor-
ward solutions.
Due to the complexity of fog computing infras-
tructures, and the varying demands of IoT applica-
tions in terms of computing resources and delay sen-
Bendjenahi, D., Moumeni, C. and Bessedik, M.
An Efficient Genetic Algorithm for Service Placement in Fog Computing.
DOI: 10.5220/0013158900003890
Paper published under CC license (CC BY-NC-ND 4.0)
In Proceedings of the 17th International Conference on Agents and Artificial Intelligence (ICAART 2025) - Volume 3, pages 547-554
ISBN: 978-989-758-737-5; ISSN: 2184-433X
Proceedings Copyright © 2025 by SCITEPRESS – Science and Technology Publications, Lda.
547

sitivity, the service placement problem in fog comput-
ing is considered an NP-complete problem (Liu et al.,
2022), this means that it’s difficult to solve it to op-
timality in a decent time with limited computing re-
sources. Meta-heuristics can be employed to solve
the FSPP due to their ability to efficiently explore
the solution space and converge to high-quality so-
lutions for optimal placements in a shorter amount of
time. Different methods have been employed to solve
this problem such as Genetic Algorithms and Particle
Swarm Optimization algorithms are considered an in-
teresting choice for this problem, as they proved their
efficiency in solving a variety of optimization prob-
lems.
Therefore, In this paper, we address the FSPP
problem in heterogeneous fog-cloud computing
environments. We aim to jointly maximize the
total resource utilization while considering service
deadlines which helps to respect the delay-sensitivity
of applications and to efficiently utilize fog resources.
The rest of the paper is organized as follows;
The next section addresses the related literature. We
present system modeling, including system architec-
ture, resource and application models in Section 3.
Then, we provide the problem formulation, in Sec-
tion 4. The proposed approach is introduced in Sec-
tion 5. In Section 6, we evaluate the performance of
the proposed method. Finally, we conclude our study
in Section 7.
2 RELATED WORK
In the following, we review some of the studies that
have been conducted on this still-challenging issue.
The article (Skarlat et al., 2017) presents a frame-
work for fog computing comprising colonies of fog,
each with a primary node and fog cells dedicated to
task execution, along with middle-ware interfacing
between the fog and the cloud. A genetic algorithm
is employed to solve the FSPP, which aims to opti-
mize service allocation across resources within a fog
computing setup, prioritizing placing services on fog
nodes rather than using the cloud.
Aladwani (Natesha and Guddeti, 2021) developed
a task scheduling algorithm named Tasks Classifica-
tions and Virtual Machines Categorization (TCVC)
for scheduling IoT healthcare tasks in fog computing
based on tasks importance by using the MAX-MIN
algorithm.
Natesha and Guddeti (Hassan et al., 2020) ad-
dressed the FSPP with two-level resources using
docker and containers. The problem is formulated
as a multi-objective optimization problem that aims
to minimize the cost, energy consumption, and ser-
vice time by proposing an elitism-based genetic al-
gorithm (EGA) for preserving a set of best solutions
between the algorithm generations, avoiding altering
them with crossover or mutation operations.
The authors in (Djemai et al., 2019) addressed
the problem of service placement in fog–cloud en-
vironments by formulating it as a mixed integer lin-
ear programming (MILP) problem with the objective
of achieving high QoS, low energy consumption, and
maximum resource usage. The authors classified the
IoT services into critical and normal categories. Then,
they proposed two heuristic-based algorithms to solve
the problem. The first algorithm aims to provide high
QoS for critical services while the second focuses on
the energy efficiency of the fog environment.
The research paper (Santoyo-Gonz
´
alez and
Cervell
´
o-Pastor, 2018) proposes an infrastructure and
applications model for IoT, as well as an optimization
strategy that takes into account the system’s energy
consumption, for the placement of energy-efficient
IoT services on a fog computing infrastructure. The
proposed approach uses discrete particle swarm
optimization algorithm (DPSO) to optimize the
placement of IoT services taking into account energy
consumption and application requirements. The
article presents simulation results that demonstrate
the effectiveness of the proposed DPSO approach
in the realization of an energy efficient IoT service
placement on a fog infrastructure.
The authors of (Canali and Lancellotti, 2019)
stress the need to optimize infrastructure placement
service to minimize delays in the service access layer.
The authors models the FSPP in a Fog Comput-
ing/NFV environment as a linear programming prob-
lem in mixed integer format. Then, they propose a
heuristic solution taking into account requirements of
the 5G mobile network.
Authors in (Jamil et al., 2019) addressed the use
of genetic algorithms for solving the FSPP. They pro-
posed a heuristic based on genetic algorithms to pro-
vide a scalable solution for mapping sensors over fog
nodes.
Resource utilization is one of the critical objec-
tives in fog computing. Therefore, most of the studied
works focus on providing an efficient placement that
maximizes resource usage. However, the challenges
persist in efficiently distributing resources and priori-
tizing services in fog-cloud computing environments.
As a result, we propose a service placement approach
that efficiently allocates the cloud-fog resources while
considering the different requirements of IoT applica-
tions.
ICAART 2025 - 17th International Conference on Agents and Artificial Intelligence
548

Figure 1: Fog Computing Architecture (Lin et al., 2020).
3 SYSTEM MODEL
3.1 System Architecture
In this section we present the used architecture of fog
computing.
The fog computing architecture consists of three
main layers, the top one is the cloud layer, the inter-
mediate layer consists of fog devices or fog nodes,
while the bottom layer is the IoT layer that includes
IoT devices. Figure 1 shows the used architecture of
fog computing.
It is advisable to keep all the given values because
any text or material outside the aforementioned mar-
gins will not be printed.
3.1.1 IoT Layer
This layer consists of sensors and actuators. Sen-
sors like cameras, heartbeat sensors, humidity sen-
sors, temperature sensors, GPS sensors, etc, collect
raw data from the external environment, convert it to
signals, and transmit them to fog nodes for further
processing. After processing, fog nodes send the re-
sults back to actuators that work as controllers to per-
form the necessary actions accordingly (Dokeroglu
et al., 2019).
3.1.2 Fog Layer
The fog layer loosely integrates both cloud and IoT
layers associated with the fog, thereby enabling in-
dependent evolution and a high degree of interaction
between multiple layers (Dokeroglu et al., 2019). The
fog layer is composed of heterogeneous fog devices
having limited computing, storage, and networking
capabilities e.g. routers, switches, proxy servers, and
cellular base stations (Dokeroglu et al., 2019).
3.1.3 Cloud Layer
The cloud gets data from networking devices for long
term behavior and data analysis and returns the re-
sults back to fog devices for further necessary actions
(Dokeroglu et al., 2019).
4 PROBLEM FORMULATION
We assume that the services of each application can
be placed and processed by any of its accessible fog
nodes if it has the necessary computing capabilities
and each node can offload its workload to the cloud if
necessary.
As a result, in our model, we focus on maximiz-
ing resource usage as the objective of the FSP prob-
lem while satisfying the problem constraints which
are described in 4.4.
Let x
i j
be a binary variable that denotes whether
an IoT service S
i
is placed on the fog node F
j
. It is
formulated as follows:
x
i j
=
(
1 if service S
i
is placed on the fog node F
j
0 otherwise
4.1 Application Model
We represent IoT applications as a set of services that
are submitted by different IoT devices to fog nodes
for execution. Each application A
k
consists of a set of
services S
i
.
Each service S
i
is characterized by its computing
requirements; CPU demand (in million instructions
per second – MIPS), memory demand (in megabyte
– MB), storage demand (in megabyte – MB), its
deadline (in milliseconds – ms), and size (in million
instructions – MI) as follows:
S
i
= { S
CPU
i
, S
RAM
i
, S
STOR
i
, S
DL
i
, S
Size
i
}
4.2 Resource Model
The fog nodes are represented as a non-directed
graph G = (F, E), where F represents the set of fog
nodes , and E is the set of links between fog nodes.
Every fog resource has the following features:
F
j
= { CPU
j
, RAM
j
, ST OR
j
}
Where CPU represents the processing power,
which is the number of instructions that can be exe-
cuted per second CPU
j
, the memory size RAM
j
, the
permanent storage size ST OR
j
available.
An Efficient Genetic Algorithm for Service Placement in Fog Computing
549

4.3 Resource Utilization
Resource usage represents the ratio between the re-
sources consumed by the served applications and the
total available resources, i.e. the percentage of the us-
age of resources by IoT services in the fog system,
which is defined as follows:
RU
F
j
=
m
∑
j=1
n
∑
i=1
x
i j
· RC
S
i
R
F
j
(1)
Where RC
S
i
represents the resource demand of the
IoT service S
i
, m is the number of fog nodes, n is the
number of services, and R
F
j
is the resource capacity
of the fog node F
j
.
Besides, P
S
i
indicates the execution priority of S
i
.
Therefore, we classify services based on their dead-
line (DL) as shown in equation 2.
P
S
i
=
1
S
DL
i
(2)
4.4 Objective Function
We formulate the FSPP model for optimizing fog
nodes resource usage using 7 while satisfying a set
of constraints as follows:
RS
i
≤ S
DL
i
, ∀i ∈ [1, n], ∀F
j
∈ FN (3)
Where RS
i
as denoted in equation 3 is the response
time for the service S
i
, which is calculated as follows:
RS
i
=
∑
S
i
∈A
k
latency
proc
j
+ latency
Com
latency
proc
i
=
S
Size
i
CPU
j
latency
Com
=
data
size
jk
BW
jk
BW
jk
in Mb/s is link bandwidth.
And for each fog node:
∑
∀S
i
S
CPU
i
· x
i j
≤ CPU
j
(4)
∑
∀S
i
S
RAM
i
· x
i j
≤ RAM
j
(5)
∑
∀S
i
S
STOR
i
· x
i j
≤ ST OR
j
(6)
Equations 4 through 6 denote that no fog node
should exceed its available computing and storage
resources.
The objective function for our FSPP is presented
in Eq 7, where the aim is to maximize fog node
utilization. Therefore, we compute the average re-
source utilization across all fog nodes as illustrated
in the equation. Hence, providing an efficient re-
source distribution that reduces cloud costs and laten-
cies (in terms of cloud computing and communication
resources).
Maximize : OF =
1
m
·
m
∑
j=1
([RU
F
j
< (1 − y)]) (7)
Where a resource utilization value of 1 represents
using 100% of the resources available on the fog
node. y is a constant that allows us to define the per-
centage of resources used for tasks other than service
placement, like monitoring and system updates, so if
the value of y is 0.1, 10% of the fog nodes resources
would be left unused for system related tasks.
5 AN EFFICIENT GENETIC
ALGORITHM FOR SERVICE
PLACEMENT IN FOG
COMPUTING
We present a GA-based approach to address the FSP
problem by proposing strategy that efficiently allo-
cates tasks to fog nodes while optimizing resource
utilization and meeting Quality of Service (QoS) re-
quirements (e.g. application deadline) as illustrated in
Figure 2.
A genetic algorithm aims to generate a global op-
tima solution through the mechanisms of selection,
crossover, and mutation, a set of candidate solutions
are maintained in each iteration (Das et al., 2018; Xue
et al., 2021). This procedure is repeated until the ter-
mination criterion is satisfied (Xue et al., 2021).
Next we introduce the different components of our
approach.
5.1 Solution Representation
Each chromosome represents a potential solution, it
consists of several genes, indicating the allocation of
tasks to fog nodes in our case. Every chromosome
has a fitness value, which is obtained by measuring
the quality of the solution represented by the chromo-
some. A solution is represented by a list in our con-
text, where the index of the list is the ID of the task,
and the element at that index represents the ID of the
fog node executing the task.
ICAART 2025 - 17th International Conference on Agents and Artificial Intelligence
550

Figure 2: GA Diagram.
5.2 Initial Population
The population is initially generated in a random
manner and all of the services are mapped to random
fog nodes after prioritizing the IoT applications based
on their deadline.
5.3 Fitness Evaluation
Fitness values are calculated using equation 7. We
calculate the fitness score of a solution based on the
percentage of fog nodes where the resource usage ex-
ceeded the available resources, and the number of fog
nodes used in the solution. For each fog node that
does not exceed its available resources while allocat-
ing services, we increment the fitness value by 1. The
better the solution, the bigger fitness value, which
helps ensure that only feasible and good quality so-
lutions are chosen.
Note that fitness values undergo normalization by
dividing them by the number of fog nodes present in
the architecture. This process guarantees that fitness
values fall within the range of 0 to 1.
5.4 Crossover Operation
We used uniform crossover, where two parents are
randomly selected from the current population, and
for each gene of the chromosome, a random gene is
chosen either from the first or the second parent (with
0.5 selection probability for both), until we get our
new offspring solution.
5.5 Mutation Operation
Random mutation was used, where each gene is mu-
tated with a small probability, to explore neighboring
solutions and introduce new genetic material into the
population. The exploration rate is controlled by the
mutation rate parameter, to help balance between ex-
ploration and exploitation.
5.6 Selection Operation
For each generation, the parent chromosomes are re-
placed by their offspring to form the next generation.
Given that the parent selection in the crossover oper-
ation is random, some parents can have multiple off-
spring individuals, where others can have none.
5.7 Correction Mechanism
In case of invalid solutions, i.e. solutions violating re-
source constraints, a correction mechanism is applied
to adjust task allocations and ensure solutions feasi-
bility.
The correction mechanism verifies whether fog
nodes exceed their available resources during the allo-
cation of applications services, if a fog node is found
to be executing more services than it can handle, the
system isolates the services that are causing the viola-
tion, and attempts to find alternative execution nodes
with enough available resources for each service. If
a service requires more resources than any fog node
can accommodate, it will be placed on the cloud as
shown in Figure 3, which ensures the efficient usage
of fog nodes and reduces the delay.
Figure 3: Example of the process of correcting an invalid
solution.
Due to that GA seeks to explore a broad variety
of potential solutions, services are assigned to fog
nodes at random, which may result in resource ca-
pacity exceeding capacity, particularly in the early
An Efficient Genetic Algorithm for Service Placement in Fog Computing
551

phases of the optimization process. To guarantee that
the solution satisfies resource limitations, a correc-
tion mechanism is implemented for all invalid solu-
tions, whereby overloaded services are offloaded to
the cloud. This guarantees that a solution gets mod-
ified to become viable in later iterations, even if the
initial solution is invalid.
5.8 Top Solutions Preservation
A list containing the best solutions is maintained, stor-
ing the best solution from each generation. By the end
of the evolution process, the best solution (with the
highest fitness value) is selected from that list as the
final solution.
In summary, the proposed genetic algorithm-
based methodology offers a promising approach to
address the fog service placement problem, enabling
efficient resource allocation and QoS optimization in
fog computing environments.
6 PERFORMANCE EVALUATION
6.1 Experimental Setup
To evaluate the effectiveness of our proposed method,
we conducted a series of experiments using different
parameters, and compared our genetic algorithm to
a First-Fit heuristic, where each task is assigned to
the first fog node that has enough resources to exe-
cute it (Brent, 1989), and a random method, which
selects a random solution from the solution space, i.e.
it chooses a random execution node for each service.
The datasets used in these experiments are de-
tailed in 1.
Table 1: Datasets Information.
Test number Fog nodes number Tasks number
1 10 20
2 15 30
3 25 75
The fog nodes and services details are given in ta-
bles 2 and 3.
Table 2: Fog Nodes Characteristics.
ID from 0 to (number of fog nodes - 1)
CPU
j
[500-3000] (MIPS)
RAM
j
[256-2048] (MB)
ST OR
j
[256-2048] (MB)
The Java programming language (JAVASE-17)
was used in the experimentation process. Eclipse was
Table 3: IoT Services Characteristics.
ID from 0 to (number of tasks - 1)
S
CPU
i
[80-300] (MIPS)
S
RAM
i
[100-1024] (MB)
S
STOR
i
[0-512] (MB)
S
DL
i
[10-30] (s)
used as an IDE (2022-09 version) running on Win-
dows 10.
The used parameters of our genetic algorithm are:
number of generations is 10, population size is 25 and
mutation rate is 100.
6.2 Experimentation Results
The following results represents the averages of 100
executions. We selected different datasets where the
allocation outcome can vary.
For the first set of experiments, the allocation pro-
cess was relatively easy, and this is confirmed with
the high accuracy of the obtained solutions, both with
the genetic approach and the first fit algorithm. The
second and third sets of experiments had a more chal-
lenging allocation process due to the specifications of
the fog nodes and services.
The time was measured in milliseconds (ms), and
the fitness value is between 0 and 1. During each run
of the algorithms, we shuffle the datasets used, to help
us obtain more accurate and less biased results. The
detailed values are shown in the graphs given below
in figures 4 through 8.
Figure 4 and 5 show the average execution times
and average fitness values for each method, respec-
tively. Whereas figures 6, 7 and 8 show the fitness
value of each algorithm execution for the three meth-
ods.
Table 4: Genetic Algorithm Results.
NUM GA Exec Time GA Fitness
1 15.756929 0.897
2 13.229277 0.336
3 31.985196 0.2696
Table 5: First Fit Heuristic Results.
NUM FF Exec Time FF Fitness
1 0.214907 0.814
2 0.477475 0.282
3 0.49348 0.212
In order to further improve the proposed genetic
algorithm, we experimented with different parameters
and methods used for each step of the algorithm, the
details are provided in the table 7.
ICAART 2025 - 17th International Conference on Agents and Artificial Intelligence
552

Table 6: Random Algorithm Results.
NUM RNDM Exec Time RNDM Fitness
1 0.017884 0.406
2 0.024984 0.046
3 0.053224 0.0459
Table 7: Methods Testing Details.
Step Method Tested
Selection - by rank
- tournament
- random
Crossover - one-point
- two-points
- uniform
Replacement - offspring replace parents with a weak fitness value
- best N individuals (from offspring and parents)
- replace parents by offspring
The figures 4 to 6 present the detailed evaluation
results from the 100 runs of the algorithm with each
dataset presented before. The execution times and
fitness values are compared for the three algorithms
at hand, which are the genetic algorithm, the first-fit
heuristic, and the random solution generator.
Figure 4: Fitness values for the first set of experiments.
Figure 5: Fitness values for the second set of experiments.
Figure 6: Fitness values for the third set of experiments.
6.3 Results Discussion
While the first fit algorithm initially seems promising
due to its ability to yield favorable results within a rea-
sonable time frame, our experiments revealed a sig-
nificant drawback, where we observed that shuffling
the dataset impacts the accuracy of its solutions, mak-
ing it less suitable for the dynamic nature of the fog
service placement problem. In contrast, the genetic
algorithm remained unaffected by dataset shuffling,
where each placement round introduces new data in-
puts, and the genetic algorithm emerges as a more ro-
bust and versatile solution.
Moreover, the parameters of the genetic algo-
rithm, including the number of generations, mutation
rate, and population size, were fixed through itera-
tive experimentation with various values. Each ad-
justment was methodically tested to isolate its impact
on solution quality.
Among the selection methods tested, tournament
selection outperformed ranking and random selec-
tions. This superiority can be attributed to its ef-
fectiveness in exploration during the algorithm’s pro-
gression. Consequently, it was integrated into the fi-
nal algorithm, wherein each parent’s selection proba-
bility is determined by its fitness.
In terms of crossover methods, the uniform
crossover demonstrated superior performance com-
pared to one-point and two-point crossovers. Its abil-
ity to produce more accurate results led to its selection
for the final genetic algorithm.
Regarding replacement strategies, replacing par-
ents with their offspring emerged as the most effec-
tive approach. This method facilitated extensive ex-
ploration of the solution space, thereby mitigating the
risk of getting trapped in local optima. Consequently,
it was chosen over alternatives such as replacing par-
ents with better offspring or selecting the N best indi-
viduals.
These refined methodologies culminated in the de-
velopment of our final genetic algorithm, which ex-
hibited commendable performance compared to both
random solutions and those generated by the first-fit
heuristic.
In our specific scenario, incorporating gateways
and cloud data-centers wasn’t necessary, as our ob-
jective was to allocate all services exclusively to the
fog nodes. Therefore, the complexity of managing
offloaded services to other components of the infras-
tructure was not a factor in our analysis.
7 CONCLUSIONS
In this paper, we studied the service placement prob-
lem in fog computing by proposing a genetic al-
gorithm that efficiently utilizes fog resources while
meeting IoT applications’ deadlines to optimize re-
An Efficient Genetic Algorithm for Service Placement in Fog Computing
553

source utilization and maximize the number of ac-
cepted services. We evaluated our proposed approach
against a random solution and a first-fit heuristic-
generated solution by using different datasets. Al-
though the genetic algorithm scored better accuracy
than both the random and the first-fit approach in most
of the experiments, there is still room for improve-
ment.
Our next research plan is to consider other objec-
tives such as delay, energy consumption, and so on,
which makes the model able to quantify the quality of
a given solution with more precision, as well as using
a fog computing simulator rather than a programming
language alone, to be able to simulate a complete fog
computing environment.
REFERENCES
Ahmad, U., Mohan, H., and Bakht, H. (2017). Cloud com-
puting - a comprehensive definition. Journal of Com-
puting and Management Studies.
Ali, Z. H. (2015). Internet of things (iot): Definitions, chal-
lenges and recent research directions. International
Journal of Computer Applications, 128.
Apat, H. K., Nayak, R., and Sahoo, B. (2023). A com-
prehensive review on internet of things application
placement in fog computing environment. Internet of
Things, 23:100866.
Bonomi, R., Milito, J., Zhu, J., and Addepalli, S. (2012).
Fog computing and its role in the internet of things. In
Proceedings of the first edition of the MCC workshop
on Mobile cloud computing.
Brent, R. P. (1989). Efficient implementation of the first-
fit strategy for dynamic storage allocation. ACM
Transactions on Programming Languages and Sys-
tems, 11:388–403.
Canali, C. and Lancellotti, R. (2019). Gasp: Genetic al-
gorithms for service placement in fog computing sys-
tems. Algorithms, 12:201.
Das, A. K., Sengupta, S., and Bhattacharyya, S. (2018). A
group incremental feature selection for classification
using rough set theory based genetic algorithm. Ap-
plied Soft Computing, 65:400–411.
Djemai, P., Stolf, T., Monteil, T., and Pierson, J.-M. (2019).
A discrete particle swarm optimization approach for
energy-efficient iot services placement over fog in-
frastructures. In 2019 18th International Symposium
on Parallel and Distributed Computing (ISPDC).
Dokeroglu, T., Sevinc, E., Kucukyilmaz, T., and Cosar, A.
(2019). A survey on new generation metaheuristic
algorithms. Computers and Industrial Engineering,
137:106040.
Hassan, O., Azizi, S., and Shojafar, M. (2020). Priority, net-
work and energy-aware placement of iot-based appli-
cation services in fog-cloud environments. IET Com-
munications, 14(13):2117–2129.
Jamil, B. et al. (2019). A job scheduling algorithm for delay
and performance optimization in fog computing. Con-
currency and Computation: Practice and Experience,
32(7).
Lin, C.-C., Deng, D.-J., Suwatcharachaitiwong, S., and Li,
Y.-S. (2020). Dynamic weighted fog computing de-
vice placement using a bat-inspired algorithm with
dynamic local search selection. Mobile Networks and
Applications, 25:1805–1815.
Liu, C., Wang, J., Zhou, L., and Rezaeipanah, A. (2022).
Solving the multi-objective problem of iot service
placement in fog computing using cuckoo search algo-
rithm. Neural Processing Letters, 54(3):1823–1854.
Minh, Q. T., Nguyen, D. T., Le, A. V., Nguyen, H. D., and
Truong, A. (2017). Toward service placement on fog
computing landscape. In 2017 4th NAFOSTED Con-
ference on Information and Computer Science, pages
291–296, Hanoi. IEEE.
Natesha, V. and Guddeti, R. M. (2021). Adopting
elitism-based genetic algorithm for minimizing multi-
objective problems of iot service placement in fog
computing environment. Journal of Network and
Computer Applications, 178:102972.
Salaht, F. A., Desprez, F., and Lebre, A. (2021). An
overview of service placement problem in fog and
edge computing. ACM Comput. Surv., 53:1–35.
Santoyo-Gonz
´
alez and Cervell
´
o-Pastor, C. (2018). Latency-
aware cost optimization of the service infrastructure
placement in 5g networks. Journal of Network and
Computer Applications, 114:29–37.
Skarlat, M., Nardelli, S., Schulte, M., Borkowski, M., and
Leitner, P. (2017). Optimized iot service placement
in the fog. Service Oriented Computing and Applica-
tions, 11(4):427–443.
Xue, Y., Zhu, H., Liang, J., and Słowik, A. (2021). Adap-
tive crossover operator based multi-objective binary
genetic algorithm for feature selection in classifica-
tion. Knowledge-Based Systems, 227:107218.
ICAART 2025 - 17th International Conference on Agents and Artificial Intelligence
554