Bandwidth Allocation Optimization

Bandwidth Allocation Optimization ensures the efficient and fair distribution of tasks among nodes without disrupting their primary internet usage. This dynamic algorithm adapts in real-time to maximize resource utilization and maintain network balance.

Objectives

Efficiency: Utilize available bandwidth optimally across all providers.
Fairness: Distribute tasks proportionally to each provider’s contribution capacity.
Non-Disruption: Ensure allocation does not interfere with providers’ normal internet activities.

Bandwidth Allocation Algorithm

Input Variables:

B_i: Total available bandwidth of node i.
U_i: User-defined maximum bandwidth contribution limit for node i.
N: Total number of nodes in the network.
W_i: Weighted task assignment for node i.

Steps:

Determine Contributable Bandwidth:
```
C_i = min(B_i, U_i)
```
- C_i: Actual contributable bandwidth of node i.
Normalize Contributions Across the Network:
```
W_i = C_i / ΣC_k  for k ∈ {1, 2, ..., N}
```
- W_i: Normalized weight for task distribution.
Allocate Tasks Proportionally:
```
T_i = W_i * T_total
```
- T_i: Number of tasks assigned to node i.
- T_total: Total tasks in the network.

Real-Time Adjustments

Dynamic Reallocation:

If a node reaches 80% of its capacity:
```
Reassign Tasks: T_i = 0.8 * C_i
```
Excess tasks are redistributed to underutilized nodes:
```
T_excess = T_total - ΣT_k  for k ∈ {1, 2, ..., N}
```

Latency Optimization:

Include proximity and latency in task assignment:
```
W_i' = α * (C_i / ΣC_k) + β * (1 / P_i) + γ * (1 / L_i)
```
- P_i: Proximity of node i to the task source.
- L_i: Latency of node i.
- α, β, γ: Weighting factors for bandwidth, proximity, and latency.

Example Calculation

Scenario:

Total tasks: T_total = 1,000
Nodes: 3
- Node 1: B_1 = 100, U_1 = 80
- Node 2: B_2 = 120, U_2 = 100
- Node 3: B_3 = 50, U_3 = 50

Steps:

Contributable Bandwidth:
```
C_1 = 80, C_2 = 100, C_3 = 50
```

Normalized Weights:

W_1 = 80 / (80 + 100 + 50) = 0.36
W_2 = 100 / (80 + 100 + 50) = 0.45
W_3 = 50 / (80 + 100 + 50) = 0.18

Task Allocation:

T_1 = 0.36 * 1,000 = 360
T_2 = 0.45 * 1,000 = 450
T_3 = 0.18 * 1,000 = 180

Key Benefits

Optimized Utilization: Maximizes the use of available bandwidth without overloading nodes.
Fair Distribution: Tasks are equitably assigned based on each provider’s capacity.
Scalability: Adjusts dynamically as nodes join or leave the network.
Reduced Latency: Proximity-based task assignment ensures faster execution.

Implementation in Lumora

Code Framework:

Python-based backend optimization.
Ethereum smart contracts for logging contributions and allocations.

API Integration:

Real-time metrics from nodes are fed into the allocation algorithm for continuous adjustments.

This optimization ensures the Lumora network operates efficiently, balancing loads dynamically and maintaining consistent performance for all participants.

Last updated 1 year ago