Strategies for optimal allocation of cloud computing resources for innovation and entrepreneurship education in industry-teaching integration environment

Course construction is mainly divided into four major parts: basic course information, course content, resource management, and learning. 1)

Basic course information

The function of basic course information includes general information, course overview, course content, activities and assessment.

General information: create the course cover, name, credits, suggested hours, classification and start time.

Course Overview: Including basic modules such as course introduction, learning objectives, learning methods, course assessment, cited resources, etc. You can also add some modules by yourself according to your needs, such as knowledge points, teaching forms, assessment scope, etc.

Course content: Teachers can create the complete information content of the course, including the course catalog, detailed chapter content, knowledge points, excellent cases, all kinds of courseware resources and so on.

Activities: Teachers can publish some activity information.

Assessment: Teachers can publish exams.

The platform can directly edit test papers online, and can also use the existing word documents to directly import test papers. Online grouping is mainly to train teachers to utilize the “insert test paper” function provided by the platform to directly edit test questions online, and can set the question stem, answer analysis, score and difficulty system. The question bank set by teachers of a certain course can be dynamically added and adjusted, and it can also be quoted by teachers of other courses through authorization.

The guided learning function is mainly realized by instant messaging and learning trace system. Instant messaging is mainly used for Q&A, group discussion, teaching management and other tutoring services between students and students, students and teachers. Learning Trace is used to facilitate teachers to view the current learning status of students, so as to analyze the current problems of students and give students guidance.

To formalize the description of the problem, we take each data center in a cloud computing to contain a number of PM, and each PM to contain a series of unallocated VM. The ultimate goal is to aspire to an allocation policy that minimizes the total number of PM.

In the following, we provide a unified description of the resource model of the system: 1)

Let the set of PM in Datecenter be denoted as P=(p1,p2,…,pj,…,pM)$$P = \left( {{p_1},{p_2}, \ldots ,{p_j}, \ldots ,{p_M}} \right)$$, where p_j denotes the j th PM and there are pj=(cj−cpu,cj−men,cj−stor,cj−bw)$${p_j} = \left( {{c_{{j_ - }cpu}},{c_{{j_ - }men}},{c_{{j_ - }stor}},{c_{{j_ - }bw}}} \right)$$, denoting the configurations of the hardware facilities of that PM corresponding to its CPU performance, memory, hard disk, and network bandwidth, respectively.

Obviously, for a specific mapping mechanism to satisfy: ∀p_j ∈ P, the total amount of its resources in each dimension (including CPU performance, memory, hard disk, and network bandwidth) must exceed the sum of the performance metrics of all the VMs it maps.

Meanwhile, for the PM-state involved in the allocation activity, we use the set U=(u1,u2,…,uM)$$U = \left( {{u_1},{u_2}, \ldots ,{u_M}} \right)$$ to represent it as u_j = 1 if it satisfies ∃vm_i ∈ V and h_ji = 1, and u_j = 0 otherwise: 1∑i=1Nri_cpu×hji≤cj_cpu1≤j≤M ∑i=1Nri_men×hji≤cj_mem1≤j≤M ∑i=1Nri_stor×hji≤cj_stor1≤j≤M ∑i=1Nri_bw×hji≤cj_bw1≤j≤M$$\begin{array}{l} \sum\limits_{i = 1}^N {{r_{i\_cpu}}} \times {h_{ji}} \le {c_{j\_cpu}}1 \le j \le M \\ \sum\limits_{i = 1}^N {{r_{i\_men}}} \times {h_{ji}} \le {c_{j\_mem}}1 \le j \le M \\ \sum\limits_{i = 1}^N {{r_{i\_stor}}} \times {h_{ji}} \le {c_{j\_stor}}1 \le j \le M \\ \sum\limits_{i = 1}^N {{r_{i\_bw}}} \times {h_{ji}} \le {c_{j\_bw}}1 \le j \le M \\ \end{array}$$

And the final optimization objective can be expressed in the following form: 2minX=∑j=1Mujwhereuj=1(∃vmi∈VAndhji=1) otherwiseuj=0$$\begin{array}{l} \min X = \sum\limits_{j = 1}^M {{u_j}} where{u_j} = 1\left( {\exists v{m_i} \in V\ And{\text{ }}{h_{ji}} = 1} \right) \\ otherwise{u_j} = 0 \\ \end{array}$$

where X denotes the total number of PM participants in the distribution activity.

Resource allocation is also the deployment of tasks, the implementation process, but only a single task is not our goal, but also need to assess the implementation of the task, maximize economic efficiency, improve resource utilization and so on. At present, the resource allocation process is mainly based on the two aspects of time span and load balancing as the main objectives. 1)

Time Span

It is the total response time consumed by the system to fulfill all the task requests of each user. Compared to the independent response time of individual tasks, the time span of the system better reflects the strength of its computing power and overall throughput rate. Obviously, the shorter the completion time, the higher the performance of the system, and at the same time, the quality of service and satisfaction of the users will be improved accordingly.

Ant Colony Optimization (ACO) algorithm, also known as ant colony algorithm, is a heuristic algorithm designed to simulate the foraging behavior of ant colonies [24]. The solution of ACO algorithm is based on the combination of deterministic solution and stochasticity, the process of constructing the optimized solution by continuous iteration, which will be dynamically adjusted with the change of environmental factors, and finally the global optimal solution is obtained through the accumulation of pheromones. Due to the positive feedback mechanism and robustness of the ACO algorithm, many scholars have already carried out in-depth research on it and migrated it to solve a variety of NP-complete problems, such as the typical traveler’s TSP problem, graph coloring, quadratic allocation problem and so on, and have made a breakthrough at a stage.

The execution process of ant colony algorithm is essentially to simulate the behavioral process of ants foraging for food.

The background and principles of the ACO algorithm have been introduced in the previous section, as a heuristic scheduling algorithm, the ACO algorithm is suitable for the solution of NP − hard problems. Its solution process for the classical TSP will be described in detail in the following.

Brief description of the Traveler’s Problem (TSP) problem: Given a series of cities and the distance between two cities, first solve for the shortest path to visit all the cities and eventually return to the starting point, requiring that each city be passed through only once. This is a classical NP model of combinatorial optimization problems, first proposed by Dantzig et al. for its mathematical model of the planning and solution process. The enumeration method is a solution idea, but it has a complexity of O(n!) where n denotes the number of cities. As the number of cities increases, the algorithm is difficult to solve in polynomial time.

For ease of understanding, the problem can be formalized in Figure Graph(N, E), where N denotes cities and E denotes edges connecting cities. Suppose there are n cities, traversed by m ants, and bounded by the following conditions. 1)

The ants release pheromones during their search and this particular chemical can remain on the path for some time.

For a certain ant k(k ∈ [1, m]), let its forbidden table structure in the search process be tabu_k, which is used to record the walking distance of the ant, and tabu_k[s] denotes the sth city visited by the ant k in its journey. Then, when it visits to a certain city node, it will calculate the state transfer probability in each direction according to the pheromone strength and heuristic information on each legal path, and decide the target direction of the next hop based on the size of the probability. The specific calculation formula is as follows: 3pij̇k(t)={ [τij(t)]α[ηij]β∑k∈allowedk[τik(t)]α[ηik]β ifj∈allowedk 0 otherwise$$p_{i\dot j}^k(t) = \left\{ {\begin{array}{*{20}{c}} {\frac{{{{\left[ {{\tau_{ij}}(t)} \right]}^\alpha }{{\left[ {{\eta_{ij}}} \right]}^\beta }}}{{\sum\limits_{k \in allowedk} {{{\left[ {{\tau_{ik}}(t)} \right]}^\alpha }} {{\left[ {{\eta_{ik}}} \right]}^\beta }}}}&{ if\ j \in allowe{d_k}} \\ 0&{ otherwise} \end{array}} \right.$$

When all the ants have completed one traversal, i.e., after completing the search process of one path, the pheromone value needs to be updated according to the search situation of each search path, the specific formula is as follows: 4τij(t′)=ρ×τij(t)+Δτij(t)$${\tau_{ij}}\left( {t^\prime } \right) = \rho \times {\tau_{ij}}(t) + \Delta {\tau_{ij}}(t)$$ 5Δτij(t)=∑k=1mΔτijk(t)$$\Delta {\tau_{ij}}(t) = \sum\limits_{k = 1}^m \Delta \tau_{ij}^k(t)$$

There are three main ways of updating pheromone, which are ant-volume model, ant-density model, and ant-week model. 1)

Ant volume model 6Δτijk(t)={ constdij Ant k passes through ij path in this search 0 Otherwise$$\Delta \tau_{ij}^k(t) = \left\{ {\begin{array}{*{20}{l}} {\frac{{const}}{{{d_{ij}}}}}&{ {\text{Ant }}k{\text{ passes through }}ij{\text{ path in this search}}} \\ 0&{ {\text{Otherwise}}} \end{array}} \right.$$

where const is a constant factor and L_k denotes the total length of the search path of ant k this time.

Compared with the previous two strategies, the ant-week model adopts the full length of the search path of ant k in the current iteration as the updating factor of the pheromone, i.e., it is a global information updating method, which better reflects the influence of the overall length of the path in the global scope. Due to the positive feedback mechanism of the pheromone, this approach speeds up the convergence of the algorithm, therefore, we adopt the ant-week model as the updating strategy of the pheromone.

The specific steps of annealing algorithm (SA)$$\left( {SA} \right)$$ can be divided into the following three parts [25]: 1)

Generation of new solution X′: Generated in the solution space by generating function, generally the most commonly used method is through the current solution X by random simple transformation, the method has randomly replaced some elements in the current solution X, etc., so that the purpose is for the convenience of the later calculation as well as to reduce the conversion time.

The purpose of Metropolis acceptance criterion chooses whether to accept the new state as an optimized solution for one iteration or not [26]. The initial solution is X, the new solution of the random transformation X′, the energy of the initial solution is denoted by E(X), and the energy of the new solution is denoted by E(X′)$$E\left( {X^\prime } \right)$$. The energy difference ΔE=E(X′)−E(X)$$\Delta E = E\left( {X^\prime } \right) - E(X)$$; if ΔE < 0, the new solution X′ is accepted and the new solution’s is set to be the initial state of the next annealing iteration; if ΔE > 0, it is necessary to set up a random number located in the interval of (0,1)$$\left( {0,1} \right)$$, to find out the new state probability p, and if p>rand(0,1)$$p > rand\left( {0,1} \right)$$, then the new solution X′ is still accepted, or the new solution X′ of the state will be discarded, the Still keep the initial solution X of this iteration as the initial state. Then we have the following transfer formula: 9p={ exp(−E(X′)−E(X)T) E(X′)>E(X) 1 E(X′)<E(X)$$p = \left\{ {\begin{array}{*{20}{l}} {\exp \left( { - \frac{{E\left( {X^\prime } \right) - E(X)}}{T}} \right)}&{ E\left( {X^\prime } \right) > E(X)} \\ 1&{ E\left( {X\prime } \right) < E(X)} \end{array}} \right.$$

Characteristics analysis of annealing simulation algorithm: because in the process of algorithm execution will always be a certain probability to accept the suboptimal solution that is not as good as the current solution, increasing the solution space of the algorithm, to a certain extent, to realize the diversity of the solution space, to avoid the algorithm appearing to fall into the local optimal problem, and the design process of the algorithm is relatively simple. Of course, the SA algorithm also has shortcomings, the algorithm can not control the most effective direction of the search, there is a great deal of randomness, so the convergence speed is also relatively slow. According to its advantages and disadvantages combined with the GAAA algorithm in the late stage of the algorithm needs to increase the characteristics of the solution space, can be introduced into the SA algorithm of the Metropolis acceptance mechanism to propose a new improved algorithm (HGAACO), applied to the resource allocation problem in the cloud computing environment.

1)

Task and node representation

Assuming that there are n task to be executed, denoted by T:T={T1,T2,…Tn}$$T:T = \left\{ {{T_1},{T_2}, \ldots {T_n}} \right\}$$, and m resources, denoted by V:V={V1,V2,…,Vm}$$V:V = \left\{ {{V_1},{V_2}, \ldots ,{V_m}} \right\}$$, this paper assumes that there are five attributes, i.e., they are represented by a hexadecimal tuple: Vi=〈VIriDViCriVBsiVRi〉$${V_i} = \left\langle {V{I_{{r_i}}}D{V_i}C{r_i}V{B_{{s_i}}}V{R_i}} \right\rangle$$, where where VID_i represents the node number, VC_i represents the node’s cpu processing capacity, VB_i represents the node bandwidth, VR_i represents the node memory, VF_i represents the node failure rate, and VP_i represents the node usage price. Similarly for task T, it is still a hexadecimal group, which corresponds to the amount of resources expected by the task. The execution time of task i on resource j is represented by a matrix S, S = {S_ij ∣ S_ij represents the execution time of T_i on V_j, 1 < i < n, 1 < j < m}, and a resource allocation matrix is represented by E, with a matrix size of m × n, E = {E_ij ∣ E_ij represents whether T_i is allocated for execution on V_j or not, and if it is allocated for execution then E_ij = 1, otherwise E_ij = 0, 1 < i < n, 1 < j < m}.

Where Tm_i implies the expectation of task i on the resource, which is obtained from hex T, and Vm_j is the parameter value of resource node j obtained from hex V. The larger Match_ij means that task i prefers to be executed on resource j, which means that the resource node can provide better service to task i. 3)

Load Balancing Degree and Computing Power of Resource Nodes

Let X be a sequence of tasks and resources mapping, then the load balancing degree is defined as: 11Load(X)=∑i=1n(1−C1YiLvi)2$$Load\left( X \right) = \sqrt {\sum\limits_{i = 1}^n {{{\left( {1 - {C_1}\frac{{{Y_i}}}{{L{v_i}}}} \right)}^2}} }$$

Where Y_i denotes how many tasks are assigned to resource node i, Lv_i denotes the computational power of the resource node, Lvi=a*c(Vi)+c*b(Vi)+b*r(Vi)$$L{v_i} = a^*c\left( {{V_i}} \right) + c^*b\left( {{V_i}} \right) + b^*r\left( {{V_i}} \right)$$, where c(Vi)b(Vi)r(Vi)$$c\left( {{V_i}} \right)b\left( {{V_i}} \right)r\left( {{V_i}} \right)$$ denotes the size of the resource node’s processing power, memory, and bandwidth, respectively, and the previous parameters a, b, and c represent the importance of each item in the process of computational power, respectively. C₁ is the normalization parameter, which satisfies 0<C1YiLvi<1$$0 < {C_1}\frac{{{Y_i}}}{{L{v_i}}} < 1$$. 4)

Genetic Coding

Genetic Algorithm (GA)$$\left( {GA} \right)$$ performs operations such as cross mutation through the ordinal number of paths in solving the TSP problem. In the resource allocation problem, it is necessary to encode the decision variables of the problem, so far there are methods such as encoding in binary, real number encoding, matrix encoding, tree encoding, etc. In this paper, in order to introduce the information about the specific problem of resource allocation in the cloud computing environment real number encoding is used by encoding a one-dimensional string that represents the task allocation. Str(i) = a denotes that the task T_i is assigned to a resource V_a for execution. Assuming a specific allocation scheme AssignM: V1:T1,T3,T5 V2:T2,T4,T6$$AssignM:\ \begin{array}{*{20}{c}} {{V_1}:{T_1},{T_3},{T_5}} \\ {{V_2}:{T_2},{T_4},{T_6}} \end{array}$$ then the corresponding encoding is (121212), the left string indicates that task T₁, T₃, T₅ is assigned to V₁ for execution and T₂, T₄, T₆ is assigned to V₂ for execution, so resource node 1 at position 135 and resource node 2 at position 246.

Where M represents the population size, t_min represents the minimum value of completion time in the task allocation scheme, t(i) represents the maximum completion time of the i th task allocation scheme, from the formula (12), we know that the size of t(i) affects the size of f(i), and the smaller t(i) represents the shorter completion time, in this case, the larger the fitness value is, i.e., the more likely to be selected for the next genetic operation, in order to prevent the fitness values between individuals from being too close, the formula squares the fitness function so as to enhance the significance of the individuals. In order to prevent the fitness values between individuals from being too close to each other, the formula squares the fitness function, which enhances the degree of significance of the individual. 6)

Definition of Objective Function

Task allocation in cloud environment refers to the process of assigning the tasks submitted by users to be completed to the corresponding resources to achieve the most scheduling process, the assigned task execution time needs to be minimized as much as possible, and the load of the resources is balanced as much as possible. So in this paper, the time span and load balancing degree are synthesized as evaluation criteria, then the objective function is composed as: 13F(X)=Load(X)*Makespan(X)$$F\left( X \right) = Load\left( X \right)^*Makespan\left( X \right)$$

where Makespan(X)=∑i=1n∑j=1mSij*Eij$$Makespan\left( X \right) = \sum\limits_{i = 1}^n {\sum\limits_{j = 1}^m {{S_{ij}}} } *{E_{ij}}$$, denotes the task time span. where S_ij denotes the execution time of T_i on V_j, 1 < i < n, 1 < j < m

E_ij denotes whether T_i is assigned to V_j for execution, E_ij = 1 if assigned, E_ij = 0, 1 < i < n, 1 < j < m otherwise.

The architecture of CloudSim platform is a multi-layer design with four layers, namely UserCode layer, CloudSim layer and GridSim layer. 1)

UserCode layer, i.e., the user code layer, allows users to customize their own services and scheduling strategies according to their needs.

The simulation experiment process of CloudSim includes the following steps. 1)

Initialization process: Initialize the environment of CloudSim.

The software environment applied in this simulation experiment is specifically shown in Table 1.

The largest task completion time in the printout of CloudSim simulation tool is taken as the execution time of the simulation experiment, and the experimental results are shown in Figure 2.

Figure 2.

Comparison of execution times when the number of tasks is different

The results of the experiment are shown in Fig. 2. The figure shows the running time of the four algorithms under different numbers of tasks. From the experimental results, the execution time of each algorithm does not differ much when the number of tasks is small, especially when the number of tasks is 30, the execution time of the four algorithms differs very little. However, when the number of tasks exceeds 30, the execution time of HGAACO, ACO and GAAA algorithms are significantly lower than that of the traditional polling algorithm. Comparing ACO, GAAA and HGAACO algorithms in this paper, it can be seen that the execution time of ACO algorithm is the longest compared with that of HGAACO algorithm in this paper. Taking the case of 300 tasks as an example, the execution time of this paper’s HGAACO algorithm is only 13ms, while the traditional polling algorithm, ACO algorithm, and GAAA algorithm reach 33ms, 13.5ms, and 27ms, respectively. Therefore, it can be obtained that this paper’s HGAACO algorithm shortens the completion time of the tasks, and is suitable for large-scale task scheduling in cloud environments.

The cost model is built in CloudSim, and the calculated output is used as the execution cost of this simulation experiment. The execution costs of the four scheduling algorithms with different numbers of tasks are shown in Fig. 3. From the experimental results, the cost difference of the four algorithms is relatively stable, and when the number of tasks is 30, the cost difference of the four algorithms is the smallest. When the number of tasks increases gradually, the cost of the GAAA algorithm tends to be consistent with the traditional polling algorithm. The cost of ACO algorithm and HGAACO algorithm in this paper is significantly lower than the cost of GAAA algorithm and traditional polling algorithm.

Figure 3.

Comparison of execution costs when the number of tasks is different

In this section, the VM load imbalance value DI is used to measure its load. The number of tasks for which simulated scheduling is carried out during the experiment is divided into six groups which are 50, 100, 150, 200, 250 and 300, then the load imbalance values of the four algorithms. The load imbalance values corresponding to the four scheduling algorithms with different number of tasks are shown specifically in Fig. 4. From the experimental results, the increasing number of tasks makes the DI values of all four algorithms decrease gradually, indicating that the resource allocation of the system is becoming more and more balanced. From the figure, it can also be seen that the HGAACO algorithm in this paper significantly reduces the load imbalance value compared with the traditional polling algorithm, which indicates that the HGAACO algorithm in this paper has a significant effect on improving the load balancing of the system. When users are more concerned about load balancing, this paper’s algorithm can obviously achieve this purpose.

Figure 4.

Comparison of load values when the number of tasks is different

In order to further illustrate the optimization of this paper’s HGAACO algorithm in resource allocation scheduling time and the improvement of load balancing, this paper will be simulated with the GAAA algorithm and the ACO algorithm under the same resource task conditions and compared with the performance of this paper’s HGAACO algorithm with the same values of the algorithm’s parameters. The resource allocation scheduling task ends when the number of iterations is completed, or the gap between the task completion time after two iterations is completed is within 0.1%. 1)

Comparison of resource load and resource scheduling task execution

According to the results of task allocation on resources, the load of each resource is organized, as shown in Figure 5. In the figure, the horizontal coordinate of 1~10 represents resource 1~resource 10 in turn, and the vertical coordinate is the number of cloud computing resource scheduling tasks. It can be seen that the number of cloud computing tasks of this paper’s HGAACO algorithm is higher than that of the ACO algorithm on resources 1~4, and the number of cloud computing tasks is the same for both of them on resource 5. From resource 5 onwards, the number of tasks of this paper’s HGAACO algorithm is always lower than that of the ACO algorithm, and also lower than that of the GAAA algorithm.

Figure 5.

Resource load situation

Based on the resource load, the total time for resource scheduling task execution is calculated as shown in Table 2. According to the order of time, HGAACO algorithm (73.6ms) <-GAAA algorithm (83.6ms) < ACO algorithm (92.8ms). Obviously, the HGAACO algorithm in this paper takes less time in resource allocation scheduling and has better performance.

2)

Comparison of resource load balancing and task execution time span

The number of resource provisioning tasks set in this section is gradually increased from 20 to 100, and the cloud computing resource nodes are still the 10 nodes established in the previous section. The HGAACO algorithm, GAAA algorithm and ACO algorithm proposed in this paper are utilized to execute the tasks 20 times respectively, and the average value of the 20 times is obtained. Calculate the standard deviation of the allocation results of the three algorithms when they are assigned to different numbers of resource allocation tasks, respectively, as shown in Fig. 6. The horizontal coordinate in the figure indicates the number of tasks, and the vertical coordinate indicates the standard deviation of the allocation results. From the figure, it can be seen that this paper’s HGAACO algorithm allocates tasks more evenly than the GAAA algorithm and the ACO algorithm in cloud computing task scheduling, and with the increase of the number of user-input tasks, this paper’s HGAACO algorithm allocates them more evenly, and the standard deviation of the allocation results is always less than 5, which demonstrates a better performance on the task load balancing problem.

Figure 6.

Standard deviation of distribution results

The execution time span of different algorithms on resource allocation tasks is calculated and the results are shown in Fig. 7. The horizontal coordinate in the figure represents the number of tasks of the cloud platform and the vertical coordinate represents the task execution time of the cloud platform system. It is clear from the figure that under the condition of the same number of tasks, the execution time relationship of the tasks is HGAACO algorithm<GAAA algorithm<ACO algorithm, and with the increase of the number of tasks, the HGAACO algorithm in this paper shows more and more obvious effects. When the number of resource allocation tasks is 20, 40, 60, 80, 100 respectively, the execution time of this paper’s HGAACO algorithm is only 75ms, 141ms, 199ms, 268ms, 322ms, and the execution time grows with the growth of the number of resource allocation tasks, but comparing with the GAAA algorithm and the ACO algorithm, this paper’s HGAACO algorithm can always maintain a low execution time level.

Figure 7.

Comparison of task execution time span