Research on Cloud Task Scheduling Algorithm with Conflict Constraints Based on Branch-and-Price

Abstract

The low-energy task scheduling of cloud computing systems is a key issue in the field of cloud computing. Nevertheless, existing works on task scheduling lack consideration of the conflict relationship between tasks and focus on heuristic and other approximate algorithms. Thus, solving the problem of minimizing energy consumption with antiaffinity constraints between tasks and designing an efficient exact algorithm for task scheduling is a major challenge. This paper abstracts the problem into a multidimensional bin packing model with conflict constraints. The model is decomposed by the Lagrange relaxation principle and Dantzig–Wolfe decomposition principle. Moreover, we propose an accurate algorithm based on branch-and-price. The algorithm benefits from a new initial solution generation scheme based on maximum cliques and dominant resource proportion, and a multipattern branching strategy. The efficiency of the proposed branch-and-price algorithm is verified by a number of numerical experiments.

1. Introduction

With the increasing development of cloud computing technology, the huge energy consumption in cloud computing has attracted wide attention. The proportion of energy consumption in cloud data centers is estimated as 1.4% of the global energy consumption, which increases by approximately 12% annually [1]. Currently, many studies in cloud computing focus on task scheduling algorithms with the goal of reducing energy consumption [2,3]. Most of the existing works use heuristic algorithms, random algorithms, and intelligent algorithms to solve the approximate optimal solution of the problem [4,5].

To reduce the energy consumption of cloud computing systems, an effective and common method is to schedule tasks to as few virtual machines (VMs) as possible [6]. However, the existing studies lack research on the stability of cloud computing system, especially without considering the antiaffinity constraints between tasks. Kubernetes [7] first introduced the new feature of node antiaffinity. This feature can improve the usability and robustness of the applications. Similarly, OpenStack [8] has antiaffinity scheduler filter. In a cloud computing system, the antiaffinity constraint refers to the existence of interference factors between two tasks in the system. When these two tasks are deployed on the same VM, their performance may be influenced by each other. For example, Chi et al. [9] experimentally verified that deploying a disk-intensive task to a physical machine with multiple disk-intensive tasks will lead to resource contention and serious performance degradation. Therefore, when scheduling tasks, it is necessary to avoid the deployment of mutually interfering tasks on the same VM. This problem can be equivalent to the multidimensional bin packing problem with conflicts (MDBPPC).

The MDBPPC model originates from the classic bin packing problem model, but due to its difficulty in solving, research on this problem is very few. The existing research focuses on the bin packing problem with conflicts (BPPC) of single-dimension resources. Jansen [10] first introduced the conflict relationship in the traditional bin packing model, and represented the conflict relationship in the form of a graph structure. Christman et al. [11] studied the bin packing problem with stability, which is a variant of BPPC. Note that previous works have focused on algorithm design for single-dimension resource requirements without considering the situation of multidimension resource requirements.

Therefore, this paper studies the cloud computing task scheduling problem with antiaffinity constraints, and aims to minimize the number of cloud computing VMs to reduce the energy consumption of the cloud computing system. The main contributions of this work are summarized as follows:

• We formulate the low-energy task scheduling problem with antiaffinity constraints in cloud computing as an MDBPPC problem. To reduce the solution difficulty, we decompose the problem by Lagrange relaxation principle and Dantzig–Wolfe decomposition principle.
• To obtain the optimal integer solution, we design an efficient branch-and-price algorithm with several improvements. First, we introduce the idea of the dominant resource proportion into the process of initial solution generation. Second, we use an efficient branch rule based on multiple pattern. Third, we use the hot start and upper bound strategy to improve the branch-and-price algorithm.
• We conduct numerical simulations on three scales to evaluate the correctness and effectiveness of our proposed algorithm. Moreover, we verify the effectiveness of the initial solution strategy and the branching strategy.

The remainder of this paper is organized as follows. Section 2 summarizes the related work. Section 3 describes the cloud computing task scheduling problem with conflict constraints, Section 4 decomposes the original model. Section 5 proposes a task scheduling algorithm based on branch-and-price, and Section 6 gives the experimental results. Section 7 summarizes the work of the full text.

2. Related Works

Recently, there have been many works focused on reducing the energy consumption of task scheduling in cloud computing. Beloglazov et al. [12], as pioneers, designed an energy-efficient cloud computing architecture model based on CPU and proposed an energy-efficient resource allocation algorithm, but did not consider hardware resources other than CPU. Garg et al. [13] considered multiple resources; they first designed a mathematical model to measure the energy consumption in the process of task execution, and then proposed a scheduling algorithm that can minimize the average energy consumption of each task. Mekala et al. [14] classified tasks and VMs, and scheduled tasks to corresponding VMs based on the classification results. This scheduling algorithm can both improve resource utilization and reduce energy consumption. Zhang et al. [15] weighed the energy consumption and performance of the cloud computing system. They abstracted the problem into a double-objective integer programming problem and designed a two-stage heuristic algorithm. Liang et al. [16] designed a dynamic hybrid resource deployment algorithm to minimize energy consumption of data centers by improving the average utilization rate of physical machines. The algorithm is based on the K-means clustering algorithm in unsupervised learning and the KNN classification algorithm in supervised learning. Note that the previous works are mostly based on approximation algorithms. The solution results often lack theoretical support and can only be evaluated by numerical experiments, thus lacking in promotion.

In terms of the algorithm research in BPPC, Gendreau et al. [17] studied the lower bound of the problem and designed various heuristic algorithms. Capua et al. [18] proposed an iterated local search algorithm. This metaheuristic algorithm can enhance the search procedure with a variety of local and large neighborhoods. Elhedhli et al. [19] proposed an exact algorithm based on branch-and-price. They utilized the structure of conflict constraints to design an efficient branching strategy. This strategy can preserve the model of subproblems after branching, thus greatly improving the efficiency of the algorithm. Wei et al. [20] designed a new label-setting scheme that can effectively solve the pricing problem and accelerate algorithm execution speed. Ekici [21] considered a variant model of BPPC, which allowed fragments of items. He proved that the proposed new model was still NP-hard and designed a heuristic algorithm based on a lower bounding scheme. It is noteworthy that the existing studies focus on the algorithm design for single-dimension resource requirements.

3. System Model and Problem Formulation

We assume that there are m VMs with the same configuration in the cloud computing system, and let $\mathcal{M}=\{1,2,\dots ,M\}$ be the set of VMs. Each VM has k types of hardware resources, such as CPU, memory, and disk. Let $\mathcal{R}=\{1,2,\dots ,M\}$ be the type set of hardware resources, and let vector $c=(c_1,c_2,\dots ,c_k)$ represent the resource capacity of each VM. Meanwhile, there are $n(n\le m)$ tasks waiting to be deployed in the cloud computing system. Let $\mathcal{J}=\{1,2,\dots ,n\}$ represent the set of tasks. For each task $j(j\subseteq \mathcal{J})$, let $d_j=(d_{j1},d_{j2},\dots ,d_{jk})$ represent the resource requirement vector of task j, where $d_{jr}$ represents the requirement of the jth task for the rth resource. In a cloud computing environment, there may be interference between tasks. If mutually interfering tasks are deployed on the same VM, their performance may be affected. Therefore, when scheduling tasks, it is important to avoid scheduling mutually interfering tasks to the same VM. The conflict interference relationship between tasks is characterized by a conflict graph $G=(V,E)$. Each vertex in vertex set V corresponds to each task in task set J, and the conflict relationship between tasks corresponds to edge set E. For any two vertices $j,j^{\prime }\in V$, if there is $(j,j^{\prime })\in E$, it indicates that there is a conflict relationship between task j and task $j^{\prime }$; thus, they cannot be deployed on the same VM. The optimal solution for task scheduling of this problem is to use as few VMs as possible. The aforementioned problem can be described by the following integer programming model:

$$z=min\sum _{i\in \mathcal{M}}{y}_i$$

(1)

$$\mathrm{s}.\mathrm{t}.\sum _{j\in \mathcal{J}}{d}_{jr}·x_{ij}^{}\le c_r·y_i,\forall i\in \mathcal{M},\forall r\in \mathcal{R}$$

(2)

$$\sum _{i\in \mathcal{M}}{x}_{ij}=1,\forall j\in \mathcal{J}$$

(3)

$$x_{ij}+x_{i{j}^{\prime }}\le 1,\forall (j,j^{\prime })\in E,\forall i\in \mathcal{M}$$

(4)

$$x_{ij},y_i\in \{0,1\},\forall j\in \mathcal{J},\forall i\in \mathcal{M}$$

(5)

The objective z is to minimize the number of cloud computing VMs deployed. The decision variable $x_{ij}$ indicates whether task j is scheduled to VM i, where $x_{ij}=1$ indicates that task j is executed on VM i, and $x_{ij}=0$ indicates that it is not. The decision variable $y_i$ indicates whether there exists a task executed on the ith VM, where $y_i=1$ indicates that there is and $y_i=0$ otherwise. Formula (2) indicates that the resource used of any VM cannot exceed the capacity of any type of resource. Formula (3) ensures that each task has to be executed on exactly one VM. Formula (4) ensures that conflicting tasks cannot be executed on the same VM. Formula (5) ensures that the values of decision variables $x_{ij}$ and $y_i$ can only be 0 or 1.

4. Model Decomposition

Since the above problem is a generalization of the classical bin packing problem and graph coloring problem, its solution is quite difficult: when the conflict graph is an empty set, the problem can be transformed into a classic multidimensional bin packing problem, and when the capacity of each type of resource in each VM is zero, the problem can be transformed into a graph coloring problem. Both the bin packing problem and the graph coloring problem have been proven to be NP-hard problems [22]. The time complexity of solving such problems increases as the size of the problem increases. Therefore, this paper first relaxes the tightly coupled constraint condition (3) of the original model based on the Lagrange relaxation principle [23] to obtain the Lagrange relaxation problem of the original problem. Second, we decompose the relaxation problem based on the Dantzig–Wolfe decomposition principle [24]. Thus, we can obtain a main problem with a relatively simple structure and a multidimensional bin packing subproblem with conflict constraints.

We introduce a Lagrange multiplier $\mu =({\mu }_1,{\mu }_2,\dots ,{\mu }_n)$ to perform Lagrange relaxation on the constraint condition (3). $z\left(\mu \right)$ is the optimal solution of the relaxation problem, and the model of the Lagrangian relaxation problem is as follows:

$$\begin{array}{c}z\left(\mu \right)=min{\displaystyle \sum _{i\in \mathcal{M}}}{y}_i-{\displaystyle \sum _{i\in \mathcal{M}}}{\displaystyle \sum _{j\in \mathcal{J}}}{\mu }_j·x_{ij}^{}+{\displaystyle \sum _{j\in \mathcal{J}}}{\mu }_j\\ \mathrm{s}.\mathrm{t}.:\left(2\right),\left(4\right),\left(5\right)\end{array}$$

The problem can be decomposed into m identical multidimensional bin packing problems with conflict constraints, that is, $z=m·z_i\left(\mu \right)+{\sum }_{j\in \mathcal{J}}{\mu }_j$, which is called subproblem (SP). The model is as follows:

$$\left(\mathrm{SP}\right)z_i\left(\mu \right)=miny-\sum _{j\in \mathcal{J}}{\mu }_j·x_j^{}$$

(6)

$$\mathrm{s}.\mathrm{t}.\sum _{j\in \mathcal{J}}{d}_{jr}·x_j^{}\le c_r·y,\forall r\in \mathcal{R}$$

(7)

$$x_j+x_{j^{\prime }}\le 1,\forall (j,j^{\prime })\in E$$

(8)

$$x_j,y\in \{0,1\},\forall j\in \mathcal{J}$$

(9)

Assuming that there are H feasible solutions that satisfy the constraint conditions (7)–(9), each feasible solution is represented by the vector ${(x_1^h,x_2^h,\dots x_n^h,y^h)}_{h=1,2,\dots ,H}^{\mathrm{T}}$. Therefore, $z_i\left(\mu \right)=\underset{h=1,2,\dots H}{min}\left\{y^h-{\sum }_{j\in \mathcal{J}}{\mu }_j·x_j^h\right\}$, and the optimal Lagrangian lower bound of the original problem is

$$\begin{array}{c}{\displaystyle \underset{\mu }{max}}\left\{m·z_i\left(\mu \right)+{\displaystyle \sum _{j\in \mathcal{J}}}{\mu }_j\right\}\hfill \\ ={\displaystyle \underset{\mu }{max}}\left\{m·{\displaystyle \underset{h=1,2,\dots ,H}{min}}\left\{y^h-{\displaystyle \sum _{j\in \mathcal{J}}}{\mu }_j·x_j^h\right\}+{\displaystyle \sum _{j\in \mathcal{J}}}{\mu }_j\right\}\hfill \end{array}$$

We define variable $\theta =\underset{h=1,2,\dots ,H}{min}\left\{y^h-{\sum }_{j\in \mathcal{J}}{\mu }_j·x_j^h\right\}$. Since ${(0,0,\dots ,0,0)}_{}^{\mathrm{T}}$ is a feasible solution to the SP, $\theta \le 0$. We can obtain the following Lagrangian master problem (LMP):

$$(\mathrm{LMP})\underset{}{max}(\sum _{j\in \mathcal{J}}{\mu }_j+m·\theta )$$

(10)

$$\mathrm{s}.\mathrm{t}.\theta +\sum _{j\in \mathcal{J}}{\mu }_j·x_j^h\le y^h,h=1,2,\dots ,H$$

(11)

$$\theta \le 0$$

(12)

We can obtain the Dantzig–Wolfe master problem (DMP) which is the dual solution of the previous LMP as follows:

$$(\mathrm{DMP})min\sum _{h=1}^H{y}^h·a_h$$

(13)

$$\mathrm{s}.\mathrm{t}.\sum _{h=1}^H{a}_h\le m$$

(14)

$$\sum _{h=1}^H{x}_j^h·a_h=1,j\in \mathcal{J}$$

(15)

$$a_h\ge 0,h=1,2,\dots ,H$$

(16)

From the above models, it can be seen that the optimal solution of SP provides a lower bound $m·z_i\left(\mu \right)+{\sum }_{j\in \mathcal{J}}{\mu }_j$ for $z\left(\mu \right)$. The DMP is equivalent to the original relaxation problem, but due to the large number of DMP columns (coefficients) that cannot be enumerated one by one, we iteratively add effective columns through the column generation algorithm to obtain the restricted master problem (RMP). The optimal solution of RMP provides an upper bound for $z\left(\mu \right)$. Therefore, by iteratively solving SP and RMP until the upper and lower bounds of $z\left(\mu \right)$ are equal, the current result is the optimal solution of the Lagrange relaxation problem $z\left(\mu \right)$.

5. Cloud Task Scheduling Algorithm Based on Branch-and-Price

The optimal solution of the Lagrange relaxation problem obtained through column generation is usually not an integer solution. To obtain the optimal integer solution, it is necessary to use a branch-and-bound algorithm to branch the fractional variables, and obtain the optimal integer solution through a limited number of branches. Therefore, we design a branch-and-price algorithm that combines the branch-and-bound algorithm and column generation algorithm to address the issues and characteristics of the proposed model. The branch-and-price algorithm for task scheduling in clouds (BPTSC) involves three main parts when iteratively searching in the solution space: the generation of the initial solution (column) of the root node, column generation for solving the Lagrangian relaxation optimal solution corresponding to the node, and the branch-and-bound stage. The following subsections will focus on the algorithm design of these three parts.

5.1. Generation of Initial Solution

5.1.1. Algorithmic Procedure

The quality of the initial solution has a significant impact on the performance of the branch-and-price algorithm. A good initial solution can effectively reduce the number of iterations in the column generation solution process, thereby improving the execution speed of the branch-and-price algorithm. The generation strategy of the initial solution for the root node and child nodes in the branch-and-price algorithm search tree is different. The strategy for the root node usually needs to be constructed based on the characteristics of the model, while the child nodes can use the feasible columns on the parent node as its initial columns. Therefore, the quality of the initial solution generation algorithm at the root node is crucial.

To improve the solving speed of the algorithm, we first use the improved Bron–Kerbosch algorithm proposed in [25] to identify all task conflict maximum cliques based on the task conflict graph G at the root node. Then, we add conflict constraints based on maximum cliques to the subproblems of the algorithm, thus reducing the number of constraints and accelerating the algorithm’s solving speed. Meanwhile, the improved Bron–Kerbosch algorithm is also used to find the complete partition of the maximal independent set of tasks. According to the characteristics of multidimensional resources in our proposed model, we introduce the idea of the dominant resource proportion [26,27,28,29] in the multiresources fair allocation to improve the famous first fit decreasing [30] algorithm. The improved algorithm allocates VMs to the tasks in each independent set partition. The definition of the dominant resource proportion is as follows:

$$d{r}_j=\underset{r}{max}\frac{d_{jr}}{c_r}$$

(17)

A larger $d{r}_j$ indicates that task j has a higher requirement for its dominant resources. The steps for generating the initial solution algorithm at the root node are as follows:

Step 1 Use the improved Bron–Kerbosch algorithm to determine all task conflict maximum cliques and all complete partitions of task maximal independent set.

Step 2 If all task-independent sets have been processed, the algorithm will be terminated. Otherwise, retrieve the first unprocessed independent set, and sort the tasks by the nonincreasing order of the task dominant resource proportion.

Step 3 Enable a VM for the current independent set.

Step 4 Sequentially traverse the tasks in the current independent set and sort the corresponding deployed VMs in ascending order of index number. Schedule task j to the VM with the smallest index number, and the remaining capacity of each type of resource is not less than task j’s demand for this type of resource. If all deployed VMs are unable to deploy the task, skip to Step 3. Until all tasks of the independent set have been deployed, skip to Step 2.

5.1.2. Example

Consider a cloud computing system with five VMs, and each VM has five cores of CPU and 5 GB of memory. There are five tasks in the cloud computing system that need to be scheduled, and

Table 1. Task resource requirements.

Task Number	CPU	Memory
1	2	1
2	1	3
3	2	4
4	3	2
5	4	2

provides the resource requirement information of the tasks. Figure 1 shows the relationship graph between tasks, where Figure 1a is the conflict graph of the tasks. To illustrate the algorithm more intuitively, Figure 1b is provided as the complementary graph of Figure 1a, which is known as the compatibility graph. There is no conflict relationship between any two connected tasks in Figure 1b, and they can be scheduled to the same VM.

The process of the initial solution of the root node is as follows: First, the improved Bron–Kerbosch algorithm is used to find all the task conflict maximum cliques $\{1,2,3\},\{2,4\},\{3,5\}$ and the complete partition of the task maximal independent set $\{1,4,5\},\left\{2\right\},\left\{3\right\}$. Obtain the first independent set $\{1,4,5\}$. Since $d{r}_1=2,d{r}_4=3$ and $d{r}_5=4$, it is $\{5,4,1\}$ after sorting. Enable VM 1 and sequentially traverse task list $\{5,4,1\}$. The available resources of VM 1 at this time are $(5,5)$, which can meet the resource requirements of task 5. Therefore, task 5 is scheduled to be executed on VM 1. The available resources of VM 1 become $(1,3)$, which cannot meet the resource requirements of task 4. Therefore, VM 2 is enabled and task 4 is scheduled to be executed on VM 2. Since VM 1 cannot meet the resource requirements of task 1, and VM 2 can meet the resource requirements of task 1, task 1 is scheduled to VM 2 for execution. At this time, all tasks in the first independent set are scheduled. Similarly, VM 3 is enabled for the second independent set $\left\{2\right\}$, and task 2 is scheduled to VM 3 for execution. Enable VM 4 for the third independent set $\left\{3\right\}$, and schedule task 3 to VM 4 for execution. Therefore, the target value of the generated initial feasible solution is 4, and the generated initial feasible column is ${(0,0,0,0,1,1)}^{\mathrm{T}}$, ${(1,0,0,1,0,1)}^{\mathrm{T}}$, ${(0,1,0,0,0,1)}^{\mathrm{T}}$, ${(0,0,1,0,0,1)}^{\mathrm{T}}$.

5.2. Column Generation Algorithm

5.2.1. Algorithmic Procedure

One of the cores of branch-and-price algorithms is to use column generation algorithms to solve the optimal solution of the Lagrange relaxation problem for each node. The solution process for the column generation algorithm on each node is as follows:

Step 1 Judge whether the current node is a root node. If it is a root node, the feasible columns generated by the initial solution are used as the initial columns of the node. Otherwise, use the feasible columns in the parent node that satisfy the branch constraint as the initial columns of the current node to obtain RMP.

Step 2 Solve RMP and obtain a set of dual solutions, then transfer the dual solutions to SP.

Step 3 Solve SP and calculate the lower bound $m·z_i\left(\mu \right)+{\sum }_{j\in \mathcal{J}}{\mu }_j$ of the Lagrangian relaxation problem. Judge whether the lower bound is equal to the upper bound, i.e., the optimal solution of RMP. If they are equal, the algorithm is terminated. Otherwise, add the columns generated by SP to RMP and skip to Step 2.

5.2.2. Example

The process of using the column generation algorithm to solve the optimal solution of the Lagrangian relaxation problem of the root node in Section 5.1.2 is as follows:

First, we use the initial columns generated by Section 5.1.2 as the initial columns of the root node and obtain the following RMP model:

$$\begin{array}{c}min{a}_1+a_2+a_3+a_4\\ \mathrm{s}.\mathrm{t}.:a_1+a_2+a_3+a_4\le 5\\ a_2=1\\ a_3=1\\ a_4=1\\ a_2=1\\ a_1=1\\ a_h\ge 0,h=1,2,\dots ,4\end{array}$$

(18)

Solve this RMP model with an object value of 4, which means the upper bound of the Lagrangian relaxation main problem is 4, and $a_1=1, a_2=1, a_3=1, a_4=1$. Meanwhile, the dual solution is $\theta =0, {\mu }_1=1, {\mu }_2=1, {\mu }_3=1, {\mu }_4=0, {\mu }_5=1$. Substitute the dual solutions into the SP model and add conflict constraints based on the maximum clique found in Section 5.1.2 to obtain the following SP model:

$$\begin{array}{c}{z}_i\left(\mu \right)=miny-(x_1^{}+x_2^{}+x_3^{}+x_5^{})\\ \mathrm{s}.\mathrm{t}.:2x_1^{}+x_2^{}+2x_3^{}+3x_4^{}+4x_5^{}\le 5y\\ x_1^{}+3x_2^{}+4x_3^{}+2x_4^{}+2x_5^{}\le 5y\\ x_1+x_2+x_3\le 1\\ x_2+x_4\le 1\\ x_3+x_5\le 1\\ x_j,y\in \{0,1\},j=1,2,\dots ,5\end{array}$$

(19)

By solving this SP model, the target value $z_i\left(\mu \right)$ of the model is −1; thus, the lower bound $m·z_i\left(\mu \right)+{\sum }_{j\in \mathcal{J}}{\mu }_j$ is −1. We obtain the solution $x_1=0,x_2=1,x_3=0,x_4=0,$ $x_5=1,y=1$, that is, the generated new column is ${(0,1,0,0,1,1)}^{\mathrm{T}}$. Since the upper bound is 4 and the lower bound is −1, which are not equal, it is necessary to use the column generation algorithm to continue solving. Add the newly generated columns to the RMP model and obtain the following RMP model:

$$\begin{array}{c}min{a}_1+a_2+a_3+a_4+a_5\\ \mathrm{s}.\mathrm{t}.:a_1+a_2+a_3+a_4+a_5\le 5\\ a_2=1\\ a_3+a_5=1\\ a_4=1\\ a_2=1\\ a_1+a_5=1\\ a_h\ge 0,h=1,2,\dots ,5\end{array}$$

(20)

Solve this RMP model and obtain a target value of 3, and $a_1=0, a_2=1, a_3=0, a_4=1$, $a_5=1$. Meanwhile, the dual solution is $\theta =0, {\mu }_1=1, {\mu }_2=0, {\mu }_3=1, {\mu }_4=0, {\mu }_5=1$. By substituting the dual solution into the SP model, the objective of the obtained SP model is $z_i\left(\mu \right)=miny-(x_1^{}+x_3^{}+x_5^{})$, and the constraint conditions are the same as those in Equation (7). By solving this SP model, the target value of the model is 0, and the lower bound of the Lagrange relaxation main problem is 3. At this time, the upper and lower bounds of the Lagrangian relaxation main problem are equal to 3. Therefore, the optimal solution of the Lagrangian relaxation problem is 3, and the algorithm ends.

5.3. Branch Strategy and Node Selection Strategy

5.3.1. Algorithmic Procedure

The solution obtained by solving the Lagrange relaxation problem through column generation is usually a fractional solution, which is the lower bound of the original integer programming problem. Therefore, we need to use an efficient branching strategy to obtain the optimal integer solution. A reasonable branching strategy should effectively partition the solution space of the problem, ensuring that feasible integer solutions can be found after a limited number of branches. However, the variable-based branching strategy, which is commonly used in traditional branch-and-bound algorithms, is not suitable for branch-and-price algorithms. Therefore, this paper adopts a subproblem-model-based branching strategy proposed in [31].

Assume that a node in the branch-and-price tree has completed the column generation process and generated a fractional solution. The column matrix composed of all columns generated by the Lagrange relaxation problem of this node is as follows:

$$M={\left(x^h\right)}_{h=1,2,\dots ,H}=\left[\begin{array}{cccc}{x}_1^1& x_1^2& \dots & x_1^H\\ x_2^1& x_2^2& \dots & x_2^H\\ ⋮& ⋮& \ddots & ⋮\\ x_n^1& x_n^2& \dots & x_n^H\end{array}\right]$$

Column matrix $M^{\prime }={\left(x^h\right)}_{h=1,2,\dots ,H^{\prime }}(H^{\prime }\le H)$ is a submatrix of M that consists of columns corresponding to the condition $a_h>0$. Search the column matrix $M^{\prime }$ to find row pairs $(j^{\prime },j^{″})$ and column pairs $(h^{\prime },h^{″})$ that meet the pattern shown in Figure 2. Add constraint condition $x_{j^{\prime }}=x_{j^{″}}$ to the subproblem of the left branch, and initialize the columns in M that satisfy constraint $x_{j^{\prime }}^{}=x_{j^{″}}^{}$ as the initial columns of the left branch node of the current node. On the right branch, add the constraint $x_{j^{\prime }}+x_{j^{″}}\le 1$ to the subproblem, that is, add edge $(j^{\prime },j^{″})$ to the conflict graph G, and select the columns in M that satisfy constraint $x_{j^{\prime }}+x_{j^{″}}\le 1$ as the initial columns of the right branch node of the current node. According to reference [31], if there is no pattern, as shown in Figure 2, then the solution must be an integer solution. Due to the limited number of rows and columns, the branch-and-price algorithm will inevitably terminate after a limited number of branches. As the conditions for the left branches are easier to solve, this paper adopts a depth-first search node selection strategy.

5.3.2. Example

Assuming a noninteger node, the column matrix $M^{\prime }$ composed of the columns corresponding to condition $a_h>0$ is as follows:

$$\left[\begin{array}{cccc}0& 1& 0& 0\\ 1& 1& 0& 0\\ 0& 0& 1& 1\\ 0& 1& 1& 0\end{array}\right]$$

We find that row pair $(1,2)$ and column pair $(1,2)$ meet the pattern shown in Figure 2. Therefore, add constraint $x_1^{}=x_2^{}$ to the subproblem of the left branch and constraint $x_1+x_2\le 1$ to the subproblem of the right branch.

5.4. Optimization of the Algorithm

To further improve the efficiency of the branch-and-price algorithm, we provide implementation details on branching strategy and the strategies for generating integer solutions.

5.4.1. Branch Strategy Based on Multiple Patterns

(a)

Algorithmic Procedure

The branching strategy can be extended to more general situations [31]. Assume that $P(P\ge 1)$ row pairs satisfy the pattern shown in Figure 2 at the current node. Then we generate $P+1$ subnodes for this node, where the following constraints are added for the leftmost branch:

$$\left\{\begin{array}{c}{x}_{j_1^1}=x_{j_2^1}\hfill \\ x_{j_1^2}=x_{j_2^2}\hfill \\ \dots \hfill \\ x_{j_1^p}=x_{j_2^P}\hfill \end{array}\right.$$

The branching constraints added to the remaining P branches are as follows:

$$x_{j_1^p}+x_{j_2^p}\le 1,p=1,2,\dots ,P$$

(b)

Example

By searching the column matrix in Section 5.3.2, the following row and column pairs that meet the pattern shown in Figure 2 can be found: row pair $(1,2)$ and column pair $(1,2)$, row pair $(1,4)$ and column pair $(2,3)$, row pair $(2,4)$ and column pair $(1,2)$, row pair $(2,4)$ and column pair $(2,3)$, row pair $(3,4)$ and column pair $(2,3)$, row pair $(3,4)$ and column pair $(3,4)$. We can find three different pairs of rows: $(1,2),(2,3)$, and $(3,4)$. Therefore, four branches are generated for this node, where constraints $x_1^{}=x_2^{},$ $x_2^{}=x_3^{}, x_3^{}=x_4^{}$ are added to the first branch, constraint $x_1^{}+x_2^{}\le 1$ is added to the second branch, constraint $x_2^{}+x_3^{}\le 1$ is added to the third branch, and constraint $x_3^{}+x_4^{}\le 1$ is added to the fourth branch.

5.4.2. Hot Start and Upper Bound Strategy for Generating Integer Solutions

Since the feasible domain of a child node is contained within the feasible domain of its parent node, the object value of the parent node is the lower bound of the child node. Therefore, the object value $z_{\mathrm{father}}$ of the parent node can be used to initialize the Lagrangian lower bound of the child node. This corresponds to adding constraint ${\sum }_{h=1}^H{y}^h·a_h\ge z_{\mathrm{father}}$ to the main problem of the child nodes. Meanwhile, to reduce the number of iterations within each subnode, we use the current optimal integer solution to replace the parameter m in constraint 4 (b) of the DMP.

On the other hand, a good upper bound can effectively compress the solution space and improve the algorithm’s execution speed. Since the columns of the final integer solution must be the columns corresponding to $a_h=1$, the larger the value of $a_h$ at noninteger nodes, the more likely the corresponding column is to be included in the optimal solution. Therefore, at each noninteger node, we sort all columns in descending order of $a_h$. Each column corresponds to the allocation method of a VM. Traverse these columns in order, and add columns to the feasible columns if they cover new tasks and none of the already-covered tasks. After traversing all columns, if a task has not yet been covered, we enable a new VM for it. When all tasks are covered, a feasible solution is generated. If the feasible solution is less than the current upper bound, the upper bound is updated to this feasible solution.

5.5. Specific Implementation Steps of the Algorithm

Figure 3 shows the flow chart of BPTSC, and the overall process of the algorithm is as follows:

Step 1 By the initial solution generation algorithm, we identify all task conflict maximum cliques, and generate the initial solution and the upper bound to form the root node.

Step 2 Initialize the branch-and-price search tree and add the root node.

Step 3 Select a node by the depth first strategy and initialize the problem model with the information of this node.

Step 4 Solve the Lagrange relaxation problem through column generation. If the solution is an integer solution, skip to Step 6; otherwise, skip to Step 5.

Step 5 Calculate the feasible integer solution generated by this node, and if it is less than the current upper bound, update the upper bound value. Compare the Lagrangian relaxation optimal solution at this node with the upper bound value. If it is less than the upper bound, branch based on the above branching strategy and add the new nodes to the set of unsolved nodes.

Step 6 If the set of unsolved nodes is not empty, skip to Step 3. Otherwise, the current upper bound is the optimal integer solution, and the algorithm is terminated.

6. Experimental Results and Analysis

The configuration of the experimental platform in this paper is Intel (R) Core (TM) i5-4590 CPU @ 3.30 GHz. The branch-and-price algorithm is implemented in C++, and the multidimensional bin packing subproblem with conflict constraints and the RMP model are solved by CPLEX 12.6.3 solver.

6.1. Experimental Setup

To verify the correctness and effectiveness of BPTSC, we refer to the numerical experiment of the one-dimensional packing problem with conflict constraints in [11] for experimental design. The experimental settings are as follows:

• The experiment is divided into three scales based on the number of tasks: small-scale (30 tasks), medium-scale (100 tasks), and large-scale (200 tasks).
• There are a total of 200 cloud computing VMs, each with three hardware resources: CPU, memory, and storage. The resource capacity of each VM is $c=(100,300,3000)$.
• The CPU requirements for each task are randomly generated on a uniform distribution of [1–64], memory requirements are randomly generated on a uniform distribution of [8–128], and storage requirements are randomly generated on a uniform distribution of [100–1000].
• Generate a conflict graph G according to the settings in [11], and add the conflict relationship between tasks based on the density values $\delta (\delta =0.1,0.2,\dots ,0.9)$ of the number of conflicting tasks.The specific method is to assign a feature value $q_j$ that satisfies a uniform distribution on [0–1] to each task j. If tasks j and $j^{\prime }$ meet $(q_j+q_{j^{\prime }})/\phantom{(q_j+q_{j^{\prime }})2}2\le \delta$, add a conflict relationship between tasks j and $j^{\prime }$.
• Each scale is further divided into nine groups according to the increasing conflict density value $\delta$. To ensure the universality of the experiment, each group includes 20 instances, and the experimental results are the average values simulated by 20 instances. The total number of the instances is 540.

6.2. Experimental Results

To evaluate the efficiency of the BPTSC algorithm proposed in this paper,

Table 2. Detailed results of BPTSC.

Number of Tasks	Conflic Density $\mathit{\delta }$	Nodes	Root Node Columns	Total Columns	Root Node Value	Optimal Solution	Root Node Time (s)	Total Time (s)
30	0.1	48.40	76.75	107.45	10.88	11.30	12.25	21.23
	0.2	31.05	82.55	98.20	10.86	11.40	10.53	14.23
	0.3	29.85	72.20	87.85	11.52	11.65	7.66	12.96
	0.4	28.65	66.05	77.90	12.95	13.20	5.98	10.55
	0.5	20.80	54.45	65.70	15.72	15.95	3.58	6.11
	0.6	16.65	47.40	52.15	18.48	18.60	2.38	5.05
	0.7	5.85	40.05	41.90	21.99	22.15	1.02	1.73
	0.8	8.80	34.70	36.85	25.30	25.40	0.38	0.74
	0.9	2.80	32.45	33.50	27.40	27.40	0.24	0.64
	Average	21.43	56.29	66.83	17.23	17.45	4.89	8.14
100	0.1	276.35	261.10	474.25	35.95	36.50	63.27	159.52
	0.2	269.20	253.55	465.35	36.25	36.65	69.56	147.46
	0.3	133.45	269.65	470.55	37.51	38.05	75.33	143.70
	0.4	115.30	287.35	359.60	39.88	40.15	65.52	79.21
	0.5	107.75	205.50	284.65	48.95	49.05	35.78	53.06
	0.6	111.15	181.50	245.75	58.83	59.20	24.78	40.02
	0.7	68.05	162.85	195.65	70.88	71.10	16.51	22.10
	0.8	25.55	139.30	150.40	80.24	80.65	8.34	9.95
	0.9	9.20	109.00	112.10	91.38	91.60	1.09	1.49
	Average	124.00	207.76	306.48	55.54	55.88	40.02	72.95
200	0.1	637.70	605.30	962.65	72.32	72.35	157.71	447.21
	0.2	565.80	539.45	934.20	72.60	73.00	175.76	385.43
	0.3	367.05	566.30	903.30	73.25	73.65	185.33	321.84
	0.4	364.60	511.25	742.20	79.42	79.75	154.04	256.64
	0.5	349.95	431.80	621.30	101.98	102.20	106.64	196.77
	0.6	335.05	381.65	532.45	121.33	121.35	79.60	152.03
	0.7	295.10	353.75	506.25	135.41	135.50	59.47	125.47
	0.8	106.85	277.95	329.20	162.02	162.25	24.52	37.17
	0.9	38.50	225.35	242.30	183.43	183.75	5.34	8.826
	Average	340.07	432.53	641.54	111.31	111.53	105.38	214.60

summarizes the evaluation results of BPTSC. As the number of tasks increases, the difficulty of the problem increases exponentially. As the problem scale increases from 30 to 200, the number of nodes increases by approximately 15 times, the number of columns increases by more than 8 times, and the average execution time increases by 25 times. Notably, the model is the most difficult to solve when the conflict density is between 10% and 30%. In this case, the key constraint of the model is the multidimensional resource capacity constraint. This makes the solution space of the search tree very large, requiring the generation of a large number of branch nodes and columns. When the conflict density is between 70–90%, the model is the easiest to solve. In this instance, the key constraint is the task conflict constraint; thus, the solution space of the model is small. Only generating a small number of nodes and columns can obtain the optimal solution of the problem. On the other hand, as expected, the value of the optimal solution increases as the density of the conflict graph increases. When the conflict density is 10%, the value of the optimal solution is usually quite similar to the no-conflict constraint case. However, for high-density instances (90%), almost 90% of tasks are scheduled to different VMs. As shown in the fourth and fifth columns of Table 2, most feasible columns are generated at the root node. The number of columns generated by the root node accounts for more than 2/3 of the total number of columns, resulting in the root node accounting for more than half of the total execution time. From the sixth and seventh columns of Table 2, the Lagrange lower bound obtained by the root node is very close to the optimal solution, reaching over 98%. In addition, we also conduct ultra-large-scale (1000 tasks) experiments. The experimental results show that when the conflict density is high (70–90%), the execution time of BPTSC is still very short. In other cases, the execution time usually exceeds our set time (1 h).

The BPTSC algorithm is an accurate algorithm, while the heuristic algorithms commonly used as the benchmark are approximation algorithms, and cannot obtain optimal solution. Thus, we use CPLEX as the benchmark to compare the efficiency of the algorithm. CPLEX directly solves the original model without using Lagrange relaxation principle and Dantzig–Wolfe decomposition principle. Meanwhile, to verify the effectiveness of the initial solution generation strategy of BPTSC, Figure 4a–c, respectively, show the comparison of the number of nodes, number of columns, and execution time between BPTSC and the branch-and-price algorithm using the descending first fit strategy, which is identified by FFBP in Figure 4. Figure 4c also provides a comparison between the two branch-and-price algorithms and CPLEX in terms of execution time. From Figure 4a,b, the initial solution generation strategy of BPTSC outperforms FFBP in terms of the number of nodes and number of columns, especially when the task size is large. From Figure 4c, it can be seen that when the number of tasks is small, the execution efficiency of all three algorithms is high. When the number of tasks is medium in scale, BPTSC is superior to FFBP in finding the initial solution. Both of them have much shorter execution time than the algorithm directly using CPLEX. When the number of tasks is large, since most of the execution times of the instances solved by CPLEX exceed our set time (1 h), only the two branch-and-prices are compared. The experimental result is similar to the medium-scale case, and BPTSC is superior to FFBP, which verifies the effectiveness of the initial solution generation strategy of BPTSC.

Figure 5 shows the execution results of using three different branch modes of 1, 5, and 10 for different task scales. The algorithms for the three branch modes correspond to BPTSC-1, BPTSC-5, and BPTSC-10. Although the total number of nodes may increase when using the multibranch mode (BPTSC-5 and BPTSC-10), the generated number of feasible columns will decrease, resulting in a significant reduction in the execution time of the algorithm. The algorithm has the highest execution efficiency when the branch mode is 5, which verifies the effectiveness of the multipattern-based branching strategy proposed in this paper.

7. Conclusions

This paper investigates the task scheduling problem in cloud computing systems with the goal of reducing energy consumption. Due to the lack of consideration of antiaffinity constraints between tasks in the current research, we formulate the problem into a multidimensional bin packing model with conflict constraints. Furthermore, the model is decomposed by the Lagrange relaxation principle and Dantzig–Wolfe decomposition principle. On the other hand, due to the lack of exact algorithms with theoretical support for task scheduling problem in cloud computing, we design a branch-and-price algorithm and improve the algorithm in many ways. Finally, through multiple sets of experiments, it is verified that the algorithm designed in this paper has good results in terms of execution time and efficiency. In future work, we will address the task scheduling problem of cloud computing by adding time as a new type of resource. Tasks can specify the start and end times for using VMs. On the other hand, to better solve ultra-large-scale problems in practice, we will study the approximation algorithms of the problem proposed in this paper.