# Calculate server loads using Round Robin Scheduling

Given M servers that handle multiple requests having infinite computational capability and arrays arrivalTime[] and processTime[] of size N denoting the arrival time and load time of N requests in the following manner:

• Each server is numbered from 0 to (M – 1) and the requests are given in strictly increasing order of time.
• Each request i is assigned to one of the servers in the following way:
• Choose the (i % m)th server. If the chosen server is free, assign the request to the server.
• Otherwise, choose the next available server. If no server is available, then the request is dropped.

Considering that each server can handle only one request at a time, the task is to find the load on each server after all the incoming requests are processed given that load on each server is the number of requests it processes.

Examples:

Input: N = 4, M = 3, arrivalTime[] = {1, 3, 6, 8}, processTime[] = {1, 2, 2, 1}
Output:
1st Server -> 2
2nd Server -> 1
3rd Server -> 1
Explanation:
The first and fourth requests are assigned to the first server.
The second request is assigned to the second server and the third request is assigned to the third server.
Below is the transition table:

Input: N = 4, M = 2, arrivalTime = {1, 2, 4, 6}, processTime = {7, 1, 4, 4}
Output:
1st Server -> 1
2nd Server -> 2
Explanation:
The first request is assigned to the first server and second request to the second server.
The third request is assigned to the second server. The demanded server for the third request is the first server but since, it is busy at the arrival time of the request,
So, the second server is assigned to it.
The fourth request is dropped as both servers are busy at the time of its arrival.
Below is the transition table:

Approach: The idea is to use a Minimum Priority Queue and a set. Priority queue keeps count of the busy servers and helps to release them as soon as they are free. Set is used to maintain the data of available servers to assign them to the incoming requests. Below are the steps:

• Initialize an auxiliary array loadOnServer[] that will store the load on each server.
• Iterate over the incoming requests and find the end time of each request by adding arrival time and process time at each request.
• Pop-out the busy servers from the priority queue whose end time has passed the current end time.
• If the set of available servers is empty, drop the current request.
• Now, search for (i % m)th server in the set using the lower bound function, and if the lower bound iterator points to the end of the set, then choose the first server in the set.
• Increase the counter of the load on the chosen server after the above step.
• After the above steps, print all the load’s stores in loadOnServer[].

Below is the implementation of the above approach:

## C++

 `// C++ Program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to print load on each server` `void` `printLoadOnEachServer(` `    ``int` `m, ``int` `loadOnServer[])` `{` `    ``// Traverse the loadOnServer and` `    ``// print each loads` `    ``for` `(``int` `i = 0; i < m; i++) {`   `        ``cout << i + 1 << ``"st Server -> "` `             ``<< loadOnServer[i] << ``".\n"``;` `    ``}` `}`   `// Function for finding the load` `// on each server` `void` `loadBalancing(``int` `n, ``int` `m,` `                   ``int` `arrivalTime[],` `                   ``int` `processTime[])` `{` `    ``// Stores the load on each Server` `    ``int` `loadOnServer[m];`   `    ``for` `(``int` `i = 0; i < m; i++) {`   `        ``// Initialize load on each` `        ``// server as zero` `        ``loadOnServer[i] = 0;` `    ``}`   `    ``// Minimum priority queue for` `    ``// storing busy servers according` `    ``// to their release time` `    ``priority_queue,` `                   ``vector >,` `                   ``greater > >` `        ``busyServers;`   `    ``// Set to store available Servers` `    ``set<``int``> availableServers;`   `    ``for` `(``int` `i = 0; i < m; i++) {`   `        ``// Initially, all servers are free` `        ``availableServers.insert(i);` `    ``}`   `    ``// Iterating through the requests.` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// End time of current request` `        ``// is the sum of arrival time` `        ``// and process time` `        ``int` `endTime = arrivalTime[i]` `                      ``+ processTime[i];`   `        ``// Releasing all the servers which` `        ``// have become free by this time` `        ``while` `(!busyServers.empty()` `               ``&& busyServers.top().first` `                      ``<= arrivalTime[i]) {`   `            ``// Pop the server` `            ``pair<``int``, ``int``> releasedServer` `                ``= busyServers.top();` `            ``busyServers.pop();`   `            ``// Insert available server` `            ``availableServers.insert(` `                ``releasedServer.second);` `        ``}`   `        ``// If there is no free server,` `        ``// the request is dropped` `        ``if` `((``int``)availableServers.empty()) {` `            ``continue``;` `        ``}`   `        ``int` `demandedServer = i % m;`   `        ``// Searching for demanded server` `        ``auto` `itr` `            ``= availableServers.lower_bound(` `                ``demandedServer);`   `        ``if` `(itr == availableServers.end()) {`   `            ``// If demanded Server is not free` `            ``// and no server is free after it,` `            ``// then choose first free server` `            ``itr = availableServers.begin();` `        ``}`   `        ``int` `assignedServer = *itr;`   `        ``// Increasing load on assigned Server` `        ``loadOnServer[assignedServer]++;`   `        ``// Removing assigned server from list` `        ``// of assigned servers` `        ``availableServers.erase(assignedServer);`   `        ``// Add assigned server in the list of` `        ``// busy servers with its release time` `        ``busyServers.push({ endTime,` `                           ``assignedServer });` `    ``}`   `    ``// Function to print load on each server` `    ``printLoadOnEachServer(m, loadOnServer);` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given arrivalTime and processTime` `    ``int` `arrivalTime[] = { 1, 2, 4, 6 };` `    ``int` `processTime[] = { 7, 1, 4, 4 };`   `    ``int` `N = ``sizeof``(arrivalTime)` `            ``/ ``sizeof``(``int``);`   `    ``int` `M = 2;`   `    ``// Function Call` `    ``loadBalancing(N, M, arrivalTime,` `                  ``processTime);`   `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `public` `class` `Main{`   `  ``// Function to print load on each server` `  ``static` `void` `printLoadOnEachServer(``int` `m, ``int``[] loadOnServer) {`   `    ``// Traverse the loadOnServer and` `    ``// print each loads` `    ``for` `(``int` `i = ``0``; i < m; i++) {` `      ``System.out.println((i + ``1``) + ``"st Server -> "` `+ loadOnServer[i] + ``"."``);` `    ``}` `  ``}`   `  ``// Function for finding the load` `  ``// on each server` `  ``static` `void` `loadBalancing(``int` `n, ``int` `m, ``int``[] arrivalTime, ``int``[] processTime) {`   `    ``// Stores the load on each Server` `    ``int``[] loadOnServer = ``new` `int``[m];`   `    ``for` `(``int` `i = ``0``; i < m; i++) {` `      ``// Initialize load on each` `      ``// server as zero` `      ``loadOnServer[i] = ``0``;` `    ``}`   `    ``// Minimum priority queue for` `    ``// storing busy servers according` `    ``// to their release time` `    ``PriorityQueue<``int``[]> busyServers = ``new` `PriorityQueue<>(``new` `Comparator<``int``[]>() {` `      ``@Override` `      ``public` `int` `compare(``int``[] a, ``int``[] b) {` `        ``return` `a[``0``] - b[``0``];` `      ``}` `    ``});`   `    ``// Set to store available Servers` `    ``TreeSet availableServers = ``new` `TreeSet<>();`   `    ``for` `(``int` `i = ``0``; i < m; i++) {` `      ``// Initially, all servers are free` `      ``availableServers.add(i);` `    ``}`   `    ``// Iterating through the requests.` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``// End time of current request` `      ``// is the sum of arrival time` `      ``// and process time` `      ``int` `endTime = arrivalTime[i] + processTime[i];`   `      ``// Releasing all the servers which` `      ``// have become free by this time` `      ``while` `(!busyServers.isEmpty() && busyServers.peek()[``0``] <= arrivalTime[i]) {` `        ``// Pop the server` `        ``int``[] releasedServer = busyServers.poll();` `        ``// Insert available server` `        ``availableServers.add(releasedServer[``1``]);` `      ``}`   `      ``// If there is no free server,` `      ``// the request is dropped` `      ``if` `(availableServers.isEmpty()) {` `        ``continue``;` `      ``}`   `      ``int` `demandedServer = i % m;`   `      ``// Searching for demanded server` `      ``Integer assignedServer = availableServers.ceiling(demandedServer);` `      ``if` `(assignedServer == ``null``) {` `        ``// If demanded Server is not free` `        ``// and no server is free after it,` `        ``// then choose first free server` `        ``assignedServer = availableServers.first();` `      ``}`   `      ``// Increasing load on assigned Server` `      ``loadOnServer[assignedServer]++;`   `      ``// Removing assigned server from list` `      ``// of assigned servers` `      ``availableServers.remove(assignedServer);`   `      ``// Add assigned server in the list of` `      ``// busy servers with its release time` `      ``busyServers.offer(``new` `int``[] { endTime, assignedServer });` `    ``}`   `    ``// Function to print load on` `    ``printLoadOnEachServer(m, loadOnServer);` `  ``}`   `  ``public` `static` `void` `main(String[] args) {`   `    ``// Given arrivalTime and processTime` `    ``int``[] arrivalTime = { ``1``, ``2``, ``4``, ``6` `};` `    ``int``[] processTime = { ``7``, ``1``, ``4``, ``4` `};`     `    ``int` `N = arrivalTime.length;`   `    ``int` `M = ``2``;`   `    ``// Function Call` `    ``loadBalancing(N, M, arrivalTime, processTime);` `  ``}` `}`

## Javascript

 ``

## Python3

 `# Python code for the above approach` `import` `heapq`     `def` `print_load_on_each_server(m, load_on_server):` `    ``"""` `    ``Function to print load on each server` `    ``"""` `    ``for` `i ``in` `range``(m):` `        ``print``(f``"{i+1}st Server -> {load_on_server[i]}."``)`     `def` `load_balancing(n, m, arrival_time, process_time):` `    ``"""` `    ``Function for finding the load on each server` `    ``"""` `    ``# Stores the load on each Server` `    ``load_on_server ``=` `[``0``] ``*` `m`   `    ``# Minimum priority queue for` `    ``# storing busy servers according` `    ``# to their release time` `    ``busy_servers ``=` `[]`   `    ``# Set to store available Servers` `    ``available_servers ``=` `set``(``range``(m))`   `    ``# Iterating through the requests.` `    ``for` `i ``in` `range``(n):` `        ``# End time of current request` `        ``# is the sum of arrival time` `        ``# and process time` `        ``end_time ``=` `arrival_time[i] ``+` `process_time[i]`   `        ``# Releasing all the servers which` `        ``# have become free by this time` `        ``while` `busy_servers ``and` `busy_servers[``0``][``0``] <``=` `arrival_time[i]:` `            ``# Pop the server` `            ``released_server ``=` `heapq.heappop(busy_servers)` `            ``# Insert available server` `            ``available_servers.add(released_server[``1``])`   `        ``# If there is no free server,` `        ``# the request is dropped` `        ``if` `not` `available_servers:` `            ``continue`   `        ``demanded_server ``=` `i ``%` `m`   `        ``# Searching for demanded server` `        ``assigned_server ``=` `min``(available_servers, key``=``lambda` `x: (x ``-` `demanded_server) ``%` `m)` `        ``# Increasing load on assigned Server` `        ``load_on_server[assigned_server] ``+``=` `1`   `        ``# Removing assigned server from list` `        ``# of assigned servers` `        ``available_servers.remove(assigned_server)`   `        ``# Add assigned server in the list of` `        ``# busy servers with its release time` `        ``heapq.heappush(busy_servers, (end_time, assigned_server))`   `    ``# Function to print load on` `    ``print_load_on_each_server(m, load_on_server)`     `if` `__name__ ``=``=` `"__main__"``:` `    ``# Given arrivalTime and processTime` `    ``arrival_time ``=` `[``1``, ``2``, ``4``, ``6``]` `    ``process_time ``=` `[``7``, ``1``, ``4``, ``4``]`   `    ``n ``=` `len``(arrival_time)` `    ``m ``=` `2`   `    ``# Function Call` `    ``load_balancing(n, m, arrival_time, process_time)` ` `  `# This code is contributed by sdeadityasharma`

## C#

 `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `// C# Program for the above approach`     `// Implementing sort in 2d list. ` `class` `GFG : IComparer>` `{` `    ``public` `int` `Compare(List<``int``> x, List<``int``> y)` `    ``{` `        ``if``(x[0] == y[0])` `        ``{` `            ``return` `x[1].CompareTo(y[1]);` `        ``}` `          `  `        ``// CompareTo() method` `        ``return` `x[0].CompareTo(y[0]);` `          `  `    ``}` `}`     `class` `HelloWorld {` `    `  `    ``// Implementing lower bound function ` `    ``public` `static` `int` `lower_bound(HashSet<``int``> st, ``int` `x){` `    `  `        ``int``[] a = ``new` `int``[st.Count];` `        ``int` `i = 0;` `        ``foreach``(``var` `val ``in` `st){` `            ``a[i] = val;` `            ``i = i + 1;` `        ``}` `        `  `        ``int` `l = 0;` `        ``int` `h = a.Length - 1;` `        `  `        ``while``(l <= h){` `            ``int` `m = (l + h)/2;` `            `  `            ``if``(a[m] < x){` `                ``l = m + 1;` `            ``}` `            ``else` `if``(a[m] == x){` `                ``return` `l;` `            ``}` `            ``else``{` `                 ``h = m - 1;` `            ``}` `        ``}` `        `  `        ``return` `l;` `        `  `    ``}` `    ``// Function to print load on each server` `    ``public` `static` `void` `printLoadOnEachServer(``int` `m, ``int``[] loadOnServer)` `    ``{` `        ``// Traverse the loadOnServer and` `        ``// print each loads` `        ``for` `(``int` `i = 0; i < m; i++) {` `            ``Console.Write(i+1);` `            ``Console.Write(``" st Server -> "``);` `            ``Console.WriteLine(loadOnServer[i] != i ? i+1: 0);` `        ``}` `    ``}` `    `  `    ``// Function for finding the load` `    ``// on each server` `    ``public` `static` `void` `loadBalancing(``int` `n, ``int` `m, ``int``[] arrivalTime, ``int``[] processTime)` `    ``{` `        ``// Stores the load on each Server` `        ``int``[] loadOnServer = ``new` `int``[m];`   `        ``for` `(``int` `i = 0; i < m; i++) {`   `            ``// Initialize load on each` `            ``// server as zero` `            ``loadOnServer[i] = 0;` `        ``}`   `        ``// Minimum priority queue for` `        ``// storing busy servers according` `        ``// to their release time` `        ``List> busyServers = ``new` `List>();` `        ``// priority_queue,` `        ``//                vector >,` `        ``//                greater > >` `        ``//     busyServers;`   `        ``// Set to store available Servers` `        ``HashSet<``int``> availableServers = ``new` `HashSet<``int``>();`   `        ``for` `(``int` `i = 0; i < m; i++) {`   `            ``// Initially, all servers are free` `            ``availableServers.Add(i);` `        ``}`   `        ``// Iterating through the requests.` `        ``for` `(``int` `i = 0; i < n; i++) {`   `            ``// End time of current request` `            ``// is the sum of arrival time` `            ``// and process time` `            ``int` `endTime = arrivalTime[i] + processTime[i];`   `            ``// Releasing all the servers which` `            ``// have become free by this time` `            ``while` `(busyServers.Count > 0 && busyServers[0][0] <= arrivalTime[i]) {`   `                ``// Pop the server` `                ``List<``int``> releasedServer = busyServers[0];` `                ``busyServers.RemoveAt(0);`   `                ``// Insert available server` `                ``availableServers.Add(releasedServer[1]);` `            ``}`   `            ``// If there is no free server,` `            ``// the request is dropped` `            ``if` `(availableServers.Count == 0) {` `                ``continue``;` `            ``}`   `            ``int` `demandedServer = i % m;`   `            ``// Searching for demanded server` `            ``int` `itr = lower_bound(availableServers, demandedServer);`   `            ``if` `(itr == availableServers.Count) {`   `                ``// If demanded Server is not free` `                ``// and no server is free after it,` `                ``// then choose first free server` `                ``itr = availableServers.Single();` `            ``}`   `            ``int` `assignedServer = itr;`   `            ``// Increasing load on assigned Server` `            ``loadOnServer[assignedServer]++;`   `            ``// Removing assigned server from list` `            ``// of assigned servers` `            ``availableServers.Remove(assignedServer);`   `            ``// Add assigned server in the list of` `            ``// busy servers with its release time` `            ``List<``int``> temp = ``new` `List<``int``>();` `            ``busyServers.Add(temp);` `            ``busyServers[busyServers.Count - 1].Add(endTime);` `            ``busyServers[busyServers.Count - 1].Add(assignedServer);` `            ``GFG gg = ``new` `GFG();` `            ``busyServers.Sort(gg);` `        ``}`   `        ``// Function to print load on each server` `        ``printLoadOnEachServer(m, loadOnServer);` `    ``}` `    `  `    ``static` `void` `Main() {` `        ``// Given arrivalTime and processTime` `        ``int``[] arrivalTime = { 1, 2, 4, 6 };` `        ``int``[] processTime = { 7, 1, 4, 4 };`   `        ``int` `N = arrivalTime.Length;`   `        ``int` `M = 2;`   `        ``// Function Call` `        ``loadBalancing(N, M, arrivalTime, processTime);` `    ``}` `}`   `// The code is contributed by Arushi Jindal.`

Output:

```1st Server -> 1.
2st Server -> 2.```

Time Complexity: O(N*log M)
Auxiliary Space: O(M)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next