C ODED TASK O FFLOADING FOR F LUID C OMPUTING : A P RIVACY-AWARE A PPROACH UNDER D2D N ETWORKS
Diego Cajaraville-Aboy,
Manuel Fernández-Veiga, Ana Fernández-Vilas, Rebeca P. Díaz-Redondo atlanTTic – ICLAB, Universidade de Vigo Escuela de Ingeniería de Telecomunicación, Vigo, 36310, Spain {dcajaraville,mveiga,avilas,rebeca}@det.uvigo.es
arXiv:2607.08440v1 [cs.DC] 9 Jul 2026
A BSTRACT Fluid Computing aims to support distributed applications execution across heterogeneous cloud, edge, and device resources, motivating task execution mechanisms that adapt to dynamic and privacysensitive environments under runtime conditions. In this context, current task offloading schemes rarely address privacy risks and information leakage under adversarial execution settings; furthermore, most coded computing proposals focus on straggler mitigation without considering system-level objectives such as energy awareness. This paper proposes a coded task offloading scheme for D2D networks under stochastic task arrivals and queue-based dynamics. The proposal combines task offloading techniques with linear secret sharing schemes, where tasks are encoded into redundant shares to support threshold-based recovery, straggler mitigation, and privacy preservation while enhancing system performance. Then, we formulate a privacy-aware offloading problem that jointly optimizes delay and energy while penalizing the theoretical privacy leakage of coded tasks under noisy leakage observations. The problem is solved using a branch-and-bound solver alongside a lightweight heuristic scheduler, both of which are evaluated through a discrete-event simulator. Results show that coded offloading improves the delay–energy trade-off with respect to classical full and parallel offloading schemes, while the heuristic achieves near-optimal performance, outperforming baseline and state-of-the-art solvers. The results also show how privacy leakage penalties reshape offloading decisions, exposing an inherent delay–energy–privacy trade-off. Keywords Coded Task Offloading · Privacy Leakage · Linear Secret Sharing · D2D Networks · Fluid Computing
1
Introduction
Current digital systems are increasingly surrounded by distributed and data-driven applications, such as IoT or AI services, running across heterogeneous resources ranging from cloud-native infrastructures and edge servers to resource-constrained devices. These deployments aim to improve response delay, leverage nearby computational capabilities, and adapt execution to dynamic application requirements. Enhancing the deployment and performance of distributed applications is therefore a relevant research challenge, especially in future 6G and D2D scenarios, where communication, computation, and sensing resources are expected to be jointly managed under massive and dynamic environments [1, 2]. Moreover, distributed applications often involve the exchange or processing of sensitive information, which makes privacy and data-management requirements essential, especially in applications such as distributed AI, federated learning, etc.
distributed across multiple computational tiers to exploit the benefits of each tier and improve latency, energy consumption, or resource utilization. However, the literature has also highlighted that these systems are still limited by fragmented infrastructures, weak interoperability, centralized control assumptions, and poor adaptation to highly dynamic workloads [5, 6]. These limitations may lead to suboptimal placements, inefficient communications between tiers and energy consumption, thereby increasing the digital carbon footprint [7]. In addition, privacy requirements are not always integrated as a first-class design dimension, despite being essential when computation is moved across heterogeneous and potentially untrusted resources.
In recent years, the Fluid Computing paradigm [8, 9] has emerged as a novel approach to overcome these drawbacks. This paradigm abstracts the continuum as a unified compute–storage–network fabric, allowing applications to be deployed according to their requirements while hidSeveral works in the state of the art have addressed ing the complexity of the underlying infrastructure. This this problem within the Cloud-to-Edge Continuum [3, 4], approach can support fluid deployments in which appliwhere computation, storage, and networking resources are cations dynamically adapt their placement and execution
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
according to runtime conditions, such as resource availability, mobility, latency, or energy constraints. Even though research in this field is still scarce, especially in terms of algorithmic solutions and orchestration architectures, two promising mechanisms can support and enhance fluid deployments: task offloading and coded computing.
emissions [19, 20], along with other potential vectors such as wireless exposure or execution traces. Even though task offloading and coded computing share common objectives, works that jointly consider both mechanisms, especially under privacy concerns, remain scarce. To address this gap, we propose a privacy-aware coded task offloading scheme for fluid deployments over heterogeneous D2D networks, where tasks are encoded with LSS techniques to enhance system performance through threshold-based recovery from the fastest selected devices. We instantiate the scheme as a time-slotted queue-based scheduling system with stochastic task arrivals, and formulate a delay–energy optimization problem with an explicit theoretical privacy-leakage penalty under noisy leakage observations. Specifically, this paper presents the following contributions:
Task offloading [10, 11] has been widely explored as a useful mechanism that allows devices to delegate computational workload to nearby edge servers, cloud nodes, or peer devices in order to improve latency, energy consumption, or execution cost. It has been applied in multiple scenarios, including mobile edge/cloud computing, IoT systems and vehicular networks [12]. Although task offloading is highly useful, most proposals rely on classical approaches inherited from mobile cloud computing and fog computing settings. As a result, they often do not fully capture the dynamic execution requirements needed for fluid deployments, such as time-varying resource availability and runtime scheduling of communication and computation resources. Moreover, most works focus on systemperformance metrics and usually leave privacy concerns as a secondary aspect. Existing privacy-aware task offloading schemes mainly model privacy from the perspective of user metadata or sensitive context information, such as location, task association, or task type, rather than information leakage from the offloaded computational payload [13, 14]. This limitation becomes more relevant in Fluid Computing environments, where tasks may be dynamically distributed across heterogeneous devices that can be untrusted or only partially observable.
• We model a coded task offloading scheme that combines LSS-based task encoding with time-slotted queue dynamics and stochastic task arrivals over D2D networks. • We quantify the theoretical information leakage of the LSS-based coded tasks under noisy leakage observations, relying on Fourier-analytic leakage bounds to define the privacy-leakage penalty. • We formulate a privacy-aware optimization problem that jointly minimizes task delay and energy consumption under a privacy-leakage penalty term, and solve it using a branch-and-bound (BnB)-based greedy solver and a lightweight heuristic solver. • We implement a discrete-event simulator to evaluate the proposed system under realistic queue evolution, transmission/computation resource contention, and memoryadmission dynamics. • Finally, we analyze the proposed coded task offloading scheme under different validation settings, assessing the impact of the privacy-leakage penalty on the delay– energy trade-off and comparing the proposed solvers with baseline and state-of-the-art task-offloading policies.
On the other hand, coded computing [15, 16] relies on coding theory to introduce redundancy during workload execution, enabling robustness in distributed computing systems through straggler mitigation while providing data privacy. This idea is conceptually aligned with secure multi-party computation protocols. Linear secret sharing (LSS) schemes, which form a foundational class that cover most of known and practical secret sharing schemes, have also been used as a baseline mechanism to provide redundancy and privacy in secure coded computation [17, 18]. These approaches have been mainly applied to task-offloading scheme for linear inference and distributed matrix multiplication applications, but they do not often cover general large-scale distributed computation. Moreover, they usually focus on coding mechanisms and recovery guarantees, while they do not fully model general task-offloading dynamics, such as stochastic task arrivals, resource-constrained devices, system evolution or system performance in terms of energy consumption. Privacy concerns are also typically left aside beyond the threshold guarantees of LSS, where the secret can only be recovered after collecting a sufficient number of coded shares. This is especially relevant because even coded data may be exposed through noisy leakage observations, with side-channel attacks being widely recognized as practical cybersecurity threats based on indirect execution signals such as timing, power consumption, or electromagnetic
The remainder of this paper is organized as follows. Section 2 provides a comprehensive state-of-the-art review on task offloading schemes, including privacy-aware approaches. Section 3 outlines the system model for the coded task offloading scheme, including the underlying network, delay, energy consumption, and privacy leakage models. Section 4 defines the considered optimization problem, which is proven to be NP-hard, and the proposed solvers. Section 5 describes the experimental setup and simulation settings, and Section 6 presents the evaluation results. Finally, Section 7 concludes the paper, highlighting the contributions and outlining future work.
2
Related Work
Task/Computation/Workload offloading has been widely studied as a key mechanism to optimize resource alloca2
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
tion in distributed computing networks. These techniques support resource-constrained devices by delegating computation to other nearby devices, edge/fog resources, or cloud capabilities. In general, existing works can be classified according to: i) the execution scenario, including multi-access edge computing, mobile cloud computing, fog-assisted computing, D2D-enabled offloading, etc; ii) the task model, ranging from full task offloading (the entire task is assigned to a single helper node1 ) to parallel task execution (task is fragmented into several subtasks to be offloaded to different helper devices); and iii) the considered performance objectives (mainly delay, energy consumption, resource cost, queue stability, or deadline satisfaction). Several surveys [21] have covered these optimization perspectives and the most common solution techniques for task offloading, including convex optimization, game theory, heuristic methods, and learning-based approaches.
fog nodes to reduce task completion delay. Nevertheless, this type of parallel execution requires all subtasks to be completed before recovering the final result. Therefore, even though parallelism can reduce the workload assigned to each helper, the task completion time remains limited by the slowest selected node. On the other hand, coded computing and secret-sharing-based schemes introduce structured redundancy by encoding the workload into coded subtasks or shares, which consequently enables straggler tolerance and threshold-based recovery. For instance, [18] proposes a coded MEC scheme for distributed inference, where Shamir’s secret sharing protects input data against colluding edge servers while coding mitigates straggling servers. [30] studies secure distributed computation based on secret sharing, focusing on the recovery threshold and communication load under privacy and security constraints. Although these coded-computation approaches show how coding can support both straggler mitigation and data privacy, they are usually formulated for specific linear inFor example, [22] formulates task offloading in a mobile ference or distributed matrix-computation settings, rather edge computing scenario as a multi-objective optimization than for multi-purpose and energy-aware task offloading problem to jointly minimize delay, energy consumption, schemes. and payment cost. [23] studies massive task scheduling in fog–cloud systems by considering the joint impact of Privacy-aware task offloading has also received increasing energy consumption and execution delay. [24] considers attention. For example, [13] models privacy-aware task a pipelining task-offloading strategy in 6G networks to offloading by incorporating a privacy leakage metric, meareduce delay, where task scheduling decisions are based on sured with KL divergence, based on the leakage of user poa high-level Cybertwin entity. [25] formulates task assign- sition when selecting MEC servers. [35] considers a proxyment in edge–cloud systems as a graph-based scheduling assisted MEC offloading to protect both location privacy problem to jointly consider delay, energy, and processing and task-association privacy during server selection. [36] cost. All these works are considered from a high-level studies online task offloading under location privacy leakorchestration plane that has a complete overview of the age, where a specific metric is designed to capture inforsystem. Other works provide solutions for these (full) mation revealed by sequential decisions. Other proposals task offloading schemes that do not rely on a high-level quantify privacy through information-theoretic or entropyplane and propose more scalable techniques. [26] models based metrics. [14] introduces a privacy-awareness task the interaction among devices, edge, and cloud resources offloading approach where the uncertainty of the computhrough a potential-game formulation, where each device tational task type is quantified through privacy entropy. selects offloading strategies according to delay and energy [31] considers privacy-aware task offloading in healthcare costs. [27] proposes a distributed offloading model for scenarios, where privacy entropy is considered to measure MEC systems from a mean-field perspective, focusing on uncertainty of offloading decisions. Differential privacy scalable decisions when many devices compete for edge has also been incorporated into task offloading by perturbresources. [28] studies D2D-assisted MEC using multi- ing sensitive data or location-related information before agent decision-making to minimize average task delay making offloading decisions [32]. In D2D scenarios, [34] under deadline constraints. However, most existing works considers security-aware collaborative task offloading by focus on the allocation and scheduling decision itself, ab- introducing a security workload constraint (in terms of stracting the offloaded workload as directly executable at CPU capabilities and data size). [33] studies trustworthy the selected computing node. This leaves less explored the and replicated offloading where helper selection reduces joint impact of stochastic task arrivals, queue evolution, repeated offloading to the same helper, while incorporating and runtime resource contention, which are essential to blockchain-based verification. [37] studies privacy-aware model realistic distributed networks. collaborative task offloading in fog computing, where tasks are allocated according to security credits and requireAnother line of work has considered parallel task offloadments. These works show that privacy and security are ing, which is especially relevant in IoT and D2D scenarios becoming increasingly relevant in the task offloading field. as computational resources of a single helper may not However, they mainly protect contextual information from be enough to execute large workloads efficiently. In this the perspective of user metadata, such as location, task direction, [29] proposes a many-to-one matching-based association, task type, or helper trust. This leaves mostly parallel offloading scheme where subtasks are assigned to unexplored information-theoretic approaches, particularly regarding the information that helper devices may infer 1
A helper node, or simply helper, denotes any computational resource to which a workload is offloaded
3
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
Table 1: Comparison of selected task offloading and privacy-aware computation schemes (N/A: not apply) Reference Scenario
Execution model
Privacy concern
Privacy metric
Privacy role
Optimized criteria
[22] (2020) MEC/Cloud
Full offloading
Not considered
N/A
N/A
[29] (2022) IoT/Fog [18] (2022) MEC
Parallel offloading Coded offloading
[13] (2023) MEC
Full offloading
[14] (2024) Edge
Full offloading
[31] (2025) MEC
Full offloading
[32] (2024) MEC
Full offloading
Not considered N/A Input data privacy N/A against colluding servers Device location privacy KL divergence during server selection Privacy of computational Privacy entropy task type Uncertainty in Privacy entropy offloading decisions Local data privacy N/A
Energy, delay, payment cost Delay Delay
[33] (2020) D2D
Full offloading
Helper’s trust
N/A
[34] (2021) D2D
Full offloading
Security time
Our work D2D
Coded offloading
Security-critical workload Information leakage from coded payloads
3.1
from the coded payload they process under noisy leakage observations (such as side-channel attacks).
Objective term Objective term Objective term
Energy, delay, location privacy Energy, delay, task-type privacy Energy, delay, privacy
Data protection with Energy, delay local differential privacy Redundant offloading Delay and verification mechanisms Hard constraint Energy, queue stability Objective penalty
Delay, energy, privacy leakage
Network model
We consider a D2D network consisting of a set of heterogeneous devices, denoted by N = {1, . . . , N }, where each device can communicate directly with any other device through D2D links. The proposed task offloading scheme operates in a time-slotted system, with time slots denoted by T = {1, . . . , T } and coordinated by a high-level scheduler, as illustrated in Figure 1. For simplicity, each time slot has a fixed duration τ , although the model can be easily extended to variable slot durations. During each time slot t ∈ T , computational tasks arrive at each device according to a Poisson process with rate λi for device i ∈ N , resulting in a per-device set of generated tasks Ki (t). At the beginning of the next time slot, the scheduler considers all incoming S tasks during the previous slot, denoted by K(t) ≜ i∈N Ki (t), and they are immediately scheduled (i.e., there is no extra delay between the scheduling epoch and the beginning of the next time slot). The scheduling policy takes into account the incoming tasks and the current system state, which captures the resources already occupied by unfinished tasks. For each incoming task, the scheduler chooses between two decisions: local computation at the source device or offloading to a set of helper devices.
Motivated by the lack of task offloading models that jointly integrate coding and information-leakage privacy concerns, this paper models a task offloading from the point of view of a coded computing problem under noisy leakage observations. Specifically, we propose a coded task offloading scheme based on LSS, where each task is encoded into multiple shares and can be recovered after a threshold number of helper computations are completed. Unlike previous offloading works, privacy is modeled as the information leaked by the shares processed by potentially adversarial helper devices. This allows us to quantify the impact of privacy leakage on the delay–energy trade-off of a distributed computing system. Table 1 summarizes the main differences between representative works and our proposal.
3
Mutual information under LSS
N/A Coding guarantee
System Model
This section presents the system model of the proposed coded task offloading scheme over D2D networks. We first introduce the D2D network setting and the operational parameters of the time-slotted scheduling system (Subsection 3.1). We then describe the capabilities of the devices and their queue-based evolution dynamics (Subsection 3.2), followed by the communication model for D2D transmissions (Subsection 3.3). Next, we define the task model, including the LSS mechanism used for coded execution (Subsection 3.4). Finally, we formulate the main performance metrics considered in this work, namely task delay, energy consumption, and privacy leakage under noisy leakage observations (Subsections 3.5, 3.6, and 3.7). The main notations used in this section are summarized in Table 2.
3.2
Device model
Each device is modeled as dynamic-queue system, where each device i maintains two FCFS (First-Come, FirstServed) single-server queues: computation queue Qcmp i and transmission queue Qtx . The device i is defined by the i tx tuple (fi , κi , Mi , Qcmp i , Qi ), where fi represents the CPU frequency (in cycles per time unit) for executing tasks, κi denotes the effective switched capacitance coefficient depending on its CPU chip architecture, Mi is the memory tx capacity for allocated task data (in bits) in both Qcmp i , Qi . The incoming tasks are allocated in each queue depending on the scheduling decisions by the scheduler. If local exe4
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
z z
Figure 1: System model of coded task offloading scheme over D2D networks, under a time-slotted scheduling system. cution decision is chosen, the task is queued in Qcmp until limited additive white Gaussian noise (AWGN) channel i the device CPU is idle. If remote decision is chosen, the pij (t)gij (t) task is queued in Qtx until the device transmission unit is Rij (t) = Bij (t) log2 1 + , (1) i N0 Bij (t) idle. where pij (t) is the power transmission used by device i to send data to j, gij (t) is the channel gain between devices i and j, and N0 is the noise spectral density. The channel gain is modeled through the Friis free-space propagation 3.3 Communication model formula, namely 2 We focus exclusively on direct D2D communications c g (t) = , i ̸= j, (2) ij among end devices. The communication layer is mod4πfc dij (t) eled as a clustered New Radio (NR) sidelink (PC5) system (within 5G technology), in which a central coordina- where c is the speed of light, fc is the carrier frequency, tor assigns orthogonal radio resources to the active D2D and dij (t) is the distance between devices i and j. transmissions. NR sidelink resources are organized on an OFDM time–frequency grid and scheduled in units of 3.4 Task model physical resource blocks (PRBs). Accordingly, the coordinator selects the set of active transmitter–receiver pairs Each task (i, k) ∈ Ki (t) is defined as the tuple and grants each active link a disjoint set of PRBs for its (ℓik , cik , [nik , sik , tik , qik ]), where ℓik is the input size (in transmission interval, so that simultaneous links do not bits) required to perform the task, cik is the average numcollide in time–frequency. Each device is equipped with ber of CPU cycles required per input bit, and the parama single transmission interface for task offloading, there- eters [nik , sik , tik , qik ] define the LSS configuration used fore it cannot handle multiple transmissions in parallel to if task (i, k) is offloaded: nik is the number of encoded shares2 generated from the subtasks, sik is the number different helper devices. of source subtasks in which the input size is divided, tik In our model, whenever device i is allowed to transmit is the recovery threshold, and q is the size of the finite ik to device j during time slot t, the coordinator assigns a field over which the encoding is defined. When task (i, k) bandwidth portion Bij (t) to link i → j, i.e., the effective is offloaded, its input is first partitioned into s source ik set of sidelink radio resources assigned to that transmission. 2 The transmission rate on each directed D2D link i → j is Hereafter, secret shares are also referred to as coded shares, modeled using the Shannon–Hartley expression for a band- or simply as shares. 5
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
the size of each share can be smaller than the size of the secrets [38]. In our model, we adopt the conservative case in which each encoded share has the same size as one source subtask, and therefore yields a worst-case communication and computation cost for the encoded offloading process.
Table 2: Summary of Main Notations and Descriptions Notations
Description System Model
N
Set of N heterogeneous devices
T
Set of T discrete time slots for task scheduling
τ
Fixed duration of each time slot
fi
CPU frequency of device i in cycles/second
κi
Effective switched capacitance coefficient of CPU chip architecture of device i
Mi
Memory capacity of device i for task allocation
Qi
{cmp/tx}
Computation/Transmission queue of device i
Bij (t)
Bandwidth allocated to the D2D link i → j
Rij (t)
Transmission rate for the D2D link i → j
Ki (t)
Set of arrival tasks from device i at time slot t
ℓik
Input data size for task (i, k) in bits
At the beginning of time slot t, for each task (i, k) in the batch Ki (t), the scheduler chooses a set of binary decision j variables denoted by ψik ∈ {0, 1}, j ∈ N . If task (i, k) is i executed locally, then ψik = 1; otherwise, if it is offloaded, j i then ψik = 0, and ψik = 1 for j ̸= i means that helper device j receives one share of task (i, k). Therefore, the number of selected helpers must match the number of encoded shares: X j i ψik = (1 − ψik )nik , ∀(i, k) ∈ Ki (t), i ∈ N (3) j̸=i
3.5
Task delay model
We define the delay of a task as the elapsed time from the beginning of time slot t (when the scheduling deciCPU cycles per bit for task (i, k) in cycles/bit sion is made) until the task completes its execution. For cik a locally executed task, completion occurs when its local [nik , sik , tik , qik ] Coding parameters for encoding task (i, k) computation finishes. For an offloaded task, completion j ψik Binary decision variable: 1 if task (i, k) from occurs when a sufficient (the recovery threshold) number of encoded shares have been transmitted, queued at their time slot t is assigned to device j corresponding helper devices, and remotely computed. DeJik Set of helper devices for task (i, k) pending on the scheduling decision of task (i, k), its task delay is computed as Performance Metrics i loc i off {cmp/tx} Dik = ψik Dik + (1 − ψik ) Dik , (4) W Waiting time in computation queue and ik
transmission queue cmp Tik
Computation time for task (i, k) (local or remote subtask)
tx,(m)
Transmission time for the m-th subtask of task (i, k)
Tik
Dik
Total completion delay for task (i, k)
Eik
Total energy consumption for task (i, k)
Lik
Privacy leakage risk for task (i, k) based on mutual information
loc off where Dik is the local task delay, and Dik is the offloaded task delay.
3.5.1
Local execution
i In case of local task execution (ψik = 1), no transmission is required and task (i, k) is appended to the computation queue Qcmp i . Therefore, the task delay is computed as cmp cmp cmp loc Dik = Wik + Tik = Wik +
ℓik cik , fi
(5)
cmp where Wik is the waiting time in Qcmp under an FCFS i cmp discipline, and Tik is the local computation time.
subtasks, which are then encoded into nik shares using the LSS scheme. Therefore, each selected helper device, distinct from the others, receives one encoded share and executes the corresponding remote computation over masked data, so that no individual helper directly observes the original task input. The task output is recoverable once any tik of these remote executions finish successfully.
In terms of queue dynamics, for each device i, every job entering Qcmp (either a local task or a remotely offloaded i share) is indexed in order of arrival as p = 1, 2, . . . , with arrival time acmp p . The corresponding start-of-service time is cmp a1 , if p = 1 cmp sp = , (6) cmp cmp max{ap , cp−1 }, if p ≥ 2
Additionally, we consider a non-perfect secret sharing scheme which may achieve high information rate3 , i.e., and the completion time is cmp
cmp
cmp
cp = sp + Tp . Since the scheme is non-perfect, intermediate sets of shares may reveal partial information, but any set below a privacy thresh- Hence, the computation waiting time is old reveals no information about the secrets in the ideal thresholdcmp based scheme. Wik = scmp − acmp p p 3
6
(7) (8)
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
if job p corresponds to a local task (i, k) (or, equivalently, cmp,(m) Wik if job p corresponds to the m-th remote share of task (i, k)). 3.5.2
Task offloading
i On the other hand, in case of remote execution (ψik = 0), the nik encoded shares from task (i, k) through the corresponding LSS scheme, are appended to the transmission queue Qtx i . The overall offloading process is summarized in Figure 2. Let (1)
(n
)
j Jik = {j ̸= i : ψik = 1} = {jik , . . . , jik ik }, (9) denote the set of helper devices selected for task (i, k), so (m) that share m is transmitted from device i to device jik . Since each encoded share carries one sik -fraction of the original task workload, its transmission time of m-th share is ℓik tx,(m) Tik = . (10) sik Ri j (m) (t) ik
z
In terms of queue dynamics, jobs in Qtx i are indexed in order of arrival as q = 1, 2, . . . , with arrival time atx q , under a FCFS discipline. The start-of-service time is tx a1 if q = 1 tx , (11) sq = tx tx max{aq , cq−1 } if q ≥ 2 and the completion time of the transmission service is tx tx ctx (12) q = sq + Sq , tx where Sq denotes the transmission service time of job q. In particular, if job q corresponds to task (i, k), then nik X tx,(m) tx Sqtx = Sik = Tik . (13) m=1
Therefore, the waiting time in the transmission queue is tx tx Wik = stx (14) q − aq . Then, the encoded shares are transmitted sequentially to each helper devices but executed remotely in parallel, i.e., (m) once the m-th share reaches helper jik , it can join the helper’s computation queue and be executed independently of the remaining share transmissions. Since the adopted LSS scheme only requires tik completed share-results, the task completes when the fastest feasible subset of tik shares has finished its remote computation. Therefore, the completion delay of an offloaded task (i, k) is off tx Dik = Wik + min max U ⊆{1,...,nik } m∈U |U |=tik
m X
! tx,(ℓ) cmp,(m) cmp,(m) Tik + Wik + Tik
ℓ=1 cmp,(m)
where Wik
and cmp,(m)
Tik
=
ℓik cik sik fj (m)
Figure 2: Representation of the coded task offloading scheme 3.6
Task energy consumption model
We define the energy consumption of a task as the total amount of energy consumed by the devices involved in its execution, including local/remote computation and, when applicable, wireless transmission.
(15) In task-offloading models, the energy consumed by a CPU to process a workload is commonly represented through . dynamic power models. Accordingly, if task (i, k) is exi ecuted locally (ψik = 1), the required number of CPU cycles is ℓik cik and, therefore, the local computation energy is given by (16) loc Eik = κi fi2 ℓik cik . (17)
ik
are, respectively, the waiting time and computation time of Conversely, when the task is offloaded (ψ i = 0), the total ik (m) m-th share m at helper jik . energy consumption depends on: i) the wireless transmis7
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
sion energy required to send the encoded shares to the selected helper devices; and ii) the required remote computation energy consumed at the helper devices. Under previous considerations, the total transmission energy is tx Eik =
nik X
tx,(m)
In this context, we quantify the theoretical information leakage about the original source subtasks after the coded offloading procedure. This leakage value will be used to study the privacy–aware system performance trade-off induced by coded task offloading.
nik ℓ p (m) (t) X ik i j
ik . We consider the setting of LSS schemes over a finite field s R (m) (t) ik i jik Fq , where q = pd is an integer power of a prime p. Our m=1 m=1 (18) goal is to quantify the information leakage of the LSS k For the computation energy consumption, we adopt a scheme, between the secret vector S = (S1 , . . . , Sk ) ∈ Fq in Fq ) cancellation-aware mechanism, i.e., when the fastest tik (where each Si is an iid uniform random variable n and the leakage vector L = (L , . . . , L ) ∈ F observed 1 n q completed share-results are available, the remaining share by the adversary from the shares U = (U1 , . . . , Un ) ∈ Fnq executions are cancelled immediately. Let (which is a LSS for S). Specifically, we instantiate the m X offloading protection through a ramp-LSS scheme because (m) tx,(ℓ) cmp,(m) bik = Tik + Wik (19) they trade perfect privacy against lower overhead and ℓ=1 higher information rate (non-perfect LSS schemes), which be the instant, measured after the task starts its transmission is better aligned with dynamic and resource-constrained service, at which m-th share starts its remote computation. D2D environments. Remark that, to avoid overloading the task index notation for task (i, k), the correspondence is Also, let n = nik , k = sik , t = tik , and q = qik . off off tx dik = Dik − Wik (20) Definition 1 ((t, k, n) Ramp Secret Sharing scheme). Let be the offloaded-task completion time measured from the C2 ⊊ C1 ⊆ Fn be two nested MDS codes where C1 is an q start of the task transmission service. Then, the actual [n, t, n−t+1] code, and C is an [n, t−k, n−t+k +1] , q 2 q (m) computation time spent by helper jik on share m before which satisfy k < t ≤ n. The scheme RampSS(t, k, n) completion/cancellation is distributes n shares of the secret vector S ∈ Fkq such that: h i+ cmp,(m) (m) cmp,(m) (m) Teik = min bik + Tik , doff − bik . i) any set of at most t − k shares reveals no information ik about S; (21) + where [x] ≜ max{x, 0}. This expression gives zero ii) any set of at least t shares reconstructs S. energy if share m has not started execution before the task is reconstructed, full computation energy if it finishes To generate the shares, choose a linear complement code before reconstruction, and partial computation energy if it S of C2 in C1 , i.e., C1 = S ⊕ C2 , with S ∩ C2 = {0}, is cancelled while being executed. Therefore, the remote dim(S) = k; and fix an isomorphism ψ : Fk → S. For a q computation energy consumed by helper devices is secret s ∈ Fkq , the isomorphism ψ selects the coset ψ(s) + nik X C2 ∈ C1 /C2 , and the share vector U = (U1 , . . . , Un ) is cmp,(m) rem Eik = κj (m) fj3(m) Teik , (22) sampled uniformly at random from this coset. ik ik
pi j (m) (t) Tik
=
ik
m=1
Nested MDS codes give a closed-form threshold structure, since the privacy threshold is t − k, the reconstruction threshold is t, and the straggler tolerance of the offloaded Hence, the total energy consumption of an offloaded task task is n − t. (i, k) is On the other hand, we consider the total variation distance off tx rem Eik = Eik + Eik , (23) as the baseline privacy leakage metric to measure the statisand, therefore, combining both scheduling actions, the tical distinguishability between the joint distribution of the secret and the leakage and the product of their marginals. energy consumption of task (i, k) is expressed as Definition 2 (Pointwise Total Variation Distance). The i loc i off Eik = ψik Eik + (1 − ψik ) Eik . (24) pointwise total variation (TV) distance between two random vectors S and L, over alphabets S and L, respectively, 3.7 Privacy Leakage Model is defined as 1 XX Threat Model: We assume honest-but-curious helper de∆TV (S; L) = P(S = s, L = ℓ) 2 vices that execute the assigned coded computations cors∈S ℓ∈L rectly, but may attempt to infer information about the orig− P(S = s) P(L = ℓ) . inal subtask inputs from their received shares. A passive adversary may collect such observations and is assumed to know the coding scheme and the system model, but cannot We assume that each share is leaked through a noisy leakalter computations or inject malicious results. age observation, which is appropriate for our setting since which accounts only for the fraction of the computation actually performed before task completion.
8
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
the shares are transmitted to and processed by different helper devices. Definition 3 (δ-Noisy Channel, [20]). For some random variable U over U, a (randomized) leakage function L : U → L is said to be δ-noisy leakage channel if ∆TV (U ; L) ≤ δ. The leakage output will be called a δnoisy observation of U .
function that provides decisions to the scheduler to explicitly trade delay and energy savings against the privacy leakage of each offloading decision. Since this results in a multi-objective optimization problem, we use a scalarization method to define a unique objective function as a convex combination of both individual objectives (delay and energy consumption). Additionally, to avoid the dependence of the objective on problem-specific maxima, we normalize delay and energy through smooth scale functions: b ik = 2 arctan Dik , D π D0 (26) bik = 2 arctan Eik , E π E0
The leakage parameter of each helper, δi , captures the statistical strength of the corresponding leakage observation, and can be interpreted as a privacy risk across helper devices. Under usual assumptions, we consider that the channels (Li | Ui ) are mutually independent for all i, and that these channels are subject to independent observations such that ∆TV (Ui ; Li ) ≤ δi . Under the LSS scheme from Definition 1 and the previously cited leakage model, we obtain the following theorem. Theorem 1. Consider a RampSS(t, k, n) scheme over Fq under the δ-noisy share leakage model. Let S ∈ Fkq be the secret vector, U = (U1 , . . . , Un ) the corresponding share vector, and L = (L1 , . . . , Ln ) the leakage vector. If ∆TV (Uj ; Lj ) ≤ δj for every share j ∈ [n], then Y ∆TV (S; L) ≤ 2t−k+1 q n−t+k − 1 · max δj , [n] J ∈(t−k+1 ) j∈J (25) where [n] = {1, . . . , n} and [n] denotes the collection of x all x-element subsets of [n].
where D0 and E0 are reference task delay and task energy consumption values, respectively. On the other hand, we define the privacy penalty function as Π(Lik ) = σ (log2 (Lik )/ξ) ,
(27)
where σ(·) is the sigmoid function, and ξ > 0 controls the smoothness of the transition. This function provides a smooth and upper-bounded privacy penalty that, when the leakage grows, the penalty increases smoothly. Let us define the joint decision variable Ψ(t) ≜ j (Ψi (t))N i=1 where Ψi (t) = (ψik )k,j ∈ M|Ki (t)|×N as the set of scheduling decisions at time slot t. We define the long-term optimization problem P1 as:
The proof follows the Fourier-analysis approach for noisy channel-side leakage in linear secret sharing schemes introduced in [20], adapted to the multisecret and nested structure of RampSS(t, k, n). The full derivation is provided in Appendix A. For each offloaded task (i, k), we consider the conservative value of the privacy leakage upper bound to quantify the privacy cost associated with offloading task (i, k) to the selected helper devices, which is denoted by Lik . Remark that, if the task (i, k) is executed locally, we set Lik = 0.
T
minimize lim sup {Ψ(t)}t∈T
T →∞
1X 1 T t=1 |K(t)|
X
αD̂ik
(i,k)∈K(t)
+ β Êik + γΠ(Lik )
cmp s.t. |Qtx (t)| ≤ Mi , i ∈ N i (t)| + |Qi j ψik ∈ {0, 1}, (i, k) ∈ K(t), j ∈ N
X
j i ψik = (1 − ψik )nik .
(28a) (28b) (28c) (28d)
j∈N \{i}
4
Methodology
Problem P1 is a binary non-linear optimization problem (BNLP) with dynamic queue-state dependence. It captures: (i) a time-slotted scheduling system under queuebased dynamics under stochastic task arrivals; (ii) a coded task offloading scheme based on LSS schemes and codedcomputing principles, where each offloaded task can be recovered after the completion of a subset of offloaded shares; and (iii) a privacy-leakage-based penalty into the delay–energy trade-off through a smooth regularization term, so that offloading decisions are penalized according to the privacy leakage induced by the selected LSS scheme under noisy leakage observations.
In this section, we formulate the non-linear optimization problem that captures the objective of our coded task offloading scheme (Subsection 4.1). Since the problem is proven to be NP-hard, we propose two algorithmic solutions: a BnB-based greedy solver (Subsection 4.2) to obtain near-optimal solutions, and a heuristic solver (Subsection 4.3) to provide a lightweight scheduling policy for evaluating system performance. 4.1
Problem formulation
Our objective is to jointly minimize the long-term average task delay and energy consumption while accounting for the privacy leakage induced by offloading secret-shared tasks to helper devices. In our optimization problem, the privacy cost is introduced as a penalty term in the objective
The main difficulty stems from the combinatorial nature of the binary scheduling process since the number of joint scheduling decisions grows exponentially with the number of tasks and candidate helpers. Therefore, although optimal solutions can be achieved by exhaustive exploration, 9
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
solving P1 exactly at each slot is, in general, computation- Algorithm 1: Branch-and-bound-based Greedy Solver ally impractical. Input: task batch K(t), initial state S0 (t) Proposition 2. Problem P1 is NP-hard. Output: slot decision matrix Ψ(t) Construct Aeik (t) for every (i, k) ∈ K(t) using (31) We refer the reader to Appendix B for the proof. Order the tasks as π(1), . . . , π(|K(t)|) In the following, we use a task-action cost notation for for ℓ = 1, . . . , |K(t)| do both proposed solvers. For task (i, k), an action a denotes rank the actions in Aeπ(ℓ) (t) by the root-state cost either local execution or offloading to a helper set. The cπ(ℓ) (a | S0 (t)) state S denotes the queue and resource state at the moment define the ordered action list Ae↑π(ℓ) (t) accordingly when the action is evaluated. The cost of assigning task (i, k) through action a under state S is defined as compute cmin π(ℓ) (t) using (33) |K(t)|
Compute the sequence {Bd (t)}d=1 using (34) (29) Build the initial feasible schedule using (35), and set its total cost as the initial incumbent U (t) where D̂ik (a | S), Êik (a | S), and Lik (a | S) are the Recursive step at a current node v of depth d(v): normalized delay, normalized energy, and privacy leakage Compute the accumulated cost Gv (t) of the current induced by that action, respectively. If an action violates partial schedule memory, queue, or helper-availability constraints, its cost if Gv (t) + Bd(v) (t) ≥ U (t) then is set to +∞. prune node v else 4.2 Branch-and-bound-based greedy scheduler foreach a ∈ Ae↑π(d(v)) (t) do evaluate cπ(d(v)) (a | Sv (t)) We introduce a BnB-based greedy solver4 that serves as a strong baseline for validating the system performance if cπ(d(v)) (a | Sv (t)) < ∞ then against lower-complexity scheduling policies. This apappend a to the partial schedule proach combines two ideas: i) it constructs a deterministic if d(v) = |K(t)| then reduced action set for each task, preserving the main propupdate the incumbent solution and set erties of the model; and ii) it applies a depth-first search U (t) ← Gv (t) + cπ(|K(t)|) (a | Sv (t)) over the resulting decision space. BnB method provides an if exact solution over the reduced action space while avoidGv (t) + cπ(|K(t)|) (a | Sv (t)) < U (t) ing exhaustive enumeration. Algorithm 1 summarizes the else proposed procedure. update to successor state S ′ (t) cik (a | S) ≜ αD̂ik (a | S) + β Êik (a | S) + γΠ(Lik (a | S)) ,
v
4.2.1
recurse at the child node v ′ with depth d(v ′ ) = d(v) + 1
Deterministic reduced action set
Let S0 (t) denote the system state at the beginning of time slot t. The full feasible action set of task (i, k) is return Ψ(t) n o Afull (30) ik (t) = {i} ∪ J ⊆ N \ {i} : |J | = nik , where {i} denotes local execution, while each set J de- 4.2.2 Branch-and-bound search notes a coded offloading action using nik helpers. The BnB search is conducted over the reduced acA pure BnB search over Afull (t) remains computationally tion sets by a depth-first search (DFS) procedure. Let ik prohibitive, since the number of offloading actions for a π(1), . . . , π(|K(t)|) be the task ordering used by the search, where tasks with larger number of shares and larger task is Nn−1 . To alleviate this issue, we construct a deik workload ℓik cik are processed first. The search tree is comterministic reduced action set. For every candidate helper posed of nodes, each of them represents one partial task j ̸= i, we compute the candidate cost cik ({j} | S0 (t)). Let Hik (t) be the set containing the min{N − 1, 3nik } schedule. Let d(v) ∈ {1, . . . , |K(t)|} denote the depth of helpers with smallest values of the candidate costs. This node v, meaning that the first d(v) − 1 ordered tasks have keeps the best-ranked helpers while preserving non-trivial already been assigned. At node v, the algorithm branches combinatorial diversity. Then, the reduced action set is on one action of task π(d(v)), evaluated under the current partial state Sv (t). defined as n o The pruning mechanism is based on three quantities: i) Aeik (t) = {i} ∪ J ⊆ Hik (t) : |J | = sik . (31) the accumulated cost Gv (t) of the current partial solution 4 Branch-and-bound performs an implicit enumeration of the represented by node v, computed as the sum of the action feasible decision tree, pruning partial schedules whose lower costs along the current branch, ii) an incumbent upper bound cannot improve the incumbent solution. bound U (t) associated with the best complete schedule 10
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
found so far, and iii) a static lower bound Bd(v) (t) for the current task and the remaining tasks. Thus, node v is pruned whenever Gv (t) + Bd(v) (t) ≥ U (t). (32) Before the tree expansion starts, we compute, for each ordered task π(ℓ), the minimum root-state cost cmin min cπ(ℓ) (a | S0 (t)), (33) π(ℓ) (t) ≜ eπ(ℓ) (t) a∈A
and define the static lower bound at depth d as Bd (t) ≜
|K(t)|
X
cmin π(ℓ) (t),
d = 1, . . . , |K(t)|.
(34)
ℓ=d
Hence, Bd (t) depends only on the depth and not on the particular node at that depth. We choose this reference bound because it evaluates every remaining task independently from the slot-start state, hence ignoring the additional congestion generated by future assignments, i.e., the lower bound value cannot exceed the completion cost of any descendant node. In fact, evaluating lower bounds in which the remaining tasks are re-evaluated from the current partial state at every node produces the same scheduling decisions on the reduced action space while incurring substantially larger runtime.
Algorithm 2: Heuristic Solver Input: task batch K(t), initial state S0 (t) Output: slot decision matrix Ψ(t) foreach (i, k) ∈ K(t) do (0) form Jbik with the nik helpers having candidate costs cik ({j} | S0 (t)) compute the priority score ∆ik using (36) Order the tasks as π(1), . . . , π(|K(t)|) in non-increasing order of ∆ik for ℓ = 1, . . . , |K(t)| do (ℓ−1) form Jbπ(ℓ) with the nπ(ℓ) helpers having smallest candidate costs under the current state select a⋆ℓ using (37) apply a⋆ℓ and update the state to Sℓ (t) return Ψ(t)
4.3
Heuristic solver
We also propose a heuristic solver that avoids combinatorial search and builds a single schedule sequentially. Specifically, the heuristic solver follows this workflow: i) it prioritizes tasks according to the potential gain of ofTo initialize the search, the algorithm first constructs an floading at the initial state; ii) then, for each ordered task in initial feasible schedule by a greedy search. Starting from a sequential way, it compares local execution cost against S0 (t), for ℓ = 1, . . . , |K(t)|, it selects offloading costs with the best helper set selected by candi(0) aℓ ∈ arg min cπ(ℓ) (a | Sℓ−1 (t)) , (35) date costs, to fix the best action. Algorithm 2 summarizes eπ(ℓ) (t) the procedure. a∈A updates the state to Sℓ (t), and continues sequentially until all tasks are assigned. The corresponding total cost defines 4.3.1 Workflow the initial incumbent bound, denoted by U (t). During the (ℓ) For any state Sℓ , let Jbik denote the set of nik feasible DFS-based BnB search, this incumbent U (t) is iteratively helpers with smallest candidate costs cik ({j} | Sℓ ). This updated whenever a complete schedule with smaller total candidate costs are only used to rank helpers individually; cost is found. At the end of the search, the final scheduling the final offloading decision is evaluated through the action decision for slot t is the incumbent complete assignment b(ℓ) Ψ(t) associated with the minimum total cost U (t) among cost cik (Jik | S). all feasible schedules explored on the reduced action space. To prioritize tasks, the heuristic computes at the initial state S0 (t) the score 4.2.3 Complexity analysis (0) ∆ik ≜ cik ({i} | S0 (t)) − cik (Jbik | S0 (t)). (36) The algorithm is exact on the reduced action space Aeik (t), hence sub-optimal with respect to the original problem. Tasks are then ordered in non-increasing order of ∆ik , so The preprocessing stage evaluates N − 1 candidate costs that those with larger offloading gain are processed first. per task and ranks the corresponding helpers, so its cost Starting from S (t), the heuristic processes the ordered 0 is polynomial in N plus the generation of the reduced tasks π(1), . . . , π(|K(t)|) sequentially. At step ℓ, it forms actions |Aeik (t)|. Since the latter dominates over the former, b(ℓ−1) Jπ(ℓ) under the current state ℓ − 1 and selects between theDFS-based BnB stage has worst-case time complexity local executions and offloading as Q e O (i,k)∈K(t) |Aik (t)| with a⋆ℓ ∈ arg n min (37) o cπ(ℓ) (a | Sℓ−1 (t)). (ℓ−1) min{N − 1, 3nik } a∈ {π(ℓ)i },Jbπ(ℓ) e |Aik (t)| = 1 + , nik which remains exponential (as expected for combinatorial If the selected offloading set is infeasible, its cost is +∞ by search). However, this is substantially Q smaller than the cor definition, and the local action is selected. After applying responding full-action complexity O (i,k) [1 + Nn−1 ] , a⋆ℓ , the system state is updated to Sℓ (t) and the procedure ik and the pruning rule (32) further reduces the explored tree continues with the next ordered task. At the end of the in practice. procedure, the final scheduling decision for time slot t is 11
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
the complete assignment Ψ(t) induced by the sequential biasing the comparison through resource provisioning, all decisions. devices are assigned the same memory capacity, transmit power, and per-link bandwidth. Device heterogeneity is introduced through the task-arrival rate, CPU frequency, 4.3.2 Complexity analysis and effective switched capacitance coefficient. The comFor each task, the priority score computation requires munication model abstracts the D2D interface through an evaluating at most N − 1 candidate helpers, followed effective bandwidth of 250 kHz per active link at 5.9 GHz, by sorting the corresponding candidate scores, yielding which is consistent with NR sidelink/V2X operation over O(|K(t)|N log N ). During the sequential assignment a fraction of the available resource pool [40]. stage, each ordered task again scans and ranks at most N − 1 feasible helpers, which yields O(N log N ) per task. Therefore, the overall per-slot time complexity is Table 3: Default parameters for the validation experiments. Notation Default values O(|K(t)| log |K(t)| + |K(t)|N log N ).
5
Experimental Setup
This section details the experimental setup used to evaluate the proposed coded task offloading scheme, including implementation details and the validation scenario. We also describe the considered comparative scenarios and the validation metrics used to analyze the performance of the proposed scheduling policies, including state-of-theart solvers, common baselines, and other task-offloading schemes. 5.1
N
50 devices
T, τ
T = 300, each of duration τ = 0.1 s
Mi
2 Mbits
(fi , κi , λi )
Implementation Details
pij (t)
80 mW ≈ 19.03 dBm
ℓik
{0.22, 0.42, 0.75} Mbits with prob. (0.25, 0.50, 0.25)
cik
{700, 1000, 1400} cycles/bit with prob. (0.30, 0.45, 0.25)
Bij (t) To validate the proposed coded task offloading scheme, we implemented a Python-based discrete-event simula- (nik , sik , tik ) tor (DES)5 The simulator follows the slot-based operation introduced in Section 3 and evaluates the resulting N0 delay, energy consumption, and privacy-leakage metrics fc under event-driven queue dynamics. In contrast to a purely analytical evaluation, the DES explicitly captures asyndij (t) chronous execution, transmission and computation conδj tention, queue concurrency, and memory-admission blocking. This event-driven execution is used as the default α, β, γ validation environment, since it captures runtime effects D0 , E0 that are difficult to express in closed form. More details are shown in Appendix C. ξ
5.2
requester (50%): (1.0 GHz, 3.0 × 10−28 , 0.95) balanced (30%): (1.40 GHz, 1.8 × 10−28 , 0.45) helper (20%): (1.6 GHz, 1.5 × 10−28 , 0.05)
250 kHz per active D2D link {(3, 2, 3), (4, 3, 4), (5, 4, 5), (6, 3, 5)} and q = 256, with equal probability −174 dBm/Hz 5.9 GHz U[8, 150] m {2−8 , 2−6 , 2−4 } with equal probability 0.5, 0.5, 0.02 0.5 s, 0.2 J 10
Validation Scenario 5.3
We consider a heterogeneous D2D network where devices generate computation tasks locally and cooperate through short-range wireless links. To model different computational roles, devices are divided into three profiles: requesters, which generate tasks more frequently and have less energy-efficient computation; helpers, which generate fewer tasks and provide more efficient computation resources; and balanced devices, which represent an intermediate profile.
Comparative Scenarios
We evaluate the proposed scheme from two complementary perspectives: the task offloading scheme used to execute each task, and the scheduling policy used to select the scheduling decision and helper devices. These are the considered task-offloading schemes:
The default configuration is summarized in Table 3. The parameters are adapted from representative D2D and edge task-offloading studies [28, 24, 33, 26, 22, 39]. To avoid 5
Available online: https://gitlab.com/ discovery1721326/d2d_task_offloading.
12
• Full task offloading: each task is either executed locally or offloaded to one helper device. This represents the conventional binary offloading case and is obtained from our model by disabling coding and setting sik = nik = tik = 1. • Parallel task offloading: each task is divided into several subtasks and assigned to multiple helpers. The task is completed only when all subtasks finish, which
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
0.44 0.42 0.40
Average Energy (J)
0.46
0.56 0.48 0.40
10
20 30 40 Number of devices, N
50
10
20 30 40 Number of devices, N
0.200 0.175 0.150
50
Offload Ratio (%)
0.12 0.08 0.04
Average Backlog (tasks)
100 0.16
0.00
0.225
0.32
0.38 CPU Queue Waiting Time (s)
0.250
0.64 Average Delay (s)
Objective Cost
0.48
80 60 40 20 0
10
20 30 40 Number of devices, N Greedy-Optimization
50
10 Greedy
20 30 40 Number of devices, N Heuristic
50
Random
10
20 30 40 Number of devices, N
50
10
20 30 40 Number of devices, N
50
8 6 4 2 0
Local
Offload-only
Figure 3: System performance comparison between the1 proposed solvers and common baselines under γ = 0. corresponds to disabling coded recovery and setting posed algorithmic solution. Moreover, each proposal fosik = nik = tik = s, with s ∈ {3, 4, 5, 6} equiproba- cuses on a different main objective: energy consumption ble. and queue stability in SEC2D, and task delay in SMUA. • Coded task offloading: this is the proposed scheme and the default configuration in this paper. Each task is encoded into nik shares and can be recovered once the 5.4 fastest subset of tik helpers completes execution.
Performance Metrics
Most of the evaluated metrics are directly obtained from the closed-form models introduced in Sections 3 and 4, • Greedy-Optimization: executes Algorithm 1 over the including task delay, energy consumption, privacy penalty, recursive optimization model based on FCFS-queue objective cost, CPU/TX waiting time, and backlogged dynamics, rather than over the DES, and is used as a tasks. In addition, we report the average offload ratio, defined as the per-slot fraction of requested tasks that are near-optimal but optimistic reference. • Greedy: executes Algorithm 1 in the DES, allowing us not executed locally: to quantify the mismatch between the analytical model and the event-driven implementation. T i = 0}| 1 X |{(i, k) ∈ K(t) : ψik • Heuristic: executes Algorithm 2 in the DES. This is (38) T |K(t)| the default scheduler used throughout the paper. t=1
Moreover, we consider the following scheduling policies:
• Random: randomly selects the execution mode and helper devices, when feasible. • Local: forces all tasks to be executed locally.
6
Results and Discussion
• Offload-only: forces all offloadable tasks to be assigned to helper devices whenever feasible. Finally, we adapt two state-of-the-art policies as representative baselines. We did not find in the state of the art any equivalent task offloading scheme under similar leakage penalty considerations. Therefore, for a fair comparison, we consider SEC2D [34] and SMUA [29] under non-coded full and parallel task offloading schemes, respectively. Both algorithms are based on different techniques, namely Lyapunov optimization and matching theory, which provides an additional comparison for the pro13
In this section, we validate the overall performance of the proposed coded task offloading scheme and solvers. First, we evaluate the general system performance, comparing the proposed solvers with baseline policies (Subsection 6.1). Next, we study the impact of the coding configuration and privacy-leakage penalty on the delay– energy trade-off under different noisy observations (Subsection 6.2). Finally, we compare the heuristic solver with state-of-the-art scheduling policies and alternative taskoffloading schemes (Subsection 6.3).
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
6.1 6.1.1
System Performance Validation
Table 4: Per-slot scheduling runtime comparison. Values are reported in 10−4 s.
Baseline Comparative
Figure 3 evaluates different metrics, including objective cost, average delay, energy consumption, CPU queue waiting time, offload ratio, and average backlog, under different scheduling policies. The main analysis comes from the objective cost, which is the metric minimized by the proposed solvers. Greedy-Optimization always obtains better results than Greedy, which is justified by the optimistic memory management described in Section 5.3. In contrast, there is no substantial difference between the objective cost achieved by Heuristic and Greedy. In fact, for small values of N , the Heuristic solver achieves slightly better results. This is because the optimization problem is solved sequentially: an assignment that is optimal in the current time slot may lead to a less favorable state in the following slots. For the remaining values of N , the Heuristic solver obtains very close results to Greedy, which shows that this lightweight approach can approximate near-optimal scheduling decisions. For instance, at N = 50, the objective cost of Heuristic is 0.3943, while Greedy obtains 0.3944. The worst result is achieved by Offload-only due to the overhead introduced by the coded task offloading scheme.
Method
N = 5 N = 10 N = 20 N = 50
Greedy-Opt. Greedy Heuristic Random Local Offload-only SEC2D [34] SMUA [29]
2.00 170.30 1,736.80 10,963.80 3,847.80 1.90 132.20 680.00 7,262.90 2,784.40 0.837 2.10 2.70 9.10 4.40 0.078 0.113 0.133 0.327 0.179 0.0178 0.0179 0.0189 0.0206 0.0178 0.102 0.201 0.232 0.359 0.254 0.437 0.813 1.40 4.00 2.00 0.918 1.70 4.70 13.20 7.30
Mean
ble compared to the optimization-based solvers. Offloadonly requires slightly more runtime than Local and Random because it must check the current queue state to verify whether enough resources are available to offload the shares. 6.1.3
System Scalability
We also validated the system performance under different scalability conditions, including task-arrival regimes, workload variability levels, and time-slot durations. These experiments confirm that the proposed scheme remains stable under heavier arrivals and heterogeneous workloads, while adapting the offload ratio to queue accumulation and execution variability. Since these results mainly provide complementary evidence to the main conclusions, the detailed scalability analysis is reported in Appendix D.2.
Table 4 shows the average per-slot scheduling runtime for different scheduling policies. Two main conclusions can be extracted. First, Greedy-Optimization requires longer runtime than Greedy because deriving waiting times and checking resource availability are more efficiently handled by DES. Second, Heuristic reduces the scheduling runtime by several orders of magnitude with respect to Greedy because it does not rely on the BnB procedure, while still achieving similar performance, as shown in the previous subsection. For instance, the mean runtime decreases from 2, 784.40 × 10−4 s with Greedy to 4.40 × 10−4 s with Heuristic. On the other hand, the baseline policies are based on direct assignments, so their runtime is negligi14
0.176 0.48 0.44 0.40
δ=0 δ = 2−15 δ = 2−10 δ = 2−5
0.168 0.160 0.152
0.144 0.36 0.00 0.04 0.08 0.12 0.16 0.20 γ (Privacy Loss Weight)
Task Distribution
Scheduling Time
Average Energy (J) (Dotted)
6.1.2
Average Delay (s) (Solid)
The previous analysis over the objective cost can be similarly translated to task delay, CPU queue waiting time, and average backlog, where similar patterns are observed. However, this does not occur for task energy consumption. In this metric, Local achieves the lowest value because it avoids sequential share transmissions and replicated/coded remote computations. As a consequence, Local also achieves the worst task delay, since it cannot exploit helper 6.2 Privacy Impact on Delay-Energy Trade-off devices to reduce the computation time of backlogged Several experiments have been performed to analyze the tasks. impact of the considered privacy leakage model on the Finally, the offload ratio is higher under Greedy- proposed task-offloading system. In this subsection, to Optimization, 45.23 % for N = 50, due to its optimistic re- enable comparable and controlled results, we assume a hosource management. In contrast, both Greedy and Heuris- mogeneous noisy-observations leakage setting, i.e., δj = δ tic require fewer offloads to achieve near-optimal solutions, for all helper devices. around 40 %. Remark that, the Offload-only solver does not reach a full offload ratio for N = 5 due to the limited 1.0 0.184 0.52 available helpers. 0.8 0.6 0.4
Local 3 shares 4 shares
0.2
5 shares 6 shares
0.0
0.0 0.0050.01 0.02 0.05 0.1 γ (Privacy Loss Weight)
1 Figure 4: Impact of the privacy-leakage penalty on system performance under different values of γ.
Figure 4 studies the impact of the privacy penalty by modifying the control parameter γ, i.e., analyzing the delay– energy–privacy trade-off of the system. On the left side,
0.465 0.450
0.156 0.153 0.150 0.147
3
4 5 6 7 8 Number of shares (n)
3
0.30
Offload Ratio (%)
Energy (J)
Delay (s)
0.36
0.195 0.180 0.165 0.150
0.24
3) 4) 5) 4) 5) 5) (2, (2, (2, (3, (3, (4, Subtasks/Threshold (s, t)
4.5
4 5 6 7 8 Number of shares (n)
0.210 0.42
6.0
0.03 0.02 0.01
4 5 6 7 8 Number of shares (n)
80 60 40 20
δ = 2−15
3
0.60 0.45 0.30 0.15
3) 4) 5) 4) 5) 5) (2, (2, (2, (3, (3, (4, Subtasks/Threshold (s, t)
δ = 2−10
4 5 6 7 8 Number of shares (n)
0.00
0
3) 4) 5) 4) 5) 5) (2, (2, (2, (3, (3, (4, Subtasks/Threshold (s, t) δ=0
0.04
0.00 3
0.48
7.5
Privacy Penalty
Energy (J)
0.480
9.0
Privacy Penalty
0.159
0.495 Delay (s)
Offload Ratio (%)
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
δ = 2−5
3) 4) 5) 4) 5) 5) (2, (2, (2, (3, (3, (4, Subtasks/Threshold (s, t)
δ = 2−1
Figure 5: System performance under different coding parameters (in first row, sik = 2, tik = 3; in the second one, 1 nik = 5). both average delay and energy consumption remain constant for δ = 0, since no privacy leakage is introduced. Moreover, increasing γ increases the average task delay, since the offload ratio decreases under the same setting. When the privacy penalty is further increased through the δ-noisy parameter, the delay is penalized even more. The opposite occurs for energy consumption as higher values of γ reduce the offload ratio to limit the objective cost, which also reduces the number of share transmissions and remote computations. Therefore, in coded task offloading under privacy-leakage penalty, task delay and privacy protection follow an inverse relationship (improving one degrades the other), and the same occurs between task delay and energy consumption; in contrast, energy consumption and privacy protection follow a direct relationship, since reducing offloading improves both metrics. On the right side, we focus on the distribution of scheduling decisions according to the number of shares used to encode each task. As expected from the previous results, increasing the privacy penalty through higher values of γ increases the number of locally executed tasks, going from 57.8% under the non-leakage scenario to 93.6% for γ = 0.1. A more detailed analysis can be derived by observing the number of shares, which ranges from 3 to 6 in our experimental setting. For γ = 0.0, most offloaded tasks use 5 shares, representing more than 20% of the tasks, followed by 4, 3, and 6 shares. Increasing γ mainly penalizes the most frequent offloaded configurations, while the configurations with 3 and 6 shares keep, in relative terms, a similar share of offloaded tasks compared with γ = 0. This behavior is explained by the overhead factor n/s of the coding scheme, according to the coding parameters in Table 3. The configuration with the lowest overhead corresponds to n = 5, while the configuration with the highest overhead corresponds to n = 7. Therefore, the Heuristic solver tends to offload tasks with lower coding overhead.
This also highlights an additional privacy trade-off as tasks with lower overhead are preferred for offloading, but they also correspond to less protective ramp secret sharing configurations. This trade-off is further analyzed in Figure 5. The same experiment is applied to two different scenarios: i) varying the number of shares under the same threshold-recovery and subtask configuration; ii) keeping the number of shares fixed to 5 and varying the subtask and threshold-recovery profiles. By direct comparison, the latter produces a stronger impact on the overall system performance. In the former, increasing the number of shares generally makes offloading less attractive, since it requires additional transmission time and higher energy consumption at the helper nodes, while the number of completed shares required to finish the task remains unchanged. In any case, the offload ratio remains low, so its impact on the privacy penalty is negligible. In the latter, for a fixed number of shares, offloading becomes more attractive as the overhead factor decreases, i.e., when the number of subtasks increases, in this case. This is observed when moving from (2, 5) to (4, 5): even though the recovery threshold is the same, the offload ratio increases from below 5% to approximately 70%. Additionally, when the number of subtasks is fixed, the offload ratio decreases as more completed shares are required to recover the task, as expected. Finally, the analysis over different values of δ follows the conclusions derived from the previously analyzed delay-energy-privacy trade-off .
15
6.3
Comparison with other Works
6.3.1
Task Offloading Schemes
Figure 6 illustrates a systematic comparison between several task offloading schemes, namely full, parallel, and
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
0.55 0.50 0.45 0.40 0.25 0.50 0.75 1.00 1.25 Load Multiplier ρ
0.450
0.150 0.148 0.146 0.144 0.142
Full task offloading
0.435 0.420 0.405 0.390 0.375
0.25 0.50 0.75 1.00 1.25 Load Multiplier ρ
Offload Ratio (%)
0.60
Objective Cost
Average Energy (J)
Average Delay (s)
0.65
60 45 30 15 0
0.25 0.50 0.75 1.00 1.25 Load Multiplier ρ
Parallel task offloading
0.25 0.50 0.75 1.00 1.25 Load Multiplier ρ
Coded task offloading
Figure 6: Comparison between task-offloading1 schemes under different task-arrival regimes. coded task offloading, under different task-arrival regimes, obtained by scaling the default task-arrival profile by a factor ρ ≥ 0. For a fair comparison, the leakage penalty is disabled by setting γ = 0. Moreover, we set Bij (t) = 500 kHz to better highlight the differences between coded and non-coded schemes.
in terms of objective cost, equivalently energy consumption, closely followed by most SEC2D configurations. In fact, for V = 100, SEC2D achieves close results for most values of N . However, the Heuristic solver obtains these results with fewer offloaded tasks, as shown in the figure, which indicates a more selective helper assignment. As a consequence, the Heuristic solver penalizes task delay The coded approach achieves the lowest objective cost and obtains the worst delay result among the evaluated among the evaluated schemes, followed by parallel task scenarios. offloading and full task offloading, which obtain close results. This behavior is mainly explained by the task delay, When shifting the value of α, i.e., adding priority to task where coded offloading also achieves the best result due delay, the Heuristic solver clearly outperforms SEC2D in to straggler mitigation, and offload ratio. In coded offload- terms of objective cost. Remark that the results of SEC2D ing, offload ratio remains stable across the evaluated load under this scenario remain the same as before, except for factors ρ, around 60 %, while full and parallel schemes the objective cost, because its scheduling decision is not remain below 15 %. Similarly, coded offloading obtains directly controlled by α. In this case, the Heuristic solver the best energy-consumption result, closely followed by reduces task delay by increasing the number of offloaded full offloading (which avoids the additional transmissions tasks. The price is a clear increase in energy consumpand remote computations introduced by task splitting) and tion, which is consistent with the delay–energy trade-off parallel offloading (that must complete all subtasks before analyzed throughout this section. recovering the task). These conclusions apply to all evalAdditionally, according to Table 4, SEC2D requires lower uated task-arrival profiles, i.e., the effectiveness of each scheduling runtime than the Heuristic solver, with mean task-offloading scheme does not depend strongly on the values of 2.00 × 10−4 s and 4.40 × 10−4 s, respectively. current system workload. However, this lower runtime comes with a more rigid optimization structure. Since SEC2D is driven by a Lyapunov6.3.2 State-of-the-art Proposals based energy–queue stability formulation, its control paIn terms of scheduling policy effectiveness, we compare rameter mainly regulates the trade-off between energy conthe proposed Heuristic solver with the selected state-of- sumption and queue stability, but it does not directly adapt the-art policies in Section 5.3. Since no directly equivalent to the delay–energy objective used in this work. privacy-aware offloading scheme is available, we compare On the other hand, Figure 7b illustrates the validated metthe proposed Heuristic solver with SEC2D and SMUA rics under the Heuristic solver and SMUA. This experiment under full and parallel offloading, respectively, with the is evaluated for α = 1.0, which is equivalent to the sceprivacy penalty disabled (γ = 0). These baselines pro- nario considered in [29], and for α = 0.35 to observe the vide representative comparisons against Lyapunov- and delay–energy trade-off. For α = 1.0, the proposed solver matching-based approaches, while varying the number of achieves the best results in terms of objective cost, equivdevices to assess scalability. alently task delay, for most values of N , especially when Figure 7a illustrates the validated metrics under the Heuris- N > 10. These results are achieved because the Heuristic tic solver and several executions of SEC2D, each corre- solver decides to offload more tasks than SMUA in all evalsponding to a different value of V , a parameter that con- uated scenarios. The price to pay is energy consumption, trols the energy-aware Lyapunov policy under queue sta- which is slightly penalized by the Heuristic solver. bility. When V → 0, SEC2D prioritizes queue stability, When shifting the value of α, i.e., adding priority to energy whereas when V → +∞, it prioritizes energy consump- consumption, the Heuristic solver improves its previous tion. This experiment is evaluated for α = 0.0, which result by substantially reducing the energy consumption is equivalent to the scenario considered in [34], and for with respect to SMUA. This improvement is achieved by α = 0.65 to observe the delay–energy trade-off. For decreasing the number of offloaded tasks. As previously α = 0.0, the Heuristic solver achieves the best result 16
0.72 0.64 0.56 0.48
5 10 15 20 25 30 35 40 45 50 Number of Devices N
0.17 0.16 0.15 0.14
5 10 15 20 25 30 35 40 45 50 Number of Devices N
Heuristic (α = 0.0)
Offload Ratio (%)
Average Delay (s)
0.48 0.46 0.44 0.42
Average Energy (J)
0.80
0.368 0.364 0.360 0.356
Obj. Cost
α = 0.0 α = 0.65
Obj. Cost
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
50 40 30 20
5 10 15 20 25 30 35 40 45 50 Number of Devices N
Heuristic (α = 0.65)
SEC2D (V = 1)
5 10 15 20 25 30 35 40 45 50 Number of Devices N
SEC2D (V = 50)
SEC2D (V = 100)
1
0.57 0.54 0.51 0.48
25
0.162 Offload Ratio (%)
Average Energy (J)
0.420 0.415 0.410 0.405 0.400
0.60 Average Delay (s)
α = 1.0
Obj. Cost
α = 0.35
Obj. Cost
(a) Comparison between SEC2D [34] and the proposed Heuristic solver under full task offloading. 0.495 0.480 0.465 0.450
0.156 0.150 0.144
5 10 15 20 25 30 35 40 45 50 Number of Devices N Heuristic (α = 1.0)
15 10 5
0.138 5 10 15 20 25 30 35 40 45 50 Number of Devices N
20
5 10 15 20 25 30 35 40 45 50 Number of Devices N Heuristic (α = 0.35)
5 10 15 20 25 30 35 40 45 50 Number of Devices N
SMUA
(b) Comparison between SMUA [29] and the proposed Heuristic solver under parallel task offloading. 1
Figure 7: Comparison between representative state-of-the-art task-offloading schemes and the proposed Heuristic solver under full and parallel task offloading settings. analyzed, task delay is then penalized as a direct conse- Evaluation tests validated the performance of the proquence of the lower offload ratio. posed BnB-based greedy and heuristic solvers through the designed discrete-event simulator. The results provide Additionally, according to Table 4, matching-based SMUA three complementary points of view: i) a system-level is slower than the proposed Heuristic solver, with mean analysis assessing scalability, task arrival regimes, and −4 −4 values of 7.30 × 10 s and 4.40 × 10 s, respectively. workload variability; ii) an analysis of the impact of the This occurs because SMUA requires building and updatprivacy penalty on the delay–energy trade-off; and iii) ing preference relations between task subtasks and helper a comparison of the proposed solvers under alternative nodes, and the matching process must account for changes task-offloading schemes, baselines, and state-of-the-art in the allocation state. scheduling policies. In general, the proposed coded task offloading scheme outperforms classical full and parallel task offloading schemes, while the heuristic solver achieves 7 Conclusions and Future Work near-greedy performance with significantly lower compuThis paper introduced a privacy-aware coded task offload- tational cost. The results also show a No-Free-Lunch-like ing scheme under D2D queue-based dynamics and stochas- behavior: under coded task offloading, delay, energy contic task arrivals. for optimizing distributed application de- sumption, and information-based privacy leakage cannot ployments. The proposal combines the advantages of task be jointly optimized. Thus, distributed service deployoffloading and coded computing by providing straggler re- ments must explicitly prioritize the most relevant requiresistance through threshold-based recovery, improving the ments depending on the target application. delay–energy trade-off through a cancellation-aware execu- Further studies are still needed to enhance resource altion mechanism. Additionally, the privacy-aware system is location and workload placement in Fluid Computing modeled through a penalization on the information leaked environments. On the one hand, the proposed solvers by offloaded coded shares under a noisy leakage obser- provide effective centralized and per-slot decisions that vations (such as side-channel attacks), by quantifying the allow us to validate the privacy-aware coded offloading theoretical privacy leakage of the underlying LSS scheme. model and quantify its delay–energy trade-off. However, Therefore, the proposed model does not only decide where highly dynamic and massive networks require more scaltasks are executed, but also evaluates how coded execution able and distributed algorithmic solutions, able to operate affects delay, energy consumption, and privacy leakage. 17
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
with partial information, adapt to changing D2D neighborwards liquid computing,” IEEE Transactions on Cloud Computing, vol. 11, no. 3, pp. 2820–2838, 2022. hoods, and preserve low scheduling overhead. On the other hand, while this work focuses on the privacy implications [10] P. Peng, W. Lin, W. Wu, H. Zhang, S. Peng, Q. Wu, and of coded task offloading, Fluid Computing also requires K. Li, “A survey on computation offloading in edge systems: From the perspective of deep reinforcement learning higher-level orchestration mechanisms capable of coordiapproaches,” Computer Science Review, vol. 53, p. 100656, nating offloading decisions across heterogeneous resources 2024. and administrative domains. Therefore, future work will extend this line toward distributed and privacy-aware task [11] J. Pournazari, A. Ullah, A. Al-Dubai, and X. Liu, “Computation offloading in the edge-to-cloud compute continuum: offloading policies integrated into fluid orchestration framea survey of federated architectural solutions,” Cluster Comworks, where coded execution can be selected at runtime puting, vol. 28, no. 13, p. 839, 2025. according to application intents, resource availability, mo[12] Y. Wang, D. Kong, H. Chai, H. Qiu, R. Xue, and S. Li, “D2d bility, and multi-domain settings.
Acknowledgment This work was supported by the grant PID2023-148716OBC31 funded by MCIU/AEI/10.13039/501100011033 (DISCOVERY project). Additionally, it has also been funded by the Galician Regional Government under project ED431B 2024/41 (GPC).
References [1] Z. Liu, X. Chen, H. Wu, Z. Wang, X. Chen, D. Niyato, and K. Huang, “Integrated sensing and edge ai: Realizing intelligent perception in 6g,” IEEE Communications Surveys & Tutorials, 2025. [2] D. Wen, X. Li, Y. Zhou, Y. Shi, S. Wu, and C. Jiang, “Integrated sensing-communication-computation for edge artificial intelligence,” IEEE Internet of Things Magazine, vol. 7, no. 4, pp. 14–20, 2024. [3] P. Gkonis, A. Giannopoulos, P. Trakadas, X. Masip-Bruin, and F. D’Andria, “A survey on iot-edge-cloud continuum systems: Status, challenges, use cases, and open issues,” Future Internet, vol. 15, no. 12, p. 383, 2023. [4] A. Ullah, T. Kiss, J. Kovács, F. Tusa, J. Deslauriers, H. Dagdeviren, R. Arjun, and H. Hamzeh, “Orchestration in the cloud-to-things compute continuum: taxonomy, survey and future directions,” Journal of Cloud Computing, vol. 12, no. 1, pp. 1–29, 2023. [5] A. Marchese and O. Tomarchio, “Application and infrastructure-aware orchestration in the cloud-to-edge continuum,” in 2023 IEEE 16th International Conference on Cloud Computing (CLOUD). IEEE, 2023, pp. 262–271. [6] R. Rosmaninho, D. Raposo, P. Rito, and S. Sargento, “Edgecloud continuum orchestration of critical services: A smartcity approach,” IEEE Transactions on Services Computing, 2025. [7] Y. S. Patel, P. Townend, A. Singh, and P.-O. Östberg, “Modeling the green cloud continuum: integrating energy considerations into cloud–edge models,” Cluster computing, vol. 27, no. 4, pp. 4095–4125, 2024. [8] J. J. Lopez Escobar, R. P. Díaz Redondo, and F. GilCastineira, “In-depth analysis and open challenges of mist computing,” Journal of Cloud Computing, vol. 11, no. 1, p. 81, 2022. [9] M. Iorio, F. Risso, A. Palesandro, L. Camiciotti, and A. Manzalini, “Computing without borders: The way to-
18
assisted cooperative computational offloading strategy in edge cloud computing networks,” Scientific Reports, vol. 15, no. 1, p. 12303, 2025. [13] Z. Wang, Y. Sun, D. Liu, J. Hu, X. Pang, Y. Hu, and K. Ren, “Location privacy-aware task offloading in mobile edge computing,” IEEE Transactions on Mobile Computing, vol. 23, no. 3, pp. 2269–2283, 2023. [14] D.-G. Zhang, H.-Z. An, J. Zhang, T. Zhang, W.-M. Dong, and X.-R. Jiang, “Novel privacy awareness task offloading approach based on privacy entropy,” IEEE Transactions on Network and Service Management, vol. 21, no. 3, pp. 3598–3608, 2024. [15] S. Li and S. Avestimehr, “Coded computing: Mitigating fundamental bottlenecks in large-scale distributed computing and machine learning,” Foundations and Trends in Communications and Information Theory, vol. 17, no. 1, pp. 1–148, 2020. [16] J. S. Ng, W. Y. B. Lim, N. C. Luong, Z. Xiong, A. Asheralieva, D. Niyato, C. Leung, and C. Miao, “A survey of coded distributed computing,” arXiv preprint arXiv:2008.09048, 2020. [17] R. Bitar, P. Parag, and S. El Rouayheb, “Minimizing latency for secure coded computing using secret sharing via staircase codes,” IEEE Transactions on Communications, vol. 68, no. 8, pp. 4609–4619, 2020. [18] R. Schlegel, S. Kumar, E. Rosnes, and A. G. i Amat, “Privacy-preserving coded mobile edge computing for lowlatency distributed inference,” IEEE Journal on Selected Areas in Communications, vol. 40, no. 3, pp. 788–799, 2022. [19] S. Beck, M. Raavi, C. Dale, K. Weishalla, and B. Worrell, “Survey of side-channel vulnerabilities for short-range wireless communication technologies,” in 2024 IEEE International Conference on Electro Information Technology (eIT). IEEE, 2024, pp. 450–456. [20] U. Gupta and H. Mahdavifar, “On the security of linear secret sharing with general noisy side-channel leakage,” in Annual International Conference on the Theory and Applications of Cryptographic Techniques. Springer, 2026, pp. 477–505. [21] K. Sadatdiynov, L. Cui, L. Zhang, J. Z. Huang, S. Salloum, and M. S. Mahmud, “A review of optimization methods for computation offloading in edge computing networks,” Digital Communications and Networks, vol. 9, no. 2, pp. 450–461, 2023. [22] F. Sufyan and A. Banerjee, “Computation offloading for distributed mobile edge computing network: A multiobjective approach,” IEEE Access, vol. 8, pp. 149 915–149 930, 2020.
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
[23] M. Jia, J. Zhu, and H. Huang, “Energy and delay-ware [37] M. M. Razaq, B. Tak, L. Peng, and M. Guizani, “Privacymassive task scheduling in fog-cloud computing system,” aware collaborative task offloading in fog computing,” IEEE Peer-to-Peer Networking and Applications, vol. 14, no. 4, Transactions on Computational Social Systems, vol. 9, no. 1, pp. 2139–2155, 2021. pp. 88–96, 2021. [24] H. Niu, L. Wang, K. Du, Z. Lu, X. Wen, and Y. Liu, “A [38] H. Chen, R. Cramer, S. Goldwasser, R. De Haan, and V. Vaikuntanathan, “Secure computation from random error pipelining task offloading strategy via delay-aware multicorrecting codes,” in Annual International Conference on agent reinforcement learning in cybertwin-enabled 6g netthe Theory and Applications of Cryptographic Techniques. work,” Digital Communications and Networks, vol. 11, Springer, 2007, pp. 291–310. no. 1, pp. 92–105, 2025. P. Zhao, H. Tian, C. Qin, and G. Nie, “Energy-saving of[39] [25] S. Khan, J. Zheng, S. Khan, Z. Masood, and M. P. Akhter, floading by jointly allocating radio and computational re“Dynamic offloading technique for real-time edge-to-cloud sources for mobile edge computing,” IEEE access, vol. 5, computing in heterogeneous mec–mcc and iot devices,” Inpp. 11 255–11 268, 2017. ternet of Things, vol. 24, p. 100996, 2023. [40] ETSI, “5G; NR; User Equipment (UE) radio transmission [26] Y. Ding, K. Li, C. Liu, and K. Li, “A potential game theoand reception; Part 1: Range 1 Standalone,” European retic approach to computation offloading strategy optimizaTelecommunications Standards Institute, Sophia Antipolis, tion in end-edge-cloud computing,” IEEE Transactions on France, Technical Specification ETSI TS 138 101-1 Parallel and Distributed Systems, vol. 33, no. 6, pp. 1503– V16.12.1, Jul. 2022, 3GPP TS 38.101-1 version 16.12.1 1519, 2021. Release 16. [Online]. Available: https://www.etsi.org/ [27] S. Aggarwal, M. Bastopcu, S. Ulukus, T. Başar et al., standards-search “Distributed offloading in multi-access edge computing [41] F. Benhamouda, A. Degwekar, Y. Ishai, and T. Rabin, “On systems: A mean-field perspective,” arXiv preprint the local leakage resilience of linear secret sharing schemes: arXiv:2501.18718, 2025. F. benhamouda et al.” Journal of Cryptology, vol. 34, no. 2, p. 10, 2021. [28] H. He, X. Yang, X. Mi, H. Shen, and X. Liao, “Multi-agent deep reinforcement learning based dynamic task offload- [42] J. Bruno, E. G. Coffman Jr, and R. Sethi, “Scheduling ing in a device-to-device mobile-edge computing network independent tasks to reduce mean finishing time,” Commuto minimize average task delay with deadline constraints,” nications of the ACM, vol. 17, no. 7, pp. 382–387, 1974. Sensors, vol. 24, no. 16, p. 5141, 2024. [29] U. M. Malik, M. A. Javed, J. Frnda, J. Rozhon, and W. U. Khan, “Efficient matching-based parallel task offloading in iot networks,” Sensors, vol. 22, no. 18, p. 6906, 2022. [30] R. Bitar, Y. Xing, Y. Keshtkarjahromi, V. Dasari, S. El Rouayheb, and H. Seferoglu, “Private and rateless adaptive coded matrix-vector multiplication,” EURASIP Journal on Wireless Communications and Networking, vol. 2021, no. 1, p. 15, 2021. [31] J. Zhang, Y. Hu, M. Shao, and X. Li, “Joint energy-aware task offloading and privacy protection in healthcare monitoring systems via deep reinforcement learning,” Scientific Reports, 2025. [32] F. Xia, Y. Chen, and J. Huang, “Privacy-preserving task offloading in mobile edge computing: A deep reinforcement learning approach,” Software: Practice and Experience, vol. 54, no. 9, pp. 1774–1792, 2024. [33] H. Baek, H. Ko, and S. Pack, “Privacy-preserving and trustworthy device-to-device (d2d) offloading scheme,” IEEE Access, vol. 8, pp. 191 551–191 560, 2020. [34] Z. Li, H. Hu, H. Hu, B. Huang, J. Ge, and V. Chang, “Security and energy-aware collaborative task offloading in d2d communication,” Future Generation Computer Systems, vol. 118, pp. 358–373, 2021. [35] H. Yu, J. Liu, C. Hu, and Z. Zhu, “Privacypreserving task offloading strategies in MEC,” Sensors, vol. 23, no. 1, p. 95, 2023. [Online]. Available: https://doi.org/10.3390/s23010095 [36] D. Zhu, T. Li, H. Liu, J. Sun, L. Geng, and Y. Liu, “Privacy-aware online task offloading for mobile-edge computing,” Wireless Communications and Mobile Computing, vol. 2021, no. 1, p. 6622947, 2021.
19
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
A
Derivation of the Privacy Leakage Bound The name information density is justified by the simple
A.1
Auxiliary Results and Adapted Leakage Framework
observation that I(S; L) = E log Λ(S, L) ,
where the expectation is over the joint distribution of (S, L) and I(S; L) is the mutual information between two random vectors. In a similar spirit, Λ′ captures the statistics that compare the channel S 7→ L with the separate random variables S and the iid vector (L1 , . . . , Ln ). Through the lens of information theory, this quantifies to what exn For any linear code C ⊆ Fq , its dual code is tent it is possible to simulate the channel S 7→ L with independent random variables, or equivalently if the two ⊥ n C = {x ∈ Fq : ⟨x, c⟩ = 0, ∀c ∈ C}. alternatives can be statistically distinguished. Moreover, Since C2 ⊊ C1 , we have C1⊥ ⊊ C2⊥ . Moreover, because the an important identity is 2∆TV = E |Λ − 1| , where again dual of an MDS code is also MDS, C1⊥ is an [n, n−t, t+1]q the expectation is with respect to the joint distribution of code, and C2⊥ is an [n, n − t + k, t − k + 1]q . Therefore, (S, L). every non-zero vector in C2⊥ has Hamming weight at least Lemma 4. Given a secret vector s and a leakage realizat − k + 1. tion ℓ
We follow the Fourier-analytic leakage derivation of [20] and adapt it to the multi-secret ramp secret sharing scheme introduced in Section 3.7. To derive the leakage bound, we recall the required dual-code notation and establish the uniformity properties of the generated shares.
The following simple lemma shows that the secret shares Λ′ (s, ℓ) − 1 ≤ max Λ′ (s, ℓ) − 1 . in an RampSS(t, k, n) are uniformly distributed over Fq . Λ(s, ℓ) s∈Fk q Lemma 3. Consider a RampSS(t, k, n) scheme instantiated with nested MDS codes. Assume that S is uniformly distributed over Fkq . Then, Ui is uniformly distributed in Proof. We have that Fq , for every i = 1, . . . , n. P(L = ℓ) Λ′ − 1 = Qn −1 s Λ Proof. Consider the mapping Φ : Fq × C2 → C1 with j=1 P(Lj = ℓj ) Φ(s, c2 ) = ψ(s)+c2 . Since C1 = S ⊕C2 and ψ : Fsq → S = |ES [Λ′ (S, ℓ) − 1]| is an isomorphism, Φ is bijective (i.e., every c1 ∈ C1 has ≤ ES [|Λ′ (S, ℓ) − 1|] . a unique preimage (s, c2 )). Moreover, S is uniform over Fkq and the random vector inside each selected coset is and the lemma follows by using Jensen’s inequality over uniform over C2 . Therefore, U is uniformly distributed convex functions. over C1 . Now fix a coordinate i. Let πi : C1 → Fq be the linear mapping defined by πi (c) = ci . Since C1 is an MDS code with parameters [n, t, n − t + 1]q , no coordinate projection of C1 is identically zero. Otherwise, puncturing that coordinate would give a length-(n − 1) linear code of dimension t and minimum distance n − t + 1, contradicting the Singleton bound. Therefore, πi is a non-zero linear form and hence is surjective onto Fq . By standard algebra, C1 / ker(πi ) is isomorphic to Fq , and the cosets {cα + ker(πi ) : α ∈ Fq , πi (cα ) = α} are a partition of C1 . Since U is uniformly distributed over C1 , it follows that Ui = πi (U) is uniformly distributed in Fq .
We can also bound the maximum deviation of the information density as follows. Lemma 5. Fix a secret s and a leakage realization ℓ. It holds that ! Λ(s, ℓ) ′ max Λ(s, ℓ) − 1 ≤ 2 ′ max Λ (s, ℓ) − 1 Λ (s, ℓ) s∈Fkq s∈Fk q Proof. This follows by applying the triangle inequality |Λ(s, ℓ) − 1| ≤ Λ(s, ℓ) −
Λ Λ + ′ −1 Λ′ Λ
On the other hand, in preparation of our main result, let us repeat here the definitions introduced in [20], adapted to Λ(s, ℓ) ′ Λ(s, ℓ) = ′ |Λ (s, ℓ) − 1| + ′ −1 . our setting. Λ (s, ℓ) Λ (s, ℓ) Definition 4. Given a secret vector s and some leakage realization ℓ, define the information density Reorganizing these terms ! P(S = s, L = ℓ) Λ(s, ℓ) := , Λ(s, ℓ) P(S = s)P(L = ℓ) max Λ′ (s, ℓ) − 1 . max Λ(s, ℓ) − 1 ≤ 2 ′ Λ (s, ℓ) s∈Fk s∈Fk q q and the information density under independence P(S = s, L = ℓ) Note that for the latter inequality we have used the result Qn Λ′ (s, ℓ) := . in Lemma 2. P(S = s) j=1 P(Li = ℓi ) 20
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
We now address the question of bounding in [41]. Consequently, it is sufficient to pick any w of maxs∈Fkq |Λ′ (s, ℓ) − 1|. To that end, define first the minimum weight and bound the Fourier coefficients. Since the sum is performed over C2⊥ , we know that the minimum a posteriori distributions weight of non-zero codewords is t − k + 1 due to its MDS Ψℓi : Fq → C structure. α 7→ P(Ui = α | Li = ℓi ), To finalize the bounds on the leakage, we recall that Qn and let Ψℓ (α1 , . . . , αn ) := j=1 Ψℓj (αj ). ∆ARE (S, L) = EL maxs∈Fkq Λ(s, L) − 1 . Therefore, # " 1 ARE Λ(s, ℓ) Lemma 6. For a RampSS(t, k, n) scheme, let ℓ be a fixed ′ ∆ (S, L) ≤ EL ′ max |Λ (s, ℓ) − 1| leakage realization under the δ-noisy leakage model. Then, 2 Λ (s, ℓ) s∈Fkq X n max Λ′ (s, ℓ) − 1 ≤ Ψ̂ℓ (w) . XY s∈Fk q = P(L = ℓ) max |Λ′ (s, ℓ) − 1| ⊥,× w∈C 2
ℓ∈L i=1
s∈Fk q
n i h X Y Proof. The Lemma and the proof are a special case of b . ≤ E Ψ (w ) Li ℓi i Lemma 4 in [20]. Indeed, we can write that ⊥,× i=1 P w∈C2 P(U = u) P(L = ℓ | U = u) P(L = ℓ | S = s) = u:S=s P Using that ELj Ψ̂ℓj (wj ) ≤ 2∆FL (Uj , Lj ), and letting u:S=s P(U = u) n X Y J ⊆ supp(w) be a subset of size t − k + 1 among [n], we = q k−t P(Li = ℓi | Ui = ui ) get the bound u:S=s i=1 X Y 1 ARE n t−k+1 X Y ∆ (S, L) ≤ 2 ∆FL (Uj , Lj ) 2 = q k+n−t P(Li = ℓi ) ⊥,× j∈J w∈C2 u:S=s i=1 Y ≤ 2t−k+1 q n−t+k − 1 max δj , · P(Ui = ui | Li = ℓi ) [n] J ∈(t−k+1 ) j∈J n Y X = q k+n−t P(Li = ℓi ) Ψℓ (u) It is possible to bound also the mutual information, i=1
u∈ψ(s)+C2
I(S; L) ≤ H(S) ∆ARE (S, L)
by using the Bayes’s rule and since there exists a unique coset of secrets that results in the same share vector u. And by the Poisson summation formula (Theorem 2 from [20]) P(L = ℓ | S = s) Λ′ (s, ℓ) = Qn i=1 P(Li = ℓi ) k+n−t X q Ψ̂ℓ (u)χ(−⟨ψ(s), w⟩) = · ⊥ |C2 | u∈C2⊥ X = Ψ̂ℓ (w)χ(−⟨ψ(s), w⟩),
≤ k 2t−k+1 q n−t+k − 1 log2 q Y · max δj . [n] J ∈(t−k+1 ) j∈J
B
NP-hardness of Problem P1
Proof. We prove the claim by polynomial-time reduction from a classical NP-hard scheduling problem. Specifically, we consider the minimum mean finishing-time problem for w∈C2⊥ independent tasks on parallel processors, shown in [42], to where χ : Fq → C is the character function. Since be polynomial complete. Ψ̂ℓ (0)χ(0) = 1 and |χ(·)| = 1, we get Consider a single time slot t whose objective reduces to the X Λ′ (s, ℓ) − 1 ≤ Ψ̂ℓ (w) , per-slot average cost over the batch K(t). Then, impose the following restrictions: w∈C2⊥,× by applying the triangle inequality. A.2
Proof of Theorem 1 Qn Recall that |Ψ̂ℓ (w)| = i=1 |Ψ̂ℓi (wi )|, that Ψ̂ℓi (0) = 1, and that
a) the objective function in (28a) is restrained to a only delay-aware objective by choosing α = 1, and the privacy-leakage penalty is made inactive by choosing γ = 0;
Ψ̂ℓi (wi ) ≤ bias(Ui | Li = ℓi ) = 2∆FL ℓi (Ui , Li ).
b) for every task (i, k), set sik = tik = nik = 1, so that offloading means assigning the overall task to exactly one helper;
Moreover, the Fourier coefficients |Ψ̂ℓj (wj )| are smaller in magnitude than the trivial one |Ψ̂ℓj (0)| = 1 as highlighted
c) the memory constraint (28b) is made inactive by taking sufficiently large resources; 21
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
d) make local execution dominated by assigning it an arbitrarily large cost, so that every optimal solution offloads each task to one helper device; e) suppress communication costs (both transmission time and transmission energy consumption), so that only computation queues remain relevant. Under these restrictions, every task (i, k) ∈ K(t) must be assigned to exactly one helper device j, and its delay is determined by the the completion time induced by the computation queue of device j and its computation resources. Hence, the restricted problem becomes a scheduling problem for assigning independent jobs to a set of parallel resources. More precisely, let an instance of the source problem contain n jobs and m processors, and let pqj denote the processing time of job q on processor j. We construct an instance of the restricted version of P1 by mapping one task in K(t) to each job, one helper device for each processor, and setting the computation time of the corresponding task on helper j equal to pqj . This mapping requires writing n tasks, m helper devices, and the n × m matrix {pqj }, and is therefore computable in polynomial time. Because communication is suppressed and local execution is not considered, scheduling decisions of the restricted P1 are in one-to-one mapping with scheduling decisions of the source scheduling instance. Since minimum mean completion-time scheduling on par- Figure 8: Workflow of proposed discrete-event simulator allel processors is NP-hard, the restricted version of P1 is NP-hard. Therefore, the full problem P1 is NP-hard as well. memory, the corresponding transmission is blocked until enough memory is released.
C
More Implementation Details
The DES is implemented using the SimPy framework6 and validates the scheduling decisions in an event-driven queueing environment. Its workflow is summarized in Figure 8. At each scheduling epoch, the incoming tasks TaskBatch and the current SystemState are provided to the scheduling policy, which returns a SchedulePlan. This plan is then executed by the Execution Engine, which instantiates the scheduled Workload and manages the CodedTaskController for tracking the completion of the encoded shares required to reconstruct each output. The Node Abstraction represents the heterogeneous devices and encapsulates their local resources, including SimPy Resources for serialized transmission and computation operations, and SimPy Containers for memory occupancy. Once the time-slot execution finishes, the simulator updates the system state, generates the next task batch, and repeats the process until the last slot is reached. This simulator explicitly captures asynchronous execution, resource contention, queue concurrency, and memoryadmission blocking effects. Specifically, when an offloaded share reaches a helper with insufficient available 6
https://www.sympy.org/
D
Supplementary Results
D.1
General Performance
Figure 9 analyzes the general system performance under different network-based parameters. Specifically, Figure 9a evaluates the impact of the network size, measured by the number of devices. The results show a clear delay– energy trade-off as the average task delay decreases when the network size increases, going from 0.547 s to 0.375 s, while the average task energy consumption is lower for smaller networks, going from 0.153 J to 0.175 J. This behavior is expected since larger networks provide more potential helper devices, which improves the capacity to serve backlogged requesters and further benefits from the threshold-based recovery of the coded scheme. However, a higher number of offloaded tasks also implies a larger number of transmitted shares and remote computations. This mainly increases the backlogged computation tasks, although this effect is partially mitigated by the cancellationaware execution policy, which avoids waiting for all shares once the recovery threshold is reached. Moreover, even though the average number of backlogged tasks per device increases with N , the offload ratio re-
22
0.40
Offload Ratio (%)
10
20 30 40 Number of devices, N
30 20 10 20 30 40 Number of devices, N
0.160 0.155 10
40
10
0.165
50
50
0
Objective Cost
0.44
0.170
50
1.5 1.2 0.9 0.6 0.3 0.0
20 30 40 Number of devices, N
20 30 40 Number of devices, N
0.416 0.408 0.400
50
CPU TX
10
0.424
50
Jain’s Fairness Index
0.48
0.432
0.175
1.0
Offload Ratio (%)
Avg. Energy (J)
0.52
Avg. Backlog (tasks)
Avg. Delay (s)
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
28
10
20 30 40 Number of devices, N
50
10
20 30 40 Number of devices, N
50
100
200 300 400 D2D Distance (m)
500
0.8 0.6 0.4 0.2 0.0
(a) Sweep over number of devices Avg. Energy (J)
Avg. Delay (s)
1
0.42 0.40 0.38 0.36 100
200 300 400 D2D Distance (m)
500
0.180 0.174 0.168 0.162 0.156 100
pij = 0.04 W
200 300 400 D2D Distance (m)
pij = 0.08 W
500
pij = 0.12 W
24 20 16
pij = 0.16 W
(b) Sweep over D2D distance between devices 1
Figure 9: System performance under different network sizes and D2D distances. mains almost constant, around 25%. This indicates that the system preserves a stable scheduling behavior while the absolute number of generated tasks and offloaded shares increases with the network size, which naturally produces larger queue backlogs. Additionally, the number of backlogged transmissions is almost negligible compared to the CPU backlog, which indicates that, at the end of each time slot, the transmission rate is sufficient to serve most pending transmissions. For N = 5, the system exhibits a different behavior, with higher delay and lower offload ratio than the remaining configurations. This is caused by the limited number of balanced and helper devices under the configured device proportions, which reduces the availability of attractive offloading opportunities. Finally, we validate the Jain’s Fairness index, which measures whether the workload is evenly distributed among devices or, conversely, computed as P 2 N i=1 xi , PN N i=1 x2i where (xi )N i=1 denote the workload allocation profile across the N devices, and xi represents the number of processed and waiting tasks at device i. It remains around
0.8 throughout the sweep of number of devices, which shows that the heuristic solver distributes the workload fairly when selecting offloading decisions and helper devices, i.e., offloaded shares are not always assigned to the same high-capacity devices. However, when N increases, this index tends to decrease. This is also expected, since the strongest devices become more attractive for offloading and progressively receive a larger fraction of the remote workload. On the other hand, Figure 9b analyzes the system performance when changing the D2D distance between devices. In this experiment, all devices are separated by the same distance to isolate its impact on the communication performance. The delay and offload ratio trends are consistent with the expected behavior as the average delay increases with the distance, from 0.363 s to 0.421 s (for pij = 0.08 W), since longer transmission times make offloading less attractive. Conversely, the average task energy consumption decreases with the distance because fewer tasks are offloaded, reducing the number of share transmissions and remote computations. The same trend is observed for different transmission powers, where higher powers increase the energy cost of each transmission. This can be observed in the task energy consumption,
23
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
D.2
Avg. CPU Backlog (tasks)
which moves from 0.154 J for pij = 0.04 W to 0.163 J for pij = 0.16 W (with dij = 500 m). System Scalability
This subsection analyzes the system performance under different scalability configurations. Specifically, Figure 10 evaluates the impact of different task-arrival regimes. As expected, increasing ρ increases the number of backlogged tasks in the queues. The same occurs when the slot duration increases, since devices have more time to generate task requests before the next scheduling decision. The offload ratio follows a different behavior as it decreases for shorter slot durations because scheduling epochs are triggered more frequently and queues are less accumulated, which makes local execution more competitive in some slots. However, for a fixed slot duration, the offload ratio increases with higher values of ρ, since heavier task-arrival regimes create more opportunities to benefit from helper devices.
Slot τ = 0.1 s Slot τ = 0.25 s Slot τ = 0.4 s
3.2 2.4 1.6 0.8 0.0 0.2
0.4
0.6 0.8 1.0 Load Multiplier ρ
1.2
1.4
0.2
0.4
0.6 0.8 1.0 Load Multiplier ρ
1.2
1.4
Offload Ratio (%)
45 40 35 30
Avg. Delay Component (s)
Additionally, we study the impact of task arrivals on the average task delay, considering its different components: 0.4 transmission waiting time, transmission time, CPU waiting time, and computation time, including locally executed 0.3 and offloaded workloads. The computation time and transmission waiting time remain approximately constant for 0.2 different values of ρ. This can be explained by two factors: i) the computation time depends mainly on the workload 0.1 distribution, not on the number of scheduled tasks; ii) for τ = 0.1 s, the offload ratio remains mostly stable across 0.0 0.2 0.6 1.0 1.4 different values of ρ, while the transmission service rate Load Multiplier ρ Rij (t) is fixed. In contrast, CPU waiting time clearly increases when the number of scheduled tasks grows, going TX Queue Wait CPU Queue Wait from 3.453 ms to 36.392 ms for τ = 0.1 s. The transmisTX Computation sion time also slightly increases for higher ρ, since memory constraints favor the offloading of tasks with fewer shares, Figure 10: Scalability analysis under different task-arrival which makes each selected offloaded workload larger on regimes and slot durations. 1 average. Therefore, there is no direct translation between ρ and task delay, i.e., reducing or increasing the task-arrival rate by a factor ρ does not reduce or increase the average task delay by the same factor. Additionally, Figure 11 analyzes the system performance under different workload distributions and slot durations. The mean workload is fixed to 1,000 cycles/bit, while the lower and upper values are modified to change the workload variability. First, the average task delay decreases when workload variability increases for two reasons: i) higher variability produces a larger number of lightweight tasks, for which local execution becomes attractive and fast; ii) the offload ratio also increases for heavier tasks, allowing the scheduler to exploit coded execution when it provides a clear delay reduction. Moreover, as workload variability increases, the entire task-delay distribution shifts downwards. Specifically, the median delay drops from approximately 0.349 s under low variability to 0.288 s under high variability (for τ = 0.1 s). This occurs because the wider distribution of CPU cycles
per bit produces a significant fraction of lightweight tasks. These tasks are computed rapidly, as reflected by quartile-1 decreasing to 0.075 s under high variability, which helps reduce queue pressure. Meanwhile, heavier tasks are more frequently handled through coded offloading. Comparing the boxplots across slot durations shows that the delay distributions remain stable for each workload preset. This suggests that the scheduling framework is temporally robust: as long as the system remains stable, changing the scheduling frequency does not significantly degrade the delay distribution. This stability is maintained because the system increases its offload ratio at larger slot durations, compensating for less frequent scheduling by using helper resources more aggressively.
24
Coded Task Offloading for Fluid Computing: A Privacy-Aware Approach under D2D Networks
Avg. Delay (s)
0.400 0.375 Low (850–1150) Medium (500–1500)
0.350
High (100–1900) 0.325
more favorable. Finally, when α → 1, delay minimization is prioritized, increasing the number of offloaded tasks to exploit coded execution and threshold-based recovery. In this case, the offload ratio remains in the range of 90%– 100% independently of δ, i.e., the privacy penalty is not enough to overcome the delay benefit of coded offloading. However, energy consumption is penalized, reaching approximately 0.255 J on average.
0.300 0.15
0.25 0.35 Slot Duration (s)
0.45
0.54 Average Delay (s)
Task Delay (s)
0.05
0.75 0.50 0.25
0.48 0.42 0.36 0.30
0.0
0.2
0.4 0.6 0.8 α (Latency Priority)
1.0
0.0
0.2
0.4 0.6 0.8 α (Latency Priority)
1.0
0.00
Offload Ratio (%)
44 40
0.25 Slot Duration (s)
0.4
Average Energy (J)
0.1
Slot τ = 0.1 s Slot τ = 0.25 s Slot τ = 0.4 s
36 32
0.24 0.21 0.18 0.15
28
] 0] 200] 300] 400] 500] 600] 700] 800] 900] 000 10 , 1 00, 1 00, 1 00, 1 00, 1 00, 1 00, 1 00, 1 00, 1 00, 1 0 0 [9 [8 [7 [6 [5 [4 [3 [2 [1 [10
100 Offload Ratio (%)
Workload Range [min, max] (cycles/bit)
Figure 11: Scalability analysis under different workload 1 distributions and slot durations.
D.3
Delay-Energy Trade-off under Privacy Penalty
75 50 25
The evaluated metrics in Figure 12 are swept for differ0 ent values of the pair (α, β), with β = 1 − α. When 0.0 0.2 0.4 0.6 0.8 1.0 α → 0, energy minimization is prioritized, which results α (Latency Priority) in a negligible fraction of offloaded tasks. As a result, δ=0 δ = 2−10 δ = 2−1 energy consumption is mainly limited to local computa−15 −5 δ=2 δ=2 tions, avoiding the coded procedure and, therefore, the overhead introduced by share transmissions and remote computations. This penalizes task delay, which reaches Figure 12: Delay–energy trade-off under different values 1 with γ = 0.05. approximately 0.54 s on average. For intermediate values of the δ-noisy leakage parameter of α, e.g., α = 0.5, two main aspects can be observed: i) the impact of the δ parameter; ii) the trade-off between delay and energy. Regarding the former, lower values of δ lead to a higher offload ratio and, therefore, to higher energy consumption and lower delay. Conversely, higher values of δ reduce the attractiveness of offloading because they increase the privacy penalty. This is because δ → 0 provides almost zero privacy leakage, making offloading 25