# Bandwidth Allocation Optimization

#### **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**:

1. **Determine Contributable Bandwidth**:

   ```
   C_i = min(B_i, U_i)
   ```

   * `C_i`: Actual contributable bandwidth of node `i`.
2. **Normalize Contributions Across the Network**:

   ```
   W_i = C_i / ΣC_k  for k ∈ {1, 2, ..., N}
   ```

   * `W_i`: Normalized weight for task distribution.
3. **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**:

1. **Contributable Bandwidth**:

   ```
   C_1 = 80, C_2 = 100, C_3 = 50
   ```
2. **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
   ```
3. **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.