CC BY
11
ADAPTIVE LOAD BALANCING IN CLUSTER GRID SYSTEMS
Semenchenko V.,
Student of the 6th year of the NTUU "Kyiv Polytechnic Institute. Igor Sikorsky", Faculty ofInformatics and
Computer Science, Department of Computer Engineering
Simonenko V.
Professor of the NTUU "Kyiv Polytechnic Institute. Igor Sikorsky", Faculty of Informatics and Computer
Science, Department of Computer Engineering
Abstract
This article concerns the task of load balancing in cluster grid systems. The proposed system takes into account datasets that computing nodes may have from executing previous tasks thus increasing the overall effectiveness of the system as well as queuing method that allows to take advantage of this. Keywords: clusters, grid systems, distributed computing, load balancing.
As time goes on, the complexity and scale of scientific and business tasks increases as does computing power. But the improvement speed of computing units slows down in accordance with Moore's Law. To mitigate this multiple computers connected with each other are used to compute such tasks. But one of the hurdles of this is the problem of load balancing.
To simplify further explanations, we adopt the following terminology:
- task T - the task that was created by the user and transferred to the system for execution
- resource R - a computing node that will calculate the tasks received by the system
The system receives a number of tasks. Each task Ti can be characterized by the following time parameters:
- t i in - time of receipt of the i-th task in the system
- t i out - critical time of exit of the i-th task from system
- Ati exec - the planned execution time of the i-th task in relative units on the computing resource of the cluster, taking into account the transmission of input data
Since the critical exit time depends on the system load, as well as on the task itself, and the user cannot provide the optimal critical exit time of the task, we calculate the minimum critical exit time of the task as:
At" = t- J. U „yn tj wait
out min Li exec ' Zjj = 1
(1)
where tj wait - the maximum time to wait for the task from the resource queue Rj for the last hour. And thus we have:
Ati out min < Ati out (2)
Given the fact that in a cluster system, all nodes have the same performance, you can define the task execution time in any node of the system as:
= ti 1 e
■■■ ti j-1 exec ti j exec (3)
In addition, it is also necessary to take into account the time of the scheduler tplan, spent on the initial planning of the task. With this in mind, adjust the start time of the task At as follows:
ti in ti in tpian
(4)
Let's take one base runtime for all nodes. Then the maximum task execution time can be defined as:
But at the time t of receipt of a new task in the system, the resource may be busy performing another task. Let's calculate the time required to complete the previous task Ti-i, assigned to the resource Rj:
Atj compl tcur
-ti-
(7)
where tcur - the current time of receipt of the task Ti in system, ti-i out - critical exit time of the task Ti-i.
With this in mind, we get the time to complete the task Ti on resource Rj:
Mij' = Ati.' - tj compl (8)
The result is a connectivity matrix M, where each element determines the execution time of the task Ti, which entered the system and is ready for execution, on the resource Rj.
In many cases, different tasks can be performed using the same data set. This can be either modified versions of previous tasks or completely different tasks, or this input data set was loaded in advance when the task was waiting in line.
Usually the input data set is deleted immediately after receiving the result of the calculation of the problem. But because the data transfer also takes some time, resources can temporarily store these datasets before deleting them.
Thus, it is possible to form a matrix D, each element of which determines whether the resource Rj stores the data set required to perform the task Ti.
Thus, it is possible to form a matrix D, each element of which determines whether the resource Rj stores the data set required to perform the task Ti.
Let's take the time required to transmit the input data for the task Ti as Ati trans. Thus, as a result, we have a matrix M', where each element determines the adjusted value of the execution time, taking into account the presence of input tasks Ti on the computing resource of the cluster Rj:
Mij' = Mij + Ati trans * Dij
(9)
Since the calculated execution time Mij' of the task Ti on the resource Rj can not exceed the planned execution time of this task Ati exec,, and must be greater than 0 we have:
0 < Mij' < Ati exec (10)
To simplify the calculations, we form a new
Ati = ti in' - ti (
(6)
M- " < At-
ij i e
- M
(11)
out
t
matrix Mij'', each element of which is defined as:
where negative values determine assignments that cannot be executed before the assigned critical output time t i out, and positive values determine assignments that will allow tasks to be executed by the assigned critical time.
Let's filter the assignments to form the initial search area. Since the positive values of the matrix M7/ correspond to the purposes that are valid, i.e. can be part of the solution, assign all the positive elements a value of 0, and all the negative elements change the sign to the opposite. As a result, we obtain a new matrix M///.
After that, according to the Hungarian algorithm, we will form a new search area. From each element of the row of the resulting matrix subtract the smallest element of this row. From each element of the column of the matrix subtract the smallest element of this column.
As a result of the performed actions in each row and each column we have a zero element in the formed
matrix M////.
After that, the problem is reduced to finding the maximum pairing in a bipartite graph, ie finding destinations, where each row and each column will have only one 0.
As a result, we will have one task assigned to each resource. After that, the assigned tasks are added to the queues of relevant resources. If the queue of unassigned tasks is not empty, you need to select the next set of tasks, and perform their assignment taking into account the offset of the current time tcur of receipt of the task Ti in the system as the sum of the execution time of previous tasks in the queue. Appointments occur until the queue of incoming tasks that have not been assigned becomes empty.
This paper uses a queuing method with both load balancer queue and local node queues in which the balancer sends a queue to each node, and when a new task arrives and allocates tasks to nodes, allows to send a new queue to the node, where the order of tasks can be changed, tasks can be deleted or added.
This allows to start downloading input dataset of the task before the the previous task finishes executing. And if the system has a stable number of tasks in the queue, this can make changes to the task allocation more efficiently than when the tasks transferred to the node become tied to it and can not be assigned to other nodes.
This approach also has no disadvantage of waiting for the next task when performing the previous and canceling the current task because the node can immediately begin to perform the next.
To improve the response time of individual tasks, it's suggested to assign tasks closest to the critical time, and then in each queue for each node, try to swap tasks
so that the tasks with the shortest expected execution time are at the beginning, and the longest are at the end, while checking that none of them do not exceeded the critical time. This allows to improve the execution time of small tasks without affecting the overall execution time of the queue.
References
1. Foster I. The Anatomy of the Grid: Enabling Scalable Virtual Organizations. In: Sakellariou R., Gurd J., Freeman L., Keane J. (eds) Euro-Par 2001 Parallel Processing. Euro-Par 2001. Lecture Notes in Computer Science, vol 2150. Springer, Berlin, Heidelberg, 2001. URL: https://doi.org/10.1007/3-540-44681-8_1
2. Irfan Habib, Kamran Soomro, Ashiq Anjum, Richard McClatchey, Arshad Ali, Peter Bloodsworth, PhantomOS: A Next Generation Grid Operating System, 2007. URL: https://arxiv.org/abs/0707.0762
3. Krystek M., Kurowski K., Oleksiak A., Rzadca K. Comparison Of Centralized And Decentralized Scheduling Algorithms Using GSSIM Simulation Environment. In: Gorlatch S., Fragopoulou P., Priol T. (eds) Grid Computing. Springer, Boston, MA, 2008. URL: https://doi.org/10.1007/978-0-387-09457-1_16
4. Padala P., Wilson J.N. GridOS: Operating System Services for Grid Architectures. In: Pinkston T.M., Prasanna V.K. (eds) High Performance Computing - HiPC 2003. HiPC 2003. Lecture Notes in Computer Science, vol 2913. Springer, Berlin, Heidelberg, 2003. URL: https://doi.org/10.1007/978-3-540-24596-4_38
5. Peter Greenhalgh. ARM, Big.LITTLE Processing with ARM Cortex™-A15 & Cortex-A7, 2011. URL:
https://web.archive.org/web/20120417183714/http://w ww.arm.com/files/downloads/big.LITTLE_Final.pdf
6. Rishabh Sinha. Cluster Computing: Definition, Architecture, and Algorithms. URL: https://www.esds.co.in/blog/cluster-computing-definition-architecture-and-algorithms
7. Srinivas Nimmagadda, Ilan Harari. Scalability issues in cluster computing operating systems, 2000. URL:
https://www.researchgate.net/publication/228603082_ Scalability_issues_in_cluster_computing_operating_s ystems
8. Sushil Kumar, Deepak Singh Rana. Various Dynamic Load Balancing Algorithms in Cloud Environment: A Survey. In: International Journal of Computer Applications (0975 - 8887) Volume 129 - No.6, 2015. URL: https://www.ijcaonline.org/research/vol-ume129/number6/kumar-2015-ijca-906927.pdf
