1. Introduction

2. Related Works

3. Research Problem and Motivational Scenario

• Assumptions 

• We assume that the fog layer’s devices have limited RAM capabilities compared to cloud devices. For the experiments, we produced Synthetic data.
• There are 800 services with varying technical requirements. Similarly, we gathered data for fog devices with various capabilities.
• The services’ technical requirements, the fog devices’ capabilities, and the priorities of services are randomly generated.
• The technical needs of services and the device capabilities are known.
• We do not examine the connection between devices in our experiments since it is outside the scope of our study.

• Process 

• The model starts by building synthetic data for both the requirement of services and the capability of devices to prepare them for the allocation model.
• The fog devices’ capabilities are predefined, with fog devices being less capable when compared to cloud devices.
• The allocation technique is used to allocate between service needs and service priority, and device capabilities.
• Depending on the needs of the services, taking into consideration device capabilities and service priority, the services will be allocated across fog or cloud devices.

4. Methodology

4.1. Objective Function

We have a multi-criteria optimization problem. The goal is to maximize the weighted sum of two objective functions, f1(x) for decreasing delay and f2(x) for optimizing the usage of resources. The weighting variables w1 and w2 are utilized to balance the relevance of the two objectives and govern the trade-off between the opposing aims. These could be objectives for performance for our strategy. The function that has to be maximized is as described below:

$$\mathrm{maximize}fm\left(x\right)=-w_1·f_1\left(x\right)+w_2·f_2\left(x\right)$$

(1)

where $f_1\left(x\right)$ is the objective function for minimizing latency (i.e., the time it takes for a service to be allocated from fog to cloud), $f_2\left(x\right)$ is the objective function for maximizing fog resource utilization (i.e., using the fog devices as much as possible while minimizing resource wastage), x is a vector of variables, and $w_1$ and $w_2$ are weighting factors used to balance the importance of the two objectives.

The minus sign in front of $w_1·f_1\left(x\right)$ denotes that we are maximizing the negative of $f_1\left(x\right)$, which is the same as minimizing $f_1\left(x\right)$. Similarly, we are maximizing $f_2\left(x\right)$ by multiplying it with a positive weight $w_2$. The goal of integrating two objectives into a single objective function is to discover the optimal trade-off between the two of them. By maximizing $f_m\left(x\right)$, we mean finding x values that concurrently minimize $f_1\left(x\right)$ and maximum $f_2\left(x\right)$, with suitable weightings.

Best-Fit 

We give best-fit code in Algorithm 1 to maximize device usage while delivering services to devices based on their capabilities. We need the requirements for service $serReq$ and device capabilities $devCap$ as input. Then, for each service, we find the smallest possible device capability that may accommodate the current service.

$Servic{e}_{present}=\mathrm{find}\_\min (devCa{p}_1,devCa{p}_2,\dots ,devCa{p}_n)$

If a device is located, assign it to the present service. However, if a device cannot be discovered, discard that service and keep inspecting the other services. In the aforementioned method, we do not decompose the services into smaller services, but rather allocate them to one of the devices, either a fog device or a cloud device, according to their capabilities.

If a device is found, it should be assigned to the current service. If a device can not be found, disregard it and keep going through the other services. We do not break down the services into smaller ones, but rather assign them to one of the devices, either a fog device or a cloud device, according to their capabilities.

In other words, services are assigned to available devices according to best-fit criteria. The algorithm receives two parameters: $devCap$ and $serReq$. Each device’s capacity is represented by $devCap$, and the service request is represented by $serReq$. The algorithm begins with two for-loops that are nested. The outer loop begins at 0 and continues to a length of $serReq$, whereas the inner loop begins at 0 and continues to the length of $devCap$. The outer loop processes every service request one at a time, while the inner loop checks every device’s capacity to see if it can handle the present service request.

The $bestFitID$ is first assigned to -1. If the capacity of the device at index y is more than or equal to the capacity of the service request at index x, the $bestFitID$ is assigned to y within the inner loop. If $bestFitID$ remains -1, it indicates that no device is currently allocated to the service, and so the $bestFitID$ is assigned to y. If $bestFitID$ has recently been assigned, a comparison is done between the present device’s capacity ($devCap\left[y\right]$) and the device assigned previously ($devCap\left[bestFitID\right]$). If the current device’s capacity is smaller than that of the earlier assigned device, the $bestFitID$ is changed to the present device (y).

After the inner loop completes, if $bestFitID$ is not equal to -1, the current service is assigned to the device with the best fit ($bestFitID$). The allocation is documented by updating the $allocID$ list, and the capacity of the device is reduced by the service request. The algorithm will continue to run the outer loop until all of the service requests have been completed and the devices have been allocated to the services. The method returns $allocID$, which is the index of the device allocated to the service. The algorithm’s result is the services allocated to the devices.

Worst-Fit 

We give the worst fit code in Algorithm 2 for optimizing device usage while assigning services to devices and taking device capabilities into account. We need service requirements $serReq$ and device capabilities $devCap$ as input. Following that, we select each service and identify the most powerful device capable of supporting the current service.

$Servic{e}_{present}=\mathrm{find}\_\max (devCa{p}_1,devCa{p}_2,\dots ,devCa{p}_n)$

If a device is found, it should be assigned to the current service. If a device cannot be found, disregard it and continue investigating the other services.

The method then iterates through each service request in the $serReq$ array. It changes the value of $worstFitID$ to -1 for each service request, indicating that no device has been allocated to the service yet. The method then runs over the $devCap$ device capacities. If a device has adequate capacity to satisfy the current service request, the algorithm determines whether it is the first device discovered with sufficient capacity or if its capacity is more than the current $worstFitID$. If the device’s capacity is greater, the algorithm assigns $worstFitID$ to the present device’s ID.

Following the completion of the inner loop, the algorithm determines whether a device has been allocated to the present service request. If a device is allocated, the algorithm updates the $allocID$ list by distributing the current service request the value of $worstFitID$. The algorithm also decreases the allocated device’s capacity by the magnitude of the service request. The aforementioned stages are repeated by the algorithm for all service requests. After the outer loop has been completed, the algorithm returns the $allocID$ list, which contains the list of allocated services to devices.

First-Fit 

To maximize device utilization while allocating services to devices based on their capabilities, we give the first fit code in Algorithm 3. We need service requirements $serReq$ and device capabilities $devCap$ as input. Following that, we select every service and find out whether it is compatible with the current service. If the $devCap$ is equal to the $serReq$, assign and examine for the next $serReq$. If otherwise, proceed to investigate the next $devCap$.

In other words, the method has three inputs: $devCap$ (device capabilities), $serReq$ (service needs), and $allocID$ (allocated IDs). The algorithm’s purpose is to allocate services in $serReq$ to devices in $devCap$ and record the allocation in $allocID$.

The algorithm begins with two nested for-loops, where x is the length of $serReq$ and y is the length of $devCap$. The method examines if $devCap\left[j\right]$ is larger than or equal to $serReq\left[x\right]$ in every iteration of the inner loop. If the condition is met, the algorithm assigns the present service ($serReq\left[x\right]$) to the current device ($devCap\left[j\right]$) by changing $allocID\left[x\right]$ to y and lowering the current device’s capacity by the service requirement ($devCap\left[j\right]-=serReq\left[x\right]$). Finally, the algorithm exits the inner loop after locating a device capable of allocating the current service and proceeds to the following service in the outer loop. This operation is repeated by the algorithm until all services are assigned to devices.

Priority-Based Service Allocation 

We present the code of priority-based allocation in Algorithm 4 to select the service allocation process and if the services should be handled in the fog or cloud. We need service requirements $serReq$ and device capabilities $devCap$ as input. The services are then allocated to the fog devices using the $fogDevice(devCap,serReq)$ method. Following that, one of the algorithms presented previously will be executed. Following that, we will evaluate the capabilities of fog computing in order to allocate services. If no fog devices are available to handle the service, we assign it to cloud devices by calling and forwarding the remainder of the services to $cloudDevice\left(remainingSer\right)$.

Based on the importance of the service request, the algorithm decides whether to distribute services to fog or cloud devices. The algorithm prioritizes service requests by assigning them to the fog devices initially. The algorithm begins the process by determining the level of priority of the service demand. If the service is high-priority, the algorithm inputs the device capability and service requirement. If fog devices are capable of handling the services, they will be allocated to fog devices. If fog devices are unable to handle the low-priority service, the algorithm will allocate it to cloud devices instead.

The algorithm begins by allocating services to fog devices. To distribute services to fog devices, the algorithm employs one of three allocation algorithms: best-fit algorithm 1, worst-fit method 2, or first-fit algorithm 3. The method then iterates across the length of the service request using a for loop. In every iteration, the algorithm determines whether or not the service has already been assigned to a device by determining whether or not the $allocID$ is greater than -1. If the $allocID$ is not equal to -1, it is increased by one. If the $allocID$ is -1, the service request is saved in the $remainingSer$ list.

The algorithm checks if the $remainingSer$ list is empty at the end of the for loop. If the $remainingSer$ list is empty, the algorithm has been completed and all services have been allocated to the devices. If the $remainingSer$ list is not empty, the method "cloudDevice" with the $remainingSer$ list as input is called. The "cloudDevice" function is in charge of distributing the remainder of services to cloud devices. The priority-based allocation mechanism routes service requests to either the fog or cloud layers based on their priority. The method assigns services to fog devices utilizing one of three allocation techniques: best fit, worst fit, or first fit, with the remaining services given to the cloud.

Sort-Based Service Allocation 

We employed Dual-Pivot Quicksort, an efficient sorting algorithm commonly used in computer science and data processing applications, especially for sorting primitive data types such as int, double, and float. Dual-Pivot Quicksort, according to the authors’ findings [36], is typically quicker and more effective than alternative quicksort algorithms, especially on big datasets. They point out that Dual-Pivot Quicksort works effectively with both randomly ordered and partly sorted data, and that it has a minimal amount of comparisons and swaps.

Sorting may be a valuable technique in the context of fog computing for optimizing service allocation and lowering the level of complexity of service distribution for fog devices. Sorting the data prior to it reaching the fog devices makes it easier to deploy resources and maximize the network’s overall performance. We classify the technical needs of services in ascending order, from least to greatest, to assist service allocation techniques for fog devices. We also sort the capabilities of fog devices. This allows for faster and more efficient service allocation.

5. Experimental Setup

6. Results

7. Discussion and Evaluation:

8. Conclusions

9. Future Work

References

1. Betty Jane, J.; Ganesh, E. Big data and internet of things for smart data analytics using machine learning techniques. International conference on computer networks, big data and IoT. Springer, 2020, pp. 213–223.
2. Wang, N.; Varghese, B.; Matthaiou, M.; Nikolopoulos, D.S. ENORM: A framework for edge node resource management. IEEE transactions on services computing 2017, 13, 1086–1099. [Google Scholar] [CrossRef]
3. de Moura Costa, H.J.; da Costa, C.A.; da Rosa Righi, R.; Antunes, R.S. Fog computing in health: A systematic literature review. Health and Technology 2020, 10, 1025–1044. [Google Scholar] [CrossRef]
4. Pisani, F.; de Oliveira, F.M.C.; Gama, E.S.; Immich, R.; Bittencourt, L.F.; Borin, E. Fog computing on constrained devices: Paving the way for the future iot. Advances in Edge Computing: Massive Parallel Processing and Applications 2020, 35, 22–60. [Google Scholar]
5. Hong, C.H.; Varghese, B. Resource management in fog/edge computing: a survey on architectures, infrastructure, and algorithms. ACM Computing Surveys (CSUR) 2019, 52, 1–37. [Google Scholar] [CrossRef]
6. Ortiz, G.; Zouai, M.; Kazar, O.; Garcia-de Prado, A.; Boubeta-Puig, J. Atmosphere: Context and situational-aware collaborative IoT architecture for edge-fog-cloud computing. Computer Standards & Interfaces 2022, 79, 103550. [Google Scholar]
7. Alturki, B.; Reiff-Marganiec, S.; Perera, C.; De, S. Exploring the effectiveness of service decomposition in fog computing architecture for the Internet of Things. IEEE Transactions on Sustainable Computing 2019. [Google Scholar] [CrossRef]
8. Puliafito, C.; Mingozzi, E.; Longo, F.; Puliafito, A.; Rana, O. Fog computing for the internet of things: A survey. ACM Transactions on Internet Technology (TOIT) 2019, 19, 1–41. [Google Scholar] [CrossRef]
9. Laroui, M.; Nour, B.; Moungla, H.; Cherif, M.A.; Afifi, H.; Guizani, M. Edge and fog computing for IoT: A survey on current research activities & future directions. Computer Communications 2021, 180, 210–231. [Google Scholar]
10. Mahmud, R.; Toosi, A.N.; Ramamohanarao, K.; Buyya, R. Context-aware placement of industry 4.0 applications in fog computing environments. IEEE Transactions on Industrial Informatics 2019, 16, 7004–7013. [Google Scholar] [CrossRef]
11. Maia, A.M.; Ghamri-Doudane, Y.; Vieira, D.; de Castro, M.F. A multi-objective service placement and load distribution in edge computing. 2019 IEEE global communications conference (GLOBECOM). IEEE, 2019, pp. 1–7.
12. Behravesh, R.; Coronado, E.; Harutyunyan, D.; Riggio, R. Joint user association and VNF placement for latency sensitive applications in 5G networks. 2019 IEEE 8th International Conference on Cloud Networking (CloudNet). IEEE, 2019, pp. 1–7.
13. Lai, P.; He, Q.; Abdelrazek, M.; Chen, F.; Hosking, J.; Grundy, J.; Yang, Y. Optimal edge user allocation in edge computing with variable sized vector bin packing. Service-Oriented Computing: 16th International Conference, ICSOC 2018, Hangzhou, China, -15, 2018, Proceedings 16. Springer, 2018, pp. 230–245. 12 November.
14. Yu, N.; Xie, Q.; Wang, Q.; Du, H.; Huang, H.; Jia, X. Collaborative service placement for mobile edge computing applications. 2018 IEEE Global Communications Conference (GLOBECOM). IEEE, 2018, pp. 1–6.
15. Moubayed, A.; Shami, A.; Heidari, P.; Larabi, A.; Brunner, R. Edge-enabled V2X service placement for intelligent transportation systems. IEEE Transactions on Mobile Computing 2020, 20, 1380–1392. [Google Scholar] [CrossRef]
16. Maiti, P.; Shukla, J.; Sahoo, B.; Turuk, A.K. QoS-aware fog nodes placement. 2018 4th International Conference on Recent Advances in Information Technology (RAIT). IEEE, 2018, pp. 1–6.
17. Huang, M.; Liang, W.; Shen, X.; Ma, Y.; Kan, H. Reliability-aware virtualized network function services provisioning in mobile edge computing. IEEE Transactions on Mobile Computing 2019, 19, 2699–2713. [Google Scholar] [CrossRef]
18. Ma, H.; Zhou, Z.; Chen, X. Leveraging the power of prediction: Predictive service placement for latency-sensitive mobile edge computing. IEEE Transactions on Wireless Communications 2020, 19, 6454–6468. [Google Scholar] [CrossRef]
19. Peng, Q.; Xia, Y.; Feng, Z.; Lee, J.; Wu, C.; Luo, X.; Zheng, W.; Pang, S.; Liu, H.; Qin, Y. ; others. Mobility-aware and migration-enabled online edge user allocation in mobile edge computing. 2019 IEEE International Conference on Web Services (ICWS). IEEE, 2019, pp. 91–98.
20. Toka, L.; Haja, D.; Korösi, A.; Sonkoly, B. Resource provisioning for highly reliable and ultra-responsive edge applications. 2019 IEEE 8th International conference on cloud networking (CloudNet). IEEE, 2019, pp. 1–6.
21. Mseddi, A.; Jaafar, W.; Elbiaze, H.; Ajib, W. Intelligent resource allocation in dynamic fog computing environments. 2019 IEEE 8th International Conference on Cloud Networking (CloudNet). IEEE, 2019, pp. 1–7.
22. Badri, H.; Bahreini, T.; Grosu, D.; Yang, K. Energy-aware application placement in mobile edge computing: A stochastic optimization approach. IEEE Transactions on Parallel and Distributed Systems 2019, 31, 909–922. [Google Scholar] [CrossRef]
23. Haja, D.; Szalay, M.; Sonkoly, B.; Pongracz, G.; Toka, L. Sharpening kubernetes for the edge. Proceedings of the ACM SIGCOMM 2019 Conference Posters and Demos, 2019, pp. 136–137.
24. Mahmud, R.; Srirama, S.N.; Ramamohanarao, K.; Buyya, R. Profit-aware application placement for integrated fog–cloud computing environments. Journal of Parallel and Distributed Computing 2020, 135, 177–190. [Google Scholar] [CrossRef]
25. Deng, R.; Lu, R.; Lai, C.; Luan, T.H. Towards power consumption-delay tradeoff by workload allocation in cloud-fog computing. 2015 IEEE international conference on communications (ICC). IEEE, 2015, pp. 3909–3914.
26. Deng, R.; Lu, R.; Lai, C.; Luan, T.H.; Liang, H. Optimal workload allocation in fog-cloud computing toward balanced delay and power consumption. IEEE internet of things journal 2016, 3, 1171–1181. [Google Scholar] [CrossRef]
27. Gu, L.; Zeng, D.; Guo, S.; Barnawi, A.; Xiang, Y. Cost efficient resource management in fog computing supported medical cyber-physical system. IEEE Transactions on Emerging Topics in Computing 2015, 5, 108–119. [Google Scholar] [CrossRef]
28. Kashani, M.H.; Ahmadzadeh, A.; Mahdipour, E. Load balancing mechanisms in fog computing: A systematic review. arXiv preprint arXiv:2011.14706, arXiv:2011.14706 2020. [CrossRef]
29. Korte, B.H.; Vygen, J.; Korte, B.; Vygen, J. Combinatorial optimization; Vol. 1, Springer, 2011.
30. man Jr, E.C.; Garey, M.; Johnson, D. Approximation algorithms for bin packing: A survey.
31. Laabadi, S.; Naimi, M.; El Amri, H.; Achchab, B. A binary crow search algorithm for solving two-dimensional bin packing problem with fixed orientation. Procedia Computer Science 2020, 167, 809–818. [Google Scholar] [CrossRef]
32. Anand, S.; Guericke, S. A bin packing problem with mixing constraints for containerizing items for logistics service providers. Computational Logistics: 11th International Conference, ICCL 2020, Enschede, The Netherlands, –30, 2020, Proceedings. Springer, 2020, pp. 342–355. 28 September. [CrossRef]
33. Chraibi, A.; Alla, S.B.; Ezzati, A. An efficient cloudlet scheduling via bin packing in cloud computing. International Journal of Electrical and Computer Engineering 2022, 12, 3226. [Google Scholar] [CrossRef]
34. Goyal, T.; Singh, A.; Agrawal, A. Cloudsim: simulator for cloud computing infrastructure and modeling. Procedia Engineering 2012, 38, 3566–3572. [Google Scholar] [CrossRef]
35. Armant, V.; De Cauwer, M.; Brown, K.N.; O’Sullivan, B. Semi-online task assignment policies for workload consolidation in cloud computing systems. Future Generation Computer Systems 2018, 82, 89–103. [Google Scholar] [CrossRef]
36. Aftab, A.; Ali, M.A.; Ghaffar, A.; Shah, A.U.R.; Ishfaq, H.M.; Shujaat, M. Review on Performance of Quick Sort Algorithm. International Journal of Computer Science and Information Security (IJCSIS) 2021, 19. [Google Scholar]
37. Taylor, P. Statista Average Global Broadband Download & Upload Speed 2022, 2023.
38. Mandal, A.K.; Baruah, D.K.; Medak, J.; Gogoi, N.; Gogoi, P. CRITICAL SCRUTINYOF MEMORY ALLOCATION ALGORITHMS: FIRST FIT, BEST FIT AND WORST FIT. Turkish Journal of Computer and Mathematics Education (TURCOMAT) 2020, 11, 2185–2194. [Google Scholar]
39. Das, R.; Inuwa, M.M. A review on fog computing: issues, characteristics, challenges, and potential applications. Telematics and Informatics Reports, 1000. [Google Scholar] [CrossRef]