LDSO: Dynamic Offloading Algorithm

• LDSO is a dynamic offloading algorithm that minimizes long-term cost by jointly optimizing energy consumption, delay, and queue stability using Lyapunov techniques.
• It operates online on a per-slot basis by computing real-time per-service costs and greedily assigning offloading requests to maintain bounded SBS queues.
• Empirical evaluations show that LDSO outperforms state-of-the-art baselines by reducing cost and queue lengths while enhancing system utilization.

Searching arXiv for the LDSO paper and closely related dynamic offloading work to ground the article in current literature. Dynamic Offloading Algorithm (LDSO) denotes a Lyapunov-based dynamic service offloading method for collaborative edge computing that minimizes offloading cost while ensuring long-term queue stability. In the formulation reported in "A Dynamic Service Offloading Algorithm Based on Lyapunov Optimization in Edge Computing" (Yuan et al., 27 Aug 2025), LDSO operates in a collaborative edge computing system with one macro base station (BS), $M$ small base stations (SBSs), and $n$ users, where requests may be processed by the local SBS, via horizontal multi-hop offloading among SBSs, or, ultimately, in the cloud. Its distinguishing feature is the joint treatment of cost efficiency and stability: the algorithm explicitly models time-varying queues, incorporates both energy consumption and delay into a system cost, and makes fully online slot-by-slot offloading decisions.

1. Definition and system setting

LDSO is formulated for a collaborative edge computing system in which each SBS may cache or serve only a subset of $K$ different service types $(F_1, \ldots, F_K)$, and requests can traverse multiple SBSs before reaching the cloud (Yuan et al., 27 Aug 2025). The algorithm is therefore not merely a routing heuristic; it is an online control policy for service placement under queueing, communication, and processing constraints.

A central object in the model is the SBS buffer queue. Each SBS $i$ maintains a queue $Q_i(t)$ of unprocessed data with dynamics

$$Q_{i}(t+1)=\max \left\{Q_{i}(t)-\mu_{i}(t), 0\right\}+A_{i}(t),$$

where $\mu_i(t)$ is the processed data in timeslot $t$, and $A_i(t)$ is the new arrival. This queue model gives LDSO its stability-oriented character: offloading is not optimized solely for instantaneous latency or energy, but also for whether queues remain bounded over time.

The cost objective at time $n$0 is

$n$1

where $n$2 weights total energy consumption against total service delay. The formal optimization goal is to minimize the long-term average cost subject to average queue stability, bounded queues, and related system constraints. In the paper’s formulation, the average queue condition is written as

$n$3

This definition places LDSO within the broader class of dynamic offloading methods that treat execution context as time-varying. A plausible implication is that LDSO is especially relevant in regimes where instantaneous resource snapshots are insufficient because backlog evolution materially affects future service quality.

2. Optimization framework and mathematical structure

The defining analytical device in LDSO is Lyapunov optimization (Yuan et al., 27 Aug 2025). The algorithm adopts the quadratic Lyapunov function

$n$4

which measures aggregate congestion, and the Lyapunov drift

$n$5

The per-slot optimization criterion is the drift-plus-penalty objective,

$n$6

where $n$7 is a trade-off parameter. In the reported analysis, larger $n$8 drives the long-term average cost closer to the optimum, but also increases queue occupancy. The principal bound is

$n$9

with $K$0 denoting the optimal average cost and $K$1 a constant depending on maximum arrivals and releases.

For each SBS $K$2 and service $K$3, LDSO uses a real-time node-service cost

$K$4

This expression is central because it fuses three terms that are often treated separately in offloading work: energy consumption, delay, and queue accumulation. The queue-dependent term makes the method explicitly backlog-aware rather than purely delay-aware.

The theoretical analysis further states that LDSO achieves $K$5 approximation to the optimum, with convergence time $K$6, where $K$7. The system is described as strongly stable, meaning average queue lengths are bounded and cost approaches the optimum as $K$8. This formalizes the method’s central trade-off: lower cost can be purchased by tolerating larger queues.

3. Decision process and online operation

LDSO operates in a fully-online, slot-by-slot manner (Yuan et al., 27 Aug 2025). At each slot, for each request, the algorithm computes the cost for each eligible edge server and then applies a greedy matching mechanism: among all feasible matches, defined by node capacity and service cache constraints, it selects the one with minimum $K$9.

The operational sequence given in the paper can be summarized as follows. For each time slot, the system computes per-service user demand $(F_1, \ldots, F_K)$0, service rate $(F_1, \ldots, F_K)$1, and transmission rate $(F_1, \ldots, F_K)$2, then evaluates

$(F_1, \ldots, F_K)$3

While unassigned requests remain, the feasible pair $(F_1, \ldots, F_K)$4 with minimum cost is selected, assignment is made, and queue state is updated according to

$(F_1, \ldots, F_K)$5

Three properties of this procedure are technically significant. First, it is online: decisions depend on current queue and cost information rather than a predicted future trajectory. Second, it is constrained: only feasible matches are considered. Third, it is iterative within each slot, so queue evolution and assignment interact during decision-making.

This structure differentiates LDSO from offloading schemes that optimize a single decision variable in isolation. A plausible implication is that the queue update embedded into the slot-level loop makes the algorithm responsive not just to raw resource availability, but to short-term congestion propagation within the edge system.

4. Stability–cost trade-off and parameter interpretation

LDSO is organized around a deliberate trade-off between system stability and offloading cost (Yuan et al., 27 Aug 2025). The queue length determines system stability and directly impacts delay, while the control parameter $(F_1, \ldots, F_K)$6 governs how aggressively the algorithm prioritizes cost minimization relative to queue containment.

The paper states the trade-off explicitly: increasing $(F_1, \ldots, F_K)$7 reduces average cost but increases buffer occupancy, so delays can become larger. Conversely, smaller $(F_1, \ldots, F_K)$8 reduces queue length but yields higher cost. This relation is not incidental; it is the operating principle of the method.

The following table summarizes the main control relationships reported for LDSO.

Element	Role	Effect
$(F_1, \ldots, F_K)$9	Weight between energy and delay	Tunes cost composition
$i$0	Drift-plus-penalty control parameter	Larger $i$1: lower cost, larger queues
$i$2	SBS queue state	Captures congestion and stability
$i$3	Per-node service cost	Combines energy, delay, and queue accumulation

A common misconception is to treat LDSO as an energy-delay optimizer only. The formulation does not support that reading. Queue stability is a formal constraint, queue length enters the decision cost directly, and the theoretical guarantees are stated in terms of both bounded average queues and asymptotic cost optimality. Another possible misconception is that the greedy matching step makes the method purely myopic. The data instead indicate that the Lyapunov framework supplies the long-term control logic, while greediness is used as the slot-level realization mechanism.

5. Empirical evaluation and reported performance

The experimental evaluation reported for LDSO uses a real telecom dataset from Shanghai and varies service intensities and edge or topology parameters (Yuan et al., 27 Aug 2025). The paper states that LDSO converges quickly, with stabilization occurring within tens to hundreds of slots.

In comparative experiments, LDSO is reported to outperform the state-of-the-art baselines DSARA and MECNC. The summary given in the data states that LDSO reduces cost by about $i$4 on average even with buffer size constraints, maintains the smallest queue sizes among the tested schemes, and enables higher system utilization by offloading more data. The same summary attributes to LDSO improvements in scalability and efficiency.

These observations are consistent with the algorithm’s design. Because queue length is both a state variable and a penalty component, the method is structurally biased against decisions that reduce immediate communication or computation cost at the expense of destabilizing buffers. This suggests that the empirical queue advantage is not a secondary effect but a direct consequence of the control objective.

At the same time, the reported trade-off remains in force: queue stabilization does not arise from ignoring cost, and cost efficiency does not arise from ignoring backlog. The experiments are therefore best read as evidence that the Lyapunov-based coupling is effective under the tested conditions, not as evidence that the underlying trade-off disappears.

6. Relation to other dynamic offloading algorithms

LDSO belongs to a broader family of dynamic offloading methods, but its specific combination of queue-aware optimization and Lyapunov control distinguishes it from several adjacent lines of work. In "A Dynamic Load Balancing Algorithm for Distributing Mobile Codes in Multi-Applications and Multi-Hosts Environment" (Jungum et al., 2020), the AWLC algorithm dynamically recalculates each host’s weight from CPU idle rate and memory idle rate and assigns tasks using a minimum load-to-weight ratio. That method shares the adaptive, context-sensitive attribute noted in the source material, but it optimizes server-side assignment and does not explicitly model network cost or long-term queue stability.

Other dynamic offloading approaches in the supplied literature emphasize different control variables. LODCO jointly decides offloading mode, CPU-cycle frequencies, and transmit power for energy-harvesting MEC devices via Lyapunov optimization (Mao et al., 2016). SISYPHUS models server selection as a non-stationary multi-armed bandit and discounts past rewards to adapt to changing conditions (Rahman et al., 2020). DRACO formulates decentralized offloading as multi-agent online learning under partial, delayed, and noisy state information (Tan et al., 2022). DROO uses deep reinforcement learning to learn binary offloading decisions from channel states in wireless powered MEC (Huang et al., 2018).

These comparisons clarify what LDSO is and is not. It is not a dynamic resource monitor based on thresholded response time, as in the application-driven task offloading system of (Tachibana et al., 2022). It is not a task-dependency and channel-allocation method based on D3QN and grouped knapsack optimization, as in (Shi et al., 7 May 2025). It is not a stochastic control policy centered on helper CPU intermittency and finite-horizon MDP structure, as in (Tao et al., 2018). Rather, LDSO is specifically a fully dynamic, online, queue- and cost-aware service offloading algorithm for collaborative edge computing.

A plausible implication is that LDSO is most naturally positioned where the central systems question is not only where to offload computation, but how to do so without sacrificing long-run queue stability across collaborating edge servers.

7. Interpretation, scope, and research significance

Within the supplied literature, LDSO represents a queue-centric interpretation of dynamic offloading (Yuan et al., 27 Aug 2025). Its formal problem statement combines long-term average cost minimization with queue stability, bounded queues, and system-level energy and delay considerations. This makes it especially relevant to collaborative edge systems in which unchecked queue growth can undermine any nominal improvement in instantaneous service cost.

The method’s significance follows from three linked features. First, the system model admits horizontal multi-hop offloading among SBSs and fallback to the cloud, so the control problem is intrinsically distributed. Second, the cost function captures both communication and processing dimensions through $i$5 and $i$6. Third, the Lyapunov formulation yields both an online algorithm and explicit asymptotic guarantees.

There is, however, a boundary to what can be claimed. The data support the statement that theoretical analysis and experiments verify improvements in cost efficiency and stability relative to the evaluated baselines, but they do not establish universal superiority across all edge-computing regimes. Likewise, the source material states that larger $i$7 yields cost closer to optimum but longer queues; it does not claim that a single $i$8 setting is uniformly best.

Taken together, these properties define LDSO as a dynamic service offloading algorithm whose principal contribution is the rigorous coupling of per-slot service assignment with long-term queue control. In the current vocabulary of edge computing, it is best understood as a Lyapunov-optimized mechanism for balancing energy consumption, delay, and queue stability in collaborative multi-server environments.