The Min-Min algorithm is a simple cloud scheduling algorithm and is the basis of contemporary cloud scheduling algorithms. The Min-Min algorithm finds the resource which can perform the given tasks in the least time and execute them in that resource [5]. The algorithm Min-Min is adapted from [5] is presented below:

Algorithm 1. Min-Min.

Step 1. For all submitted tasks in the task set Ti.

Step 2. For all resources Ri.

Step 3. Compute Ctij = Etij + rtij.

Step 4. Do while set is not empty.

Step 5. Find task Tk that gives minimum execution time.

Step 6. Assign task Tk to resource Rj that gives minimum expected completion time.

Step 7. Delete task Tk from the set.

Step 8. Update ready time rtj for the selected Resources j.

Step 9. Update Ctij for all Ti .

Step 10. End do.

Fig. 3 shows the flow chart of the Min-Min algorithm.

This algorithm is the same as the Min-Min algorithm. First, we select the machine that can perform various tasks in minimum time. From the selected tasks, we choose the task that will execute in maximum time and execute that. Then, we remove that task from the set [12]. The algorithm Max-Min is adapted from [6] is presented below:

Algorithm 2. Max-Min.

For all task ti in meta-task Mv (in an arbitrary order) do for all machines mj (in a fixed arbitrary order) do ctij = etij + rj end for carry out some processing while all task in Mv are mapped do for each task ti in Mv find its earliest completion time and the machine that obtain it do find the task ti with maximum earliest completion time end for assign the task ti to the machine mi that gives the earliest completion time . delete the task tk from Mv update rj update ctij for all ti belong Mv end while end for.

Fig. 4 shows the flow chart of the Max-Min algorithm.

As proposed by [13], the Least Connection algorithm effectively facilitates dynamic scheduling and routing of incoming visitors to the server with the fewest active connections, as demonstrated in Fig. 5. This approach ensures fair load distribution by continuously monitoring and selecting the least-loaded server based on active connections. It is particularly beneficial in high-traffic scenarios, as emphasized in [8], as it optimizes resource utilization and system performance. The algorithm performs exceptionally well in environments with longer session requirements, such as databases (e.g., MariaDB or SQL) managing high transaction rates. However, alternative load balancing strategies, as recommended in [14], may be more suitable for short-lived connections like HTTP.

Fig .5. Least connection algorithm.

Algorithm 3 below, known as the Least Connection Algorithm adapted from [9], dynamically selects the server with the fewest active connections to efficiently manage incoming requests in distributed systems.

Algorithm 3. Least Connection algorithm.

function least_conn_algorithm(servers):

min_conn = infinity selected_server = null // Loop through each server in the server list for server in servers:

// If the server's connections are less than min_conn if server.connections < min_conn:

// Update min_conn and selected_server min_conn = server.connections selected_server = server // Return the server with the least connections return selected_serve.

As proposed in [17], the source hashing algorithm determines server selection in this load-balancing approach. Utilizing the source IP address as the hash key in the hash table, as explained in [10], ensures consistent routing of a user's request to the server that previously handled their request. Illustrated in Fig. 6, this sincere load-balancing algorithm provides continuity in routing for the same user based on their source IP address. This algorithm is advantageous for applications requiring consistent routing for the same user. However, challenges, as noted in [17], arise due to dynamic IP addresses provided by ISPs, impacting the maintenance of this server-specific routing approach.

Algorithm 4 given below, referred to as the Source Hash Load Balancing algorithm adapted from [11], dynamically selects the server based on the hash value generated from the source address to manage incoming requests efficiently.

Algorithm 4. IP Hash algorithm.

Function source_hash_load_balancing(servers, source_address):

Hash_value = hash_function(source_address) // Use a hash function to generate a hash value Hash_int = convert_hex_to_int(hash_value) // Convert hexadecimal hash value to integer Selected_server = null // Determine the index of the selected server based on the hash value Selected_server_index = hash_int % length(servers) // Return the selected server Return servers[selected_server_index].

The Least Bandwidth algorithm, referenced in [8], dynamically prioritizes servers based on Mbps capacity, directing requests to the server with the least network traffic (Fig. 7). The details in [12] explain how it adapts to varying network bandwidths and changing conditions. By monitoring network traffic and considering weight-based variations, it intelligently selects the least-loaded server, optimizing resource utilization and system performance for diverse scenarios [19]. This approach provides an efficient and adaptable solution for load balancing in environments with fluctuating network conditions, aligning with modern strategies, as outlined in [8].

Algorithm 5, known as the Least Bandwidth Algorithm and adapted from [12], dynamically prioritizes servers based on their Mbps capacity to manage incoming requests in distributed systems efficiently.

Algorithm 5. Least Bandwidth algorithm.

Function least_bandwidth_algorithm(servers):

min_bandwidth = infinity selected_server = null // Loop through each server in the server list for server in servers:

// If the server's Mbps capacity is less than min_bandwidth if server.mbps_capacity < min_bandwidth:

// Update min_bandwidth and selected_server min_bandwidth = server.mbps_capacity selected_server = server // Return the server with the least Mbps capacity return selected_server.

The round-robin algorithm is one of the oldest, simplest, fairest and most widely used scheduling algorithms, designed especially for time-sharing systems. In the RR algorithm, the jobs share the CPU time by allocating a slice of time; usually between 10 and 100 ms for each job, called Quantum Time (QT) [13]. All runnable processes are kept in a circular queue. The CPU scheduler goes around this queue, allocating the CPU to each process for a time interval of one quantum. New processes are added to the tail of the queue [13], [14]. Algorithm 6 shows the pseudocode of the RR algorithm as described in [13]. Table 3 shows an analysis of various load-balancing algorithms [21].

Algorithm 6. The Pseudocode of the RR algorithm in CPU scheduling.

Step 1. Keep the ready queue as a FIFO queue of tasks.

Step 2. New tasks added to the tail of the queue will be selected, set a timer to interrupt after one time slot, and dispatch the tasks.

Step 3. The task may have executed less than one time quantum. In this case:

I. The task itself will release the resources voluntarily.

II. The scheduler will then proceed to the next task in the ready queue.

Step 4. Otherwise, if the running task is longer than one time quantum, the timer will go off and will cause an interruption to the OS.

balancing, which are mentioned below [22]:

Disadvantages Use Cases May lead to suboptimal Applications with makespan due to predictable and stable resource imbalance workloads

Limited dynamic workload handling Similar limitations as Similar to Min-Min, Min-Min suitable for static May lead to suboptimal workloads makespan due to resource imbalance May lead to server High-traffic applications, overload in certain databases with high scenarios transaction rates Performance may degrade with short-lived connections Vulnerable to DDoS Applications requiring attacks and IP spoofing consistent routing for the same users Challenges with dynamic IP addresses

Risk of bandwidth Environments with constraints leading to fluctuating network service interruptions conditions

Dependency on network speed Assumes servers have Basic load balancing in equivalent loads, simple environments leading to resource imbalance

Limited scalability

Min-Min focuses on assigning tasks to resources with the minimum execution time for each individual task. This might lead to some resources overloading while others remain idle. This can result in a suboptimal overall completion time (makespan) for all tasks [16].

Min-Min is designed for static workloads, where the number of tasks and resource capabilities remain constant. However, cloud environments are dynamic, with workloads fluctuating. This can lead to inefficient load balancing when workloads change [17].

Min-Min typically assumes homogeneous resources (all resources have the same capabilities). In reality, cloud environments consist of heterogeneous resources (e.g., CPU, memory, storage) with varying capacities. This can lead to suboptimal task allocation if resource heterogeneity is not considered [17].

Like Min-Min, Max-Min prioritizes minimizing the workload on the most loaded resource. While this might seem beneficial, it can lead to situations where other resources remain underutilized. This can result in a suboptimal overall completion time (makespan) for all tasks [24].

Max-Min, like Min-Min, is designed for static workloads. When workloads fluctuate in dynamic cloud environments, Max-Min's efficiency can decrease, potentially leading to imbalanced load distribution [17].

Max-Min typically assumes homogeneous resources (all resources have the same capabilities). In reality, cloud environments consist of heterogeneous resources (e.g., CPU, memory, storage) with varying capacities. This can lead to suboptimal task allocation if resource heterogeneity is not considered [17].

Attackers could potentially manipulate source addresses to target specific servers, leading to uneven loads or overloading a particular server [18].

Uneven distribution of hash values can lead to certain servers consistently handling a disproportionate share of the load, like the Traffic Polarization Effect [19] in networking, in which certain traffic or congestion gets collected in certain routers or servers.

Dynamic IP addresses, especially those assigned by Internet Service Providers (ISPs), introduce the risk of IP spoofing in systems that rely on IP-based authentication or verification. Attackers may exploit the dynamic nature of IP assignments to impersonate legitimate users or devices by forging their source IP addresses [18].

Choosing routes with the least traffic may lead to bandwidth constraints, suspending the site due to the Bandwidth Limit Exceeded 509 error [21]. Users experience service disruption, and the site becomes temporarily unavailable.

Internet or connection speed heavily depends on the data transfer rate, affecting the user experience. Slower network performance in low-bandwidth systems negatively impacts data transfer rates [20].

The inability to manage bandwidth consumption may lead to unpredictable spikes, potentially causing service interruptions. Difficulty in maintaining a consistent and reliable level of service [20].