What is TCP fairness?

TCP fairness is a concept crucial for equitable network behavior. In the context of TCP, fairness ensures that all connections sharing network resources are treated impartially. This prevents any single connection from dominating the available bandwidth, promoting a balanced distribution of resources. There are a number of fairness mechanisms, including metrics like Jain’s fairness index and techniques like max-min fairness, that assess and aim to provide fair resource allocation. We’ll explore both in this Answer.

Why is fairness necessary?

Without fairness mechanisms, certain connections or users could dominate the available bandwidth, leading to an uneven distribution of resources. This could result in a poor user experience, particularly for those with limited access to network resources.

As there are many protocols available, the fairness indexes allow us to test how protocols perform under various conditions.

Jain’s fairness index

Jain’s fairness index is a metric used to quantify the fairness of resource allocation among multiple users or connections. The index ranges from 0 to 1, with 0 indicating complete unfairness (one user gets all the resources) and 1 indicating perfect fairness (resources are equally shared). It provides a quantitative measure to assess how evenly network resources are distributed among different connections.

Mathematical formula

Jain’s fairness index is calculated using the following formula:

$J = \frac{(\sum x_i)^2}{n \cdot \sum (x_i^2)}$ ,

where $x_i$ represents the allocation to the $i^{th}$ user and $n$ is the total number of users. The index considers both the sum of allocations and the sum of squared allocations, providing a comprehensive measure of fairness. While this index is versatile and can be applied to various scenarios, it is sensitive to the number of users, where small changes can lead to significant index variations. Additionally, the index does not account for individual user experience and assumes equal user importance, potentially diverging from real-world scenarios.

Coding example

The code below uses basic math in Python to calculate the index for three users. Feel free to change the number of users and their allocations on line 11 to see how the index changes.

def jains_fairness_index(allocations):
    # allocations is a list containing the allocations for each user
    sum_allocations = sum(allocations)
    sum_squared_allocations = sum(x**2 for x in allocations)
    num_users = len(allocations)
    fairness_index = (sum_allocations**2) / (num_users * sum_squared_allocations)
    return round(fairness_index, 3)
# Example usage with three users
user_allocations = [30, 40, 25]  # Replace with actual allocations
fairness_index = jains_fairness_index(user_allocations)
print(f"Jain's Fairness Index: {fairness_index}")

Code explanation

Line 1: The function jains_fairness_index() takes one parameter, allocations, which is a list containing the allocations for each user.
Line 3: The sum of all allocations is calculated using the sum() function and stored in sum_allocations.
Line 4: The squared sum of all allocations is calculated using list comprehension and stored in sum_squared_allocations.
Line 5: The total number of allocations is calculated by getting the length of the allocations list using the len() method.
Line 7: The fairness index is calculated using our previous calculations.
Line 8: We round the fairness index to three decimal places before returning it.
Lines 11–14: We create a sample of three allocations and send that to the function. We then print the fairness_index that it returns.

Max-min fairness

Max-min fairness is a common technique used to ensure fair network resource allocation. It calculates the ratio of the minimum to the maximum data rates experienced by different connections. Max-min fairness is achieved when if and only if allocating is possible and if an attempt to increase one connection’s share means reducing the allocation of another connection. While it guarantees equitable distribution, it can be prone to underutilization and computational complexity in changing network environments.

Max-min fairness is reached iteratively. Let’s take a look at the steps involved in this process.

Start with an initial allocation of resources to each user. This initial allocation is calculated by dividing the total capacity by the number of users.
Identify users whose demands are not fully satisfied with the initial allocation. For each unsatisfied user, calculate the excess by subtracting their actual allocation from their demand.
Redistribute the calculated excess among the remaining unsatisfied users.
Repeat steps 2 and 3 until all users are satisfied or we converge.

def max_min_fair_allocation(capacity, demands):
    print(f"Initial demands: {demands}")
    print(f"Capcity: {capacity}\n")
    
    # Calculate the initial fair share
    fair_share = capacity / len(demands)
    # Initialize allocations with the fair share
    allocations = [fair_share] * len(demands)
    # Iterate until convergence
    iteration = 1
    
    while True:
        print(f"Iteration {iteration}: Allocations = {allocations}\n")
        excess_sum = 0  # Total excess across users
        # Update allocations and calculate excess for each user
        for i in range(len(demands)):
            excess = max(0, allocations[i] - demands[i])  # Calculate excess for users i
            excess_sum += excess  # Accumulate excess for all users
            # Update allocation for users i
            allocations[i] = min(demands[i], allocations[i])
       
        # If there is no excess, the allocation is max-min fair
        if excess_sum == 0:
            break
        # Redistribute excess among unsatisfied users
        for i in range(len(demands)):
            if allocations[i] < demands[i]:
                allocations[i] += excess_sum / (len(demands) - allocations.count(demands[i]))
        iteration += 1
    print(f"Final Max-Min Fair Allocations: {allocations}")
    return allocations
# Example usage
capacity = 25
demands = [8.5, 4.7, 10.2, 5]
result = max_min_fair_allocation(capacity, demands)
# Calculating the fairness index for the allocations
fairness_index = jains_fairness_index(result)
print(f"Jain's Fairness Index: {fairness_index}")

Code explanation

Line 1: The function max_min_fair_allocation() takes two parameters: capacity (the total capacity of the resource to be allocated) and demands (a list containing the demands of each user).
Lines 3–9: A fair share of the resources is calculated by dividing the total capacity by the number of users.
An initial allocations list is created with each user allocated their fair share.
Lines 14–35: The algorithm iterates until convergence, where convergence is achieved when no user has excess allocation. In each iteration:
- The total excess across users (excess_sum) is initialized to 0.
- For each user:
  - Excess allocation (if any) is calculated as the difference between the allocated amount and the user’s demand. If this is negative, excess is set to 0.
  - The excess is accumulated to excess_sum.
  - Allocation for the users is updated to be the minimum of their demand and their current allocation.
- If excess_sum is 0, indicating no excess allocation, the loop breaks, and fair allocations have been achieved.
- Otherwise, excess allocation is redistributed among unsatisfied users proportionally to their unmet demands.
Lines 41–47: An example capacity value and a demands list are provided. The max_min_fair_allocation() function is called with these inputs, and the result is stored in the variable result. The fairness index of the resulting allocations is calculated using the previously defined jains_fairness_index() function, and it is printed.

QoE fairness

QoE (Quality of Experience) fairness refers to the equitable distribution of quality experiences among users in a network or service. It ensures that all users, regardless of their location or network conditions, receive a satisfactory and consistent quality of service. In the context of streaming, web applications, or other online services, QoE fairness aims to minimize variations in user experience, such as video buffering or webpage loading times. This is done by effectively allocating resources and optimizing delivery mechanisms. This helps maintain a uniform and satisfactory user experience for everyone connected to the network, promoting fairness in the quality of service provided.

Other indexes

Several other fairness indexes exist to assess and improve fairness in networking. These include the Proportional Fairness index and the long-range dependence fairness index. These metrics consider factors like the duration of resource usage to adapt fairness considerations to different networking scenarios.

In conclusion, TCP fairness is crucial to maintaining a balanced and equitable distribution of network resources. Jain’s Fairness index can be used to measure the fairness of network resource distributions. The max-min algorithm is one of many techniques that aim to provide fair resource allocation, ensuring a smoother and more reliable network experience for all users.

Free Resources