## 5 Simulation and Results Analysis
\begin{table}
\begin{tabular}{c c c c c c c c c c c c} \hline
**NO** & **\#** & **v** & **0** & **\(\omega\)** & **\(\sigma\)** & **\(a\)** & **\(\beta\)** & **\(\gamma\)** & **\(\kappa\)** & **Num** & **CT** \\ \hline
1 & 0.1 & 0.1 & \(\pm\)0.1 & 0.3 & 0.1 & 1 & 1 & 1 & 1 & 334 & 15.432 \\
2 & 0.1 & 0.1 & \(\pm\)0.1 & 0.3 & 0.1 & 1 & 1 & 2 & 2 & 319 & 16.212 \\
3 & 0.1 & 0.1 & \(\pm\)0.1 & 0.3 & 0.1 & 2 & 2 & 1 & 1 & 394 & 20.134 \\
4 & 0.1 & 0.1 & \(\pm\)0.1 & 0.3 & 0.1 & 2 & 2 & 2 & 2 & 405 & 19.293 \\
5 & 0.2 & 0.2 & \(\pm\)0.2 & 0.4 & 0.2 & 1 & 1 & 1 & 1 & 315 & 14.289 \\
6 & 0.2 & 0.2 & \(\pm\)0.2 & 0.4 & 0.2 & 1 & 1 & 2 & 2 & 287 & 12.785 \\
7 & 0.2 & 0.2 & \(\pm\)0.2 & 0.4 & 0.2 & 2 & 2 & 1 & 1 & 376 & 16.112 \\
8 & 0.2 & 0.2 & \(\pm\)0.2 & 0.4 & 0.2 & 2 & 2 & 2 & 2 & 389 & 17.834 \\
9 & 0.3 & 0.3 & \(\pm\)0.3 & 0.2 & 0.3 & 1 & 1 & 1 & 1 & 329 & 14.115 \\
10 & 0.3 & 0.3 & \(\pm\)0.3 & 0.2 & 0.3 & 1 & 1 & 2 & 2 & 301 & 13.454 \\
11 & 0.3 & 0.3 & \(\pm\)0.3 & 0.2 & 0.3 & 2 & 2 & 1 & 1 & 392 & 16.298 \\
12 & 0.3 & 0.3 & \(\pm\)0.3 & 0.2 & 0.3 & 2 & 2 & 2 & 2 & 421 & 21.103 \\ \hline \end{tabular}
\end{table} 
Table 1: Number of iterations and convergence time with diverse parameters. where \(\mathit{Load}_{{}_{i}}\) is the load of virtual machine, that is, the load of the slave node, and \(\mathit{Load}_{{}_{avg}}\) indicates the average load of all virtual machines. The bigger the degree of load balancing is, the more unbalanced the load will be. We limit the number of iterations to below 600 and the simulation results of execution time and degree of load balancing by different numbers of ants are shown in Figures 2 and 3. It can be seen from the results that the minimum values are obtained for the number of iterations and the degree of load balancing when the number of ants is set to 100. Apart from the number of ants, the maximum searching step for each ant also has influence on the results, so we carry out the experiment by different maximum searching steps of five (Step-5), 10 (Step-10), and 20 (Step-20) steps. Figures 4 and 5 shows the results of time execution and degree of load balancing by different maximum searching steps. Figure 3: Degree of load balancing by different numbers of ants. Figure 2: Execution time by different numbers of ants. It can be seen from the results that the minimum searching time is obtained when the maximum searching step is set to 10. Due to the forward ants in step-20 needing to go further than the ants in step-10, it takes more time for forward ants in step-20. For the maximum searching with five steps, the performance is weak because most of forward ants cannot find out the proper slave nodes within five steps. In addition, we compare the presented approach by improved ant colony optimization (IACO) with random algorithm (RA) and LBVS algorithm [20] for load balancing in cloud platforms. In this experiment, the number of slave nodes is 10,000, and the maximum searching step is 10. Other parameters are set by the optimal values from the above simulations. The LBVS algorithm was not proposed for cloud computing, so we combine heuristic methods to LBVS for getting better performance in our experiments. For random algorithms, 100 ants are distributed randomly in 100 slave nodes. In a unit time, the ants record the maximum and minimum slave nodes in searching processes and perform load balancing before the next unit time comes. The number of iterations is also limited to 600. The comparison results are shown in Figures 6 and 7. Figure 4: Execution time by different maximum searching steps. Figure 5: Degree of load balancing by different maximum searching steps. In order to test the ability for different scale of slave nodes in cloud computing platform, we carry out load balancing experiments with the numbers of slave nodes from 10,000 to 100,000. The results are shown in Figure 8.  
Figure 8: Execution time for load balancing by different algorithms. Figure 6: Execution time by different algorithms. Figure 7: Degree of load balancing by different algorithms.