A secure solution based on load-balancing algorithms between regions in the cloud environment

New grouping method

This method subdivides the files into three groups G₁, G₂, and G₃. At the start, these groups are empty. The number of files in G₁, G₂, and G₃ are denoted by f₁, f₂, and f₃, respectively. In the practice, $f_1=\frac{Fn}{3}$, $f_2=\frac{Fn}{3}$, and f₃ = Fn − f₁ − f₂. Consequently, G₁ = {F₁, …, F_f1}, G₂ = {F_f1+1, …, F_f1+f2}, and G₃ = {F_f1+f2+1, …, F_Fn}. It is clear that the groups G₁, G₂, and G₃ depend on the manner that initially the files are sorted. Therefore, the initial state of the set of files is very important to determine the groups. Ten algorithms are presented in this article based on the grouping method. Changing the way that we select files into groups and between groups is the core of the difference between the proposed algorithms. Figure 4 gives an example of the subdivision of the given set of files.

Longest file size algorithm (LFS)

Firstly, the files are sorted according to the decreasing order of their size. The scheduling of the sorted files will be done one by one on the virtual machine that has the minimum value of Tf_i until all files finish their execution. The complexity of this algorithm is depending on the algorithm that sorts the files. The heap sort is adopted for this algorithm. Consequently, the complexity of this algorithm is O(nlogn). All these steps are described in Algorithm 2. Hereafter, we denoted by DER(F) the procedure that receives as input a list of numbers F and sorts these numbers in decreasing order. These numbers will be the sizes of the files that we want to sort them. The procedure DER(F) is based on the heap sort method. Hereafter, we denoted by SCL(F) the procedure that schedules the element i (∀i, 1 ≤ i ≤ F_n) of F on the virtual machine which has the minimum Ts_j. The instructions of SCL(F) are detailed in Algorithm 1.

 
_______________________ 
Algorithm 1 Scheduling of a list F Algorithm (SCL(F))___________________________ 
  1:  for (i = 1 to Fn) do 
 2:       Determine j subject to   min 
1≤j≤Vn Tsj 
  3:       Update Tsj = Tsj + Fi 
  4:  end for____________________________________________________________________________    

The instructions of LFS are detailed in Algorithm 2.

 
__________________________________________________________________________________________ 
Algorithm 2 Longest file size Algorithm (LFS)_______________________________________ 
  1:  Call DER(FL) 
  2:  Call SCL(FL) 
  3:  Calculate Gfv 
 4:  Return Gfv______________________________________________________________________    

Third-grouped set algorithm (TGS)

The content of the groups depends on the manner that the files are sorted initially. We adopt three manners to sort the files.

• First manner: Take the files as given initially without applying any sorting.

• Second manner: Sort the files according to the increasing order of their size.

• Third manner: Sort the files according to the decreasing order of their size.

For each manner, firstly we create the groups G₁, G₂, and G₃. After that, we constitute a permutation for these groups. There are six possibilities to constitute a sequence of groups. The first sequence is G₁, G₂, and G₃ denoted as {G₁, G₂, G₃}. For this sequence, we schedule all files in G₁, next we schedule all files in G₂ and finally, we schedule all files in G₃. The second sequence is {G₁, G₃, G₂}. The third sequence is {G₂, G₁, G₃}. The fourth sequence is {G₂, G₃, G₁}. The fifth sequence is {G₃, G₁, G₂}. The last sequence is {G₃, G₂, G₁}. So, for each manner, six sequences are executed and the best solution is picked and returned.

Third-grouped with minimum-load algorithm (TGM)

The division into groups of files is adopted in this algorithm. Three groups are created by the same method described in the section ‘New grouping method’ with the three manners detailed in the same subsection. For each manner, a solution is calculated and the best solution is selected. The algorithm is designed in five steps. The first step is to apply the first manner and create the three groups G₁, G₂, and G₃. The second step is to calculate the load of each group. The load is the sum of all sizes of the files in the group. Indeed, the load of G₁ is denoted by Lo₁ and equal to ${\sum }_{i=1}^{f_1}\left(S{z}_i\right)$. The load of G₂ and G₃ are denoted by Lo₂ and Lo₃, respectively. So, we have $L{o}_2={\sum }_{i=f_1+1}^{f_1+f_2}\left(S{z}_i\right)$ and $L{o}_3={\sum }_{i=f_1+f_2+1}^{F_n}\left(S{z}_i\right)$. The third step is to choose the group which has the minimum load. This group will be denoted by Gc. The fourth step is to schedule the first file in Gc. We update loads of different groups and a new choice of a Gc will be determined and so on until the schedule of all the files. The total gap is calculated and denoted by Gfv₁. We restart step 1 with the second manner described in the above Subsection and the total gap for this solution is calculated and denoted by Gfv₂. Finally, for the fifth step, we restart, step 1 with the application of the third manner, and a new gap is calculated and denoted by Gfv₃. The best solution Gfv is calculated as given in Eq. (2). (2)${\displaystyle Gfv=\underset{1\le k\le 3}{min}\left(Gf{v}_k\right)}$

Third-grouped excluding-files with minimum-load algorithm (TEM)

The first step of this algorithm is the select the V_n longest files. Each file will be scheduled in a distinguished virtual machine. Now, the F_n − V_n remaining files will be scheduled in the virtual machines according to TGM. We denoted by EXL(F) the function that returns a list that contains the V_n longest files among F. We denoted by Rem(F) the function that returns a list that contains the F_n − V_n remaining files after excluding the V_n longest files among F. Hereafter, we denoted by IER(F) the procedure that receives as input a list of numbers F and sorts these numbers in decreasing order. Hereafter, we denoted by GrP(F) the procedure that subdivided the listed files F into the three groups G₁, G₂, and G₃ described in the section ‘New grouping method’. The procedure MG() is responsible to return the group that has the maximum load. The procedure SCLF(L) is responsible to schedule the first element of L on the available virtual machine. All steps of the algorithm are described in the Algorithm 3.

 
________________________________________________________________________________________ 
Algorithm 3 Third-Grouped Excluding-Files with Minimum-Load Algorithm 
(TEM)_____________________________________________________________________________________________ 
  1:  Set Ls = EXL(FL) 
  2:  Call SCL(Ls) 
  3:  Set Lr = Rem(FL) 
  4:  for (manner = 1 to 3) do 
 5:       if (manner = 2) then 
 6:            Call DER(Lr) 
  7:       end if 
 8:       if (manner = 3) then 
 9:            Call IER(Lr) 
10:       end if 
11:       Call GrP(Lr) 
12:       for (i = 1 to Fn − Vn) do 
13:            Calculate Lo1, Lo2, Lo3 
14:            Set Gm = MG() 
15:            Call SCLF(Gm) 
16:            Update Gm 
17:       end for 
18:       Calculate Gfvmanner 
19:  end for 
20:  Calculate Gfv =      min 
1≤manner≤3(Gfvmanner) 
21:  Return Gfv______________________________________________________________________    

Third-grouped one-by-one algorithm (TGO)

The determination of the three groups described above is adopted for this algorithm. These three groups will be created as described in the section ‘New grouping method’. The three manners as also applied. For each manner, firstly we create the groups G₁, G₂, and G₃. After that, we constitute a permutation for these groups. There are six possibilities to constitute the order of groups. The first order is G₁, G₂, and G₃ and denoted by Order₁. This means that we schedule the first file from G₁, the first file from G₂, and the first file from G₃. For the fifth order, we schedule applying the same method, the first file from each group, following the order of the group, is scheduled. The second order is {G₁, G₃, G₂} and denoted by Order₂. The third order is {G₂, G₁, G₃} and denoted by Order₃. The fourth order is {G₂, G₃, G₁} and denoted by Order₄. The fifth order is {G₃, G₁, G₂} and denoted by Order₅. The last order is {G₃, G₂, G₁} and denoted by Order₆. So, for each manner, six orders are executed and the best solution is picked and returned. We denoted by SCG(Order_h) with h = {1, …, 6} the procedure that schedules the files following the order received as input until scheduling of all files.

 
________________________________________________________________________________________ 
Algorithm 4 Third-Grouped One-by-one Algorithm (TGO)_______________________ 
  1:  for (manner = 1 to 3) do 
 2:       if (manner = 2) then 
 3:            Call DER(FL) 
  4:       end if 
 5:       if (manner = 3) then 
 6:            Call IER(FL) 
  7:       end if 
 8:       Call GrP(FL) 
  9:       for (h = 1 to 6) do 
10:            Call SCG(Orderh) 
11:            Calculate Gfvhmanner 
12:       end for 
13:  end for 
14:  Calculate Gfv =  min 
1≤h≤6(     min 
1≤manner≤3(Gfvhmanner)) 
15:  Return Gfv______________________________________________________________________    

Three-files swap third-grouped algorithm (TST)

The determination of the three groups described above is adopted for this algorithm. These three groups will be created as described in the section ‘New grouping method’. The three manners as also applied. For each manner, firstly we create the groups G₁, G₂, and G₃. After that, we constitute a permutation for these groups. There are six possibilities to constitute the order of groups as described in the section ‘Third-grouped one-by-one algorithm (TGO)’. So, for each manner, six orders are executed. For each order, a swap of three files is applied. These files are the first file F1 from G₁, the first file F2 from G₂, and the first file F3 from G₃. The swapping is as follows:

• Restore a copy of F1

• Apply a translation of the f₁ − 1 files to the left beginning with position 2 and ending with position f₁.

• Move F2 at the end of G₁.

• Move F3 at the front of G₂.

• Move the stored copy of F1 at the front of G₃.

Now, after the swapping TGO described in the ‘Third-grouped one-by-one algorithm (TGO)’ on the new set of files obtained after swapping.

Hereafter, the procedure SWap(L1, L2, L3) is responsible to swap F1, F2, and F3 the first files of the lists L1, L2, and L3 given as input, as the description above.

 
________________________________________________________________________________________ 
Algorithm 5 Three-files Swap Third-Grouped Algorithm (TST)_________________ 
  1:  for (manner = 1 to 3) do 
 2:       if (manner = 2) then 
 3:            Call DER(FL) 
  4:       end if 
 5:       if (manner = 3) then 
 6:            Call IER(FL) 
  7:       end if 
 8:       Call GrP(FL) 
  9:       Call SWap(G1,G2,G3) 
10:       for (h = 1 to 6) do 
11:            Call SCG(Orderh) 
12:            Calculate Gfvhmanner 
13:       end for 
14:  end for 
15:  Calculate Gfv =  min 
1≤h≤6(     min 
1≤manner≤3(Gfvhmanner)) 
16:  Return Gfv______________________________________________________________________    

On-tenth-files swap third-grouped algorithm (OST)

The determination of the three groups described above is adopted for this algorithm. These three groups will be created as described in the section ‘New grouping method’. The three manners as also applied. For each manner, firstly we create the groups G₁, G₂, and G₃. After that, we constitute a permutation for these groups. There are six possibilities to constitute the order of groups as described in the section ‘Third-grouped one-by-one algorithm (TGO)’. So, for each manner, six orders are executed. For each order, a swap of three files is applied. These files are the first $\frac{F_n}{10}$ files from G₁, the first $\frac{F_n}{10}$ files from G₂, and the first $\frac{F_n}{10}$ files from G₃. The swapping is as follows:

• Restore a copy of the first $\frac{F_n}{10}$ files from G₁

• Apply a translation of the f₁ − 10 files to the left beginning with position 11 and ending with position f₁.

• Move the first $\frac{F_n}{10}$ files from G₂ at the end of G₁.

• Move the first $\frac{F_n}{10}$ files from G₃ at the front of G₂.

• Move the stored copy of the first $\frac{F_n}{10}$ files from G₁ at the front of G₃.

Now, after the swapping TGO described in the ‘Third-grouped one-by-one algorithm (TGO)’ on the new set of files obtained after swapping.

Best-value of three algorithms (BVT)

This algorithm returns the minimum value after running the LFS, TGS, and OST.

 
________________________________________________________________________________________ 
Algorithm 6 Best-value of three algorithms (BV T)__________________________________ 
  1:  Call LFS 
 2:  Set Gfv1 = Gfv 
 3:  Call TGS 
 4:  Set Gfv2 = Gfv 
 5:  Call OST 
 6:  Set Gfv3 = Gfv 
 7:  Calculate Gfv =  min 
1≤h≤3(Gfvh) 
  8:  Return Gfv______________________________________________________________________    

Best-value of five algorithms (BFI)

This algorithm returns the minimum value after running the LFS, TGM, TEM, TGO, and TST.

Best-value of four algorithms (BFO)

This algorithm returns the minimum value after running the LFS, TGS, TST, and OST.

Based on the above algorithms, it is clear to see that the algorithm BVT dominates the three used algorithms LFS, TGS, and OST. In the same context, the algorithm BVF dominates the five used algorithms LFS, TGM, TEM, TGO, and TST. Finally, the algorithm BVF dominates the four used algorithms. Consequently, we discussed only six algorithms in the experimental results. These algorithms are LFS, TGS, OST, BVT, BFI, and BFO.

Instances

The tested instances are coded to be used by the proposed algorithms measuring the performance in terms of gap and time. These instances are depending on the manner that we generate the Sz_i values. Indeed, the generation of Sz_i is based on two distributions. The first one is the uniform distribution and is denoted by UN[.]. The second one is the normal distribution and is denoted by NO[.].

The generated classes are illustrated as follows:

• Class 1: Sz_i in UN[25, 130].

• Class 2: Sz_i in UN[110, 370].

• Class 3: Sz_i in NO[220, 25].

• Class 4: Sz_i in NO[330, 110].

The choice of the number of virtual machines and the number of files that can be tested are presented in Table 4.

For each number of virtual machines and each number of files, 10 different instances were generated. In total, the number of generated instances is (3 × 3 + 4 × 4 + 3 × 3) × 10 × 4 = 1, 360. The generation of instances is inspired by the analysis presented in Alquhayz, Jemmali & Otoom (2020); Alquhayz & Jemmali (2021a), and Jemmali & Alquhayz (2020b).

Metrics

All algorithms presented in ‘Proposed algorithms’ will be discussed based on several metrics. These metrics are defined as follows.

• $\vec{Z}$ The minimum value obtained after executing of all algorithms.

• Z The value of the presented algorithm.

• Mp The percentage of instances when $\vec{Z}=Z$.

• $Gp=\frac{Z-\vec{Z}}{Z}$, if Z = 0, then Gp = 0.

• Ag The average Gp for a fixed set of instances.

• Time The time of execution of an algorithm for a fixed set of instances. This time is in seconds and we recorded it as “.” if the time is less than 0.0001 s.

Discussion results

In this subsection, we discuss the performance of the proposed algorithms. This discussion is based on five kinds of analyses. The first kind is an overall analysis of the obtained results. The second kind is based on the number of files discussed. The third kind is based on the number of virtual machines discussed. While the fourth kind is based on the class’s discussion. Finally, the fifth kind is based on the pair discussion. These kinds of analyses are discussed separately in the following subsections.

Pair discussion

In this subsection, we discuss the variation of the average gap when the pair of (F_n, V_n) changes.

Figure 5 presents a comparison between the best algorithm BFO and BFI according to the pair(F_n, V_n). This latter figure shows that the curve of BFO is always below the curve of BFI for all values of the pairs (F_n, V_n). This explains that BFI is the best algorithm. In addition, it is easy to see that the total number of the different pairs is 34.