Distributed Linear Bandits for Freshness-Aware Preprocessing in MEC-Enabled Digital Twin Networks

1

Distributed Linear Bandits for Freshness-Aware Preprocessing in MEC-Enabled Digital Twin Networks

arXiv:2611.05115v1 [cs.DC] 3 Nov 2026

Mariam Yahya and Setareh Maghsudi Faculty of Electrical Engineering and Information Technology, Ruhr-University Bochum, Germany

Abstract—Digital twins (DTs) require timely updates from Internet of Things (IoT) devices to accurately represent the state of the corresponding physical systems, but transmitting large data volumes can compromise freshness. Moreover, different task classes have distinct computational demands and freshness requirements, while stochastic task generation and sizes complicate resource allocation. In this paper, we propose a freshnessaware framework in which multi-access edge computing (MEC) servers preprocess IoT data, reducing transmission volume and DT-server processing load. The framework establishes mutual support between DT and MEC servers. The DTs determine feasible CPU-allocation strategies guaranteeing class-specific ageof-information (AoI) requirements under specified workload, delay, and update-generation bounds. MEC servers collaboratively identify the feasible strategy minimizing expected freshnessnormalized preprocessing delay. We formulate CPU-strategy selection as a fixed-confidence distributed best-arm identification problem in linear bandits, with MEC servers as agents and CPU allocations across task classes as arms. We employ DistLinGapE, a distributed collaborative learning method, to coordinate exploration and share observations. Numerical results show that the method identifies the optimal feasible strategy and reduces preprocessing delay when deployed under stationary task-class assignments and workload statistics. Collaboration yields an identification speedup nearly proportional to the number of participating MEC servers in the evaluated settings. Index Terms—Multi-access edge computing (MEC), Age-ofInformation (AoI), digital twins (DT), linear bandits, distributed learning.

I. I NTRODUCTION The rapid growth of Internet of Things (IoT) networks has accelerated the use of digital twins (DTs), which are virtual representations of physical systems, in computation-intensive applications such as vehicular networks [1], industrial automation [2], and smart healthcare [3]. Through continuous synchronization with physical systems, DTs can support system monitoring, optimization, and autonomous operation [1]–[6]. Maintaining an accurate DT, however, requires sensing devices to provide timely data that reflects the current state of the physical system. A common approach updates the virtual DT representations and uses them to guide operational decisions in the physical This work was supported in part by the Federal Ministry of Research, Technology and Space (BMFTR) under Grant 16KIS2411 and in part by German Research Foundation (DFG) under Grant MA7111/6-1 Mariam Yahya and Setareh Maghsudi are with the Faculty of Electrical Engineering and Information Technology, Ruhr-University Bochum, 44801 Bochum, Germany (e-mails: {mariam.yahya, setareh.maghsudi}@ruhr-unibochum.de).

system, such as resource allocation in edge networks [2], [7]. However, updating the DT itself requires communication and computational resources. Transmitting large volumes of sensing data to the DT server can cause substantial communication overhead and processing delays [5], [8]. The resulting synchronization delays may cause the DT to rely on outdated information, reducing its usefulness in real-time applications. Moreover, depending on the application, updating the DT may require only a subset of the sensing data or information extracted from it [5], [8]–[10]. Preprocessing sensing data before updating the DT can help address this challenge. Techniques such as data compression [9], feature extraction [10], and semantic communication [5], [8] can reduce the volume of forwarded data and, depending on the application, the processing load at the DT server. These benefits motivate the use of multi-access edge computing (MEC) servers to preprocess data closer to IoT devices. IoT devices or clusters can transmit sensing tasks from multiple classes to MEC servers for preprocessing. These classes may differ in their preprocessing needs, computational demands, and freshness requirements [11], [12]. Age of information (AoI) provides a measure of the freshness of the information represented by a DT and can be used to specify class-specific freshness requirements. Allocating computational resources for preprocessing is challenging when task generation and task sizes are uncertain [7], [13], as the allocation must accommodate different computational demands while keeping DTs sufficiently up to date. Uniform or random CPU allocation across task classes may be inefficient because it does not account for differences in workloads and freshness requirements. This motivates learning approaches that use observed preprocessing delays to identify effective CPU allocations. A. Paper Contributions We propose a framework that establishes mutual support between the DT and the MEC servers. The MEC servers preprocess sensing data before forwarding the results to the DT server, while the DT guides their CPU-allocation decisions through a two-stage process. First, the DT determines a feasible set of CPU-allocation strategies that guaranty class-specific AoI requirements under specified workload, delay, and updategeneration bounds. Second, the MEC servers collaboratively identify the strategy within this set that minimizes the expected freshness-normalized preprocessing delay.

2

We formulate CPU-allocation strategy selection as a fixedconfidence distributed best-arm identification (BAI) problem in linear bandits. MEC servers solving a shared allocation problem combine their observations to identify the best strategy with a predefined confidence using as few observations as possible. The linear structure allows observations from one strategy to inform the evaluation of others. We employ the distributed linear gap-based exploration (DistLinGapE) algorithm [14] to perform this collaborative identification. The main contributions of this work are summarized as follows: • We develop a freshness-aware MEC preprocessing framework in which the DTs determine feasible CPU-allocation strategies that satisfy class-specific AoI requirements. • We formulate CPU-allocation strategy selection as a fixed-confidence distributed linear BAI problem, aiming to identify the feasible strategy that minimizes the expected freshness-normalized preprocessing delay under unknown mean workloads and task generation rates. • We employ DistLinGapE to enable MEC servers to collaboratively identify the best feasible CPU allocation. • The numerical results show that the DistLinGapE is effective in finding the best CPU allocation strategy with a predetermined confidence. Additionally, we show that collaboration among the MEC-servers speedup the learning process by reducing the number of learning rounds required per server. B. Paper Organization This paper is organized as follows. Section II reviews the related work on DTs, AoI, and bandit learning. Section III introduces the system model, and Section IV presents the DT freshness requirements and strategy-update mechanism. Section V formulates the optimization problem, while Section VI develops its linear-bandit BAI representation. Section VII presents the solution approach using DistLinGapE. Numerical results are presented in Section VIII, and Section IX concludes the paper. II. BACKGROUND AND R ELATED W ORK A. Digital Twins and Age of Information Research on DT-enabled networks considers two different but complementary directions: the first uses DTs to support physical-system monitoring, optimization, or operation, while the second focuses on maintaining timely DT representations through methods such as resource allocation, DT placement and migration, and update scheduling. These directions are closely connected, as the effectiveness of DT-assisted decisions depends on the freshness of the information available to the DT. Our work connects them through mutual support between the DT and MEC servers. Our work considers fixed DT placement and focuses on allocating computational resources to reduce preprocessing delay while satisfying freshness requirements. Another research direction investigates DT placement and migration to determine where DTs should be hosted and when their

locations should change to improve synchronization [6], [15], [16]. Dynamic placement adjusts DT locations to changing network conditions to improve synchronization efficiency [15]. For mobile physical systems, Noroozi et al. [6] formulate DT migration as a Markovian stopping problem and use dynamic programming to reduce the AoI observed when an application requests data. Considering both freshness and energy consumption, Guo et al. [16] jointly optimize edge association, transmission power, and DT deployment through a lightweight online algorithm. Collaboration in DT-enabled networks has been studied both for providing shared services and for coordinating resource allocation. Although MEC servers and DTs may operate independently, applications involving multiple physical objects can benefit from exchanging information and coordination. For example, Li et al. [17] consider DT network slicing, where worker DTs process data from physical objects and a master DT aggregates their outputs to support a shared service. They develop approximation and online algorithms to maximize service utility based on AoI-dependent model quality, subject to delay and resource constraints. Collaboration can also support privacy preservation. Heydari et al. [18] propose a federated optimization framework in which a scheduler coordinates with DTs to minimize transmission time or maximize the amount of uploaded data under energy constraints, without revealing the DTs’ private information. In our framework, the DTs of the IoT clusters reside on a common DT server, which may be a MEC server or a separate server. This enables coordinated specification of class-specific freshness thresholds and workload and delay bounds. Collaboration takes place among the MEC servers, which share observations to accelerate the identification of an effective preprocessing CPU allocation. A major role of the DT is to assist in resource allocation by using virtual representations to make decisions in the physical network. In our work, the DT does not directly select the resource allocation. Instead, it determines a set of feasible allocations based on task freshness requirements and specified workload and delay bounds. The MEC servers then collaboratively identify the best allocation within this set. Other studies use DTs to optimize scheduling and resource-allocation decisions directly. Bozkaya et al. [2] propose a genetic algorithmbased scheduler to minimize AoI and task completion time across industrial IoT devices and MEC servers. Huynh et al. [19] jointly optimize bandwidth, transmission power, taskoffloading fractions, and the processing rates of user devices and edge servers. They develop a centralized solution based on successive convex approximation, followed by a distributed solution. Beyond resource allocation, some studies also optimize how information is processed for DT synchronization [5], [8]–[10]. For example, Li et al. [5] jointly optimize semantic extraction, transmission power, and computational resources using a soft actor-critic algorithm to minimize average synchronization latency under deadline, energy, and resource constraints. Other studies use data compression [9] or semantic feature extraction [10]. Our work considers MEC-side preprocessing for data-volume reduction without restricting the framework to a specific application or preprocessing technique. For given

3

preprocessing operations, we allocate CPU resources across task classes with heterogeneous computational demands and freshness requirements. Uncertainty in operating conditions motivates learningbased resource allocation when accurate system or workload information is unavailable [20]–[23]. Wirth et al. [20] use a risk-aware bandit algorithm for radio-access and DT-placement selection under changing conditions. Ai et al. [23] use a multiarmed bandit strategy to allocate computing resources between model retraining and inference services in DT-assisted MEC. In our setting, the preprocessing workloads are stochastic with unknown distributions. MEC servers therefore learn allocation performance from observed delays and share observations to accelerate identification within a freshness-feasible set. This motivates the bandit learning approach discussed next. B. Bandit Learning and Best-Arm Identification Bandit learning is a sequential decision-making framework in which a learner, called an agent, selects actions, known as arms, with unknown reward distributions and updates its beliefs from observed rewards to guide subsequent selections. One objective is to minimize cumulative regret, which is the difference between the expected cumulative reward from consistently selecting an optimal arm and that from the selected arms [24], [25]. Alternatively, BAI focuses on recommending the best arm after an exploration phase [26], [27]. In the fixedconfidence setting, the objective is to identify an optimal arm with a predefined confidence, using as few observations as possible. The latter approach suits our problem, where CPU allocations are explored until the best feasible allocation is identified with the required confidence and then deployed until the network configuration changes. Linear bandits have a shared structure across arms, it expresses each arm’s expected reward as the inner product of a known feature vector and an unknown parameter vector. This structure allows observations from one arm to inform estimates of other arms, potentially reducing the exploration required for identification. Xu et al. [27] propose the linear gap-based exploration (LinGapE) algorithm for fixed-confidence linear BAI. The algorithm is adaptive, meaning that it uses reward observations and confidence bounds to select the next best arm to eventually identify the best arm in the least number of rounds, a more efficient algorithm compared to static approaches [28]. The DistLinGapE [14] extends this approach to a distributed setting in which multiple agents collaborate by sharing learning updates. Each agent updates its model estimates using local data, and then exchanges the updates with other agents in each global round creating a tradeoff between communication and local computation. In our problem, uncertainty in task generation and task sizes makes preprocessing delays unknown. We model the CPU-strategy selection as a fixed-confidence linear BAI problem, where each CPU allocation in the set of freshnessfeasible allocations determined by the DTs represents an arm. Each MEC server acts as an agent that selects and deploys an allocation and observes the resulting delay. We employ DistLinGapE to coordinate learning among MEC servers.

Servers observe local delays under the selected strategies and exchange learning updates. Under suitable conditions, sharing observations reduces learning rounds per agent compared with independent learning. III. S YSTEM M ODEL We first introduce the notation used in this work. Notation: We use boldface lowercase and uppercase letters to represent vectors and matrices, respectively. For a positive integer K, [K] denotes the set {1, . . . , K}. Furthermore, ∥x∥p denotes the p-norm of a vector x. For a symmetric positivedefinite matrix A, the weighted 2-norm is defined as ∥x∥A = √ ⊤ x Ax. We use P[·] to denote the probability of the event inside the brackets. We consider an IoT network consisting of a set C of C clusters, indexed by c ∈ [C], and a set M of M MEC servers, indexed by m ∈ [M ]. Each IoT cluster has a corresponding DT that virtually represents the physical system and is updated as new information becomes available. The DTs of all clusters are maintained at a common server, referred to as the DT server, which may be one of the MEC servers or a separate server with resources dedicated to DT operation. The system model is illustrated in Fig. 1.

Fig. 1: The system model.

A. Cluster Association and Homogeneous MEC Servers Each cluster is associated with one MEC server, and we assume that this association is based on proximity. Let Cm denote the set of clusters associated with server m ∈ [M ]. We consider applications where clusters generate large volumes of data, but only a subset of this data or information extracted from it is needed to update their DTs. Cluster data is therefore transmitted to the associated MEC server for preprocessing, and the results are forwarded to the DT server. Tasks are grouped into classes according to their preprocessing operation, input-data type, and freshness requirement. Operations may include compression, feature extraction, or semantic extraction, among others. Their parameters depend on the application and are not optimized in this work. Different

4

classes may have different input sizes and computational demands, and each MEC server may receive a random number of tasks from these classes in each time slot. Freshness is measured using the AoI, which is tracked separately for each cluster and associated task class, as detailed in Section IV. The MEC servers allocate CPU resources to preprocessing tasks using a feasible set of strategies determined by the DT server. This set accounts for class-specific AoI requirements and the prescribed workload, delay, and update-generation bounds, as detailed in the next section. A configuration, indexed by n, is defined by its task classes, AoI requirements, and the statistical characteristics of task generation and workloads. Let Jn and Kn denote the numbers of task classes and feasible CPU-allocation strategies, (n) respectively, and let ϵj denote the AoI requirement of class j. These quantities and the cluster associations remain fixed within a configuration. Task generation and workload statistics also remain stationary, although realized workloads vary and their distributions are unknown. A change in the defining characteristics initiates a new CPU-allocation problem and learning process. Here, we describe the system under a fixed configuration and omit its index when clear from the context, using j ∈ [J] and k ∈ [K] to index task classes and feasible strategies, respectively. Within each configuration, we assume that all MEC servers have the same computing capacity F > 0, measured in CPU cycles/s, dedicated to task preprocessing. The average total workload of each task class is also assumed to be the same across MEC servers, although realized workloads may differ across servers and time slots. These homogeneity assumptions allow the servers to collaboratively identify a common optimal CPU-allocation strategy, as described in Section V. With heterogeneous computing capacities or mean workloads, each MEC server could instead apply the framework independently, using its own feasible allocation set and local observations to identify its optimal CPU allocation. B. Task Generation and Computational Workload We consider time slots of duration T > 0 to coordinate task generation and CPU allocation. Slots are indexed by r = 0, 1, . . .. At the beginning of slot r, at time tG r = rT , each cluster may generate tasks from the predefined task classes and offloads them to its associated MEC server. Each task q generated in slot r contains data collected at its generation G time, tG q = tr . This timestamp is used to evaluate the freshness of the information incorporated into the DT. Let Qm,j,r be the set of tasks of class j generated in slot r and offloaded to MEC server m. Each task q ∈ Qm,j,r has an input size of γq bits and requires Wq CPU cycles for preprocessing, where Wq is a random variable with an unknown distribution. Its output size is νj γq bits, where νj ∈ (0, 1] is an application-defined reduction factor that remains fixed for each class within a configuration. The total input size and computational load of class j at server m in slot r are X X Γm,j,r = γq , Wm,j,r = Wq . (1) q∈Qm,j,r

q∈Qm,j,r

Both quantities are zero when Qm,j,r = ϕ. The generation rate and size of the computational workloads are random, and their underlying distributions are unknown. However, we assume known bounds on the total workload and input size per class, server, and time slot: 0 ≤ Γm,j,r ≤ Γj .

0 ≤ Wm,j,r ≤ W j ,

(2)

These bounds may follow, for example, from limits on the number of generated tasks, their input sizes, and the computational requirements of the tasks. The CPU-allocation strategy determines the processing rate assigned to each task class and thereby the tasks’ execution times. C. CPU-Allocation Strategies The MEC servers process the tasks using one of a finite set of K feasible CPU-allocation strategies given by {f (1) , . . . , f (K) }. Strategy k ∈ [K] specifies (k)

(k)

f (k) = [f1 , . . . , fJ ]⊤ ,

(k)

fj

> 0,

J X

(k)

fj

≤ F. (3)

j=1 (k)

Here, fj denotes the share of the server’s computing capacity allocated to class j, measured in Hz. We assume that tasks within a class are processed sequentially, while different classes are processed concurrently. The allocated CPU rates remain unchanged regardless of which classes are present. Unused reservations are not redistributed to other classes during the slot. Each server selects its strategy at the start of a slot, before observing the new task collection or workloads. The allocation remains fixed throughout the slot and may change only at the next slot boundary. Motivated by resource-management architectures that separate performance monitoring from allocation decisions [21], [22], we consider a monitoring component at each MEC server that reports the total processing delay resulting from the CPUstrategy selection, without access to each class’s execution time or computing capacity. D. Communication and Processing Delays For a task q ∈ Qm,j,r generated by cluster c, the uplink transmission rate to MEC server m is given by ! G P H (t ) q c,m q UL , (4) RqUL (tG q ) = Bq,m log2 1 + 2 Ic (tG q ) + IN UL where Bq,m is the allocated bandwidth, Pq is the transmission power, Hc,m is the channel power gain, and Ic is the interference power affecting the cluster c’s transmission to its 2 associated MEC receiver. The quantity IN is the noise power over the allocated bandwidth. UL UL UL The uplink delay is dUL ≥0 q = wq +γq /Rq , where wq is the waiting time for channel access and is zero when transmission can begin immediately. We assume that the uplink delay is bounded dUL ≤ bUL for every task q of class q j j. We assume a fixed upper bound u < T on the class uplink delay bounds: max bUL ≤ u < T. (5) j j∈[J]

5

Tasks of class j at MEC server m are processed in their order of arrival. Let qold denote the task immediately preceding task q. A task starts processing once it has arrived and the preceding task of the same class has completed processing. Assuming no unfinished workload carries over from the previous slot, the first task of each class starts processing upon arrival. The processing start and completion times of task q are given by o n Out,(k) , tStart,(k) = max tArr q q , tqold tOut,(k) = tStart,(k) + q q

Wq (k) fj

(6)

.

Here, tArr is the arrival time at the MEC server, Wq is the q (k) required computational workload in CPU cycles, and fj is the processing rate allocated to class j under strategy k. Under strategy k, the execution time of task q is dproc,(k) = q

Wq (k)

.

(7)

fj

The total execution time of all class-j tasks at server m in slot r is X Wm,j,r exec,(k) . (8) dm,j,r = dproc,(k) = q (k) fj q∈Qm,j,r This execution time is zero when no class-j tasks arrive at server m in slot r. Individual processing start and completion times follow (6). DT,(k) be the delay from completion of preprocessing Let dq until the result updates the DT. We assume that dDT,(k) ≤ bDT q j ,

(9)

for all class-j tasks and candidate allocation strategies k. This assumes sufficient forwarding and DT-server capacity to ensure the bound under the modeled traffic conditions. The bound includes the transmission delay νj γq /RqDT , where RqDT is the forwarding rate, and any additional scheduling delays. The task’s DT update time and end-to-end delay are tDT,(k) = tOut,(k) + dDT,(k) , q q q (k) DT,(k) G Dq = tq − tr

(10)   Wq DT,(k) Start,(k) Arr + d . = dUL + t − t + q q q q (k) fj Start,(k)

UL Here, tArr = tG −tArr is the waiting time q r +dq , and tq q at the MEC server before execution begins. All tasks generated in slot r arrive by tG r +u. The quantity u is used only for delay analysis and does not impose a common processing start time. With no unfinished workload from the preceding slot, tasks of each class are processed sequentially at the reserved CPU rate as they become available. Since all tasks have arrived by tG r + u, every class-j task satisfies

tOut,(k) ≤ tG q r +u+

Wm,j,r

.

(11)

+ bDT j .

(12)

(k)

fj

Consequently, Dq(k) ≤ Dj (k) := u +

Wj (k)

fj

The feasible strategy set defined in the next section ensures that all tasks are processed and their results update the DT by the end of their generation slot. Hence, no unfinished workload is carried between slots. IV. DT I NFORMATION F RESHNESS AND S TRATEGY U PDATE A DT state is updated whenever a task is processed and its result is incorporated into the DT. We assume that each configuration change is accompanied by a fresh initialization of all monitored DT states. Thus, each configuration starts a new optimization problem with zero initial age. A. Digital-Twin Information Freshness (n)

For configuration n, let Jc ⊆ [J (n) ] denote the task classes associated with cluster c. Each pair (c, j), with j ∈ (n) Jc , generates a sequence of updates to the corresponding DT (n) state, with freshness requirement ϵj > 0. Updates belonging to the same class share the same freshness requirement, while freshness is tracked separately for each cluster–class pair. Let tcfg n denote the beginning of configuration n. At this time, all monitored DT states are initialized with fresh measurements generated at tcfg n , such that Ac,j (tcfg n ) = 0,

∀c ∈ C, j ∈ Jc(n) .

(13)

(n)

Let Qc,j denote the tasks of class j generated by cluster c cfg during configuration n. For t ∈ [tcfg n , tn+1 ), the generation time of the freshest information incorporated into the DT is  n o (n) G DT Uc,j (t) = max {tcfg ≤ t . (14) n } ∪ tq : q ∈ Qc,j , tq where tcfg n represents the timestamp of the freshly initialized DT DT state. For a task generated in slot r, tG q = rT . Here, tq denotes the time at which the processed result updates the DT. The age of information is Ac,j (t) = t − Uc,j (t).

(15)

The age increases linearly over time and decreases when a result with a newer generation timestamp updates the DT. Results with equal or older timestamps do not reduce the age. The normalized age is ec,j (t) = Ac,j (t) . A (n) ϵj

(16)

B. Freshness-Feasible CPU Allocations A CPU-allocation strategy is freshness-feasible if it allows the DT to incorporate updates while keeping the AoI within the corresponding freshness thresholds. A simple approach would be to require the delay bound in (12) to satisfy Dj (k) ≤ ϵj . However, this condition only considers the delay of individual updates and does not account for the time between consecutive generations. In practice, an update may not be generated in every slot, and some updates may be lost. We therefore assume that each cluster generates at least one valid update for each associated class j in every hj consecutive slots that is successfully incorporated into the DT within the delay bound

6

Dj (k), where hj ≥ 1 is a known integer. This assumption holds for every candidate allocation strategy. With updates generated at slot boundaries, the maximum generation time of successfully delivered updates is hj T . This permits slots with no new updates and allows other updates to be lost, while bounding the time between generations of successfully delivered updates. Consider consecutive distinct generation slots rprev and r whose updates for cluster–class pair (c, j) are successfully incorporated into the DT. Let q be the first valid result from slot r incorporated into the DT. Provided that the freshest incorporated update before this event was generated in slot rprev , the age immediately before incorporation is
− Ac,j (tDT = (r−rprev )T +Dq , r−rprev ≤ hj , (17) q ) where Dq = tDT − tG q r is the actual end-to-end delay. The generation-slot gap is bounded by the assumption that every hj consecutive slots contain at least one generated update that is successfully delivered. Using the conservative delay bound in (12), we construct a common set of K freshness-feasible CPU-allocation strategies, indexed by k ∈ [K]. Every strategy satisfies Dj (k) ≤ T,

∀j ∈ [J], ∀k ∈ [K]. (18) The first condition ensures that preprocessing finishes within the generation slot, preventing unfinished preprocessing workload from carrying into the next slot, and that successfully delivered updates are incorporated by that slot’s end. The second condition ensures that the peak AoI remains within the freshness threshold despite slots with no generated updates or update losses, provided the successful-update assumption holds. For hj = 1, each cluster–class pair generates at least one successfully delivered update in every slot, and the freshness condition reduces to T + Dj (k) ≤ ϵj . The DT constructs the candidate strategies using workload upper bounds and freshness requirements, without knowledge of the workload means or distributions. Specifically, the feasibility conditions in (18) imply a minimum CPU allocation for each class:

round, including slots in which some task classes are absent. The set and its size may change between configurations. Under the stated initialization, update-generation, and delay assumptions, any sequence of feasible CPU-allocation strategies maintains Ac,j (t) ≤ ϵj for every monitored cluster–class pair throughout the configuration. This freshness guarantee is independent of the statistical guarantee of best-arm identification. Without a finite bound on hj , random task generation alone does not ensure a deterministic upper bound on AoI. V. P ROBLEM F ORMULATION Within configuration n, all K = Kn candidate CPU allocations satisfy the freshness requirements. However, these allocations distribute the computing capacity differently and may therefore produce different execution times for the same workload. Our objective is to identify a feasible allocation whose expected freshness-normalized total execution time is within a fixed tolerance of the minimum, with a predefined confidence and using as few observation slots as possible. Each observation round corresponds to one time slot. Under allocation k, the total execution time of class-j tasks at MEC server m in slot r is given by (6). We define the freshness-normalized execution time loss as

hj T + Dj (k) ≤ ϵj ,

Wj . (19) min{T, ϵj − hj T } − u − bDT j PJ min We require positive denominators and ≤ F. j=1 fj The remaining CPU capacity is distributed across classes to PJ (k) (k) construct feasible candidates, let vj ≥ 0 and j=1 vj = 1, then ! J X (k) (k) min min fj = fj + F − fℓ vj . (20) fjmin =

ℓ=1

The weights v (k) are selected to obtain diverse allocations across the feasible region without using expected losses. We assume P that at least one feasible strategy exists, i.e., K ≥ 1; if j fjmin = F , the construction yields a single allocation. The feasible set is constructed before each configuration becomes effective and remains fixed throughout identification and deployment. Every strategy is available in every learning

Lm,r (k) =

exec,(k) J X dm,j,r j=1

ϵj

=

J X Wm,j,r (k)

j=1

.

(21)

ϵj f j

Normalization by ϵj assigns a larger loss to a given execution time for classes with tighter freshness requirements. Within configuration n, we assume that the total class workloads have fixed conditional means. For every slot r in this configuration, (n)

E[Wm,j,r | Fr−1 , km,r ] = wm,j ,

m ∈ [M ], j ∈ [J], (22) where Fr−1 contains the information available before slot r, and km,r ∈ [K] is the index of the CPU-allocation strategy selected by MEC server m before observing its new workloads. To apply the distributed learning approach introduced later and satisfy its theoretical guarantees [14], we assume that these conditional means are common across MEC servers: (n)

(n)

wm,j = wj ,

m ∈ [M ], j ∈ [J].

(23)

This homogeneity assumption concerns the total mean workload of each class. It does not require identical workload realizations or distributions across servers. Under (22) and (23), the expected execution time loss is common to all MEC servers and is given by (n) ℓk =

(n) J X wj

.

(24)

kn∗ ∈ arg min ℓk .

(25)

(k) j=1 ϵj fj

The optimal feasible allocation is (n)

k∈[K]

Minimizing (24) selects the allocation with the smallest expected normalized execution time among these feasible candidates. This objective is different from the constraints in (18),

7

which ensure that the AoI of every monitored cluster–class pair remains within its freshness threshold under the stated bounds. We aim to identify and recommend an allocation k̂n whose expected normalized execution time loss is within εBAI of the minimum with confidence at least 1 − δ, using as few observation slots as possible. Specifically, the recommendation must satisfy h i (n) (n) P ℓk̂ − ℓk∗ > εBAI ≤ δ, (26) n

n

where εBAI = 0 corresponds to exact best-arm identification. This guarantee applies separately to each configuration. The per-agent failure probabilities δm are chosen such that δ = M δm . VI. L INEAR M ODEL FOR CPU A LLOCATION In this section, we derive an exact linear representation of the expected execution time loss using features determined by the CPU allocations and freshness requirements, and describe the information observed at each MEC server. We note that alternative feature representations may also be considered, with linearity adopted as a modeling approximation rather than an exact relation, but these are not considered in this work. A. Linear Relation For a configuration n, we define the feature vector of allocation k as #⊤ " 1 1 ,..., , (27) xk = (k) (k) ϵ1 f1 ϵJ fJ where the configuration index is omitted from the features and allocations for notational simplicity. The unknown configuration-dependent parameter is h i⊤ (n) (n) θ ∗n = − w1 , . . . , wJ . (28) Defining the expected reward as the negative expected execution time loss, we obtain (n)

µk

(n)

:= −ℓk

∗ = x⊤ k θn .

(29)

This relation is exact under the stated execution and workload assumptions. The features depend only on the predefined CPU allocations and freshness thresholds and remain fixed throughout the configuration. B. Scalar Feedback Following resource-management architectures that separate performance monitoring from allocation decisions [21], [22], we consider a monitoring component at each MEC server that normalizes task execution times by the class-specific freshness thresholds and sums them over each slot. At the end of the slot, this component reports the resulting scalar execution time loss to the allocation learner. We assume that the learner receives only this aggregate feedback, without access to execution times or realized workloads. For configuration n, let τn = rn T denote the start of its identification phase, where T is the slot duration and rn is

the first observation slot. We index consecutive observation rounds by s = 1, 2, . . ., with round s corresponding to slot r = rn +s−1 and beginning at time τn +(s−1)T . Each round therefore lasts one slot. Server m selects km,n,s = km,r ∈ [K] before observing the slot’s workload and receives the scalar reward Ym,n,s = −Lm,r (km,n,s ) (30) ∗ = x⊤ km,n,s θ n + ηm,n,s , where ηm,n,s = −

(n) J X Wm,j,r − wj (k

j=1

ϵj fj m,n,s

)

(31)

is the deviation of the realized workloads from their conditional means. Let kr = (k1,r , . . . , kM,r ) be the allocations selected by all MEC servers in slot r. We assume that the shared conditional (n) workload means remain wj when conditioned on Fr−1 and kr . Consequently, E[ηm,n,s | Fr−1 , kr ] = 0.

(32)

C. Observation and Parameter Bounds Since 0 ≤ Wm,j,r ≤ W j , define Lmax = max

k∈[K]

J X Wj (k) j=1 ϵj fj

.

(33)

Then Ym,n,s ∈ [−Lmax , 0]. Together with the conditional zeromean property in (32), Hoeffding’s lemma gives [24]  2 2 α σ Lmax αηm,n,s , α ∈ R. ,σ = E[e | Fr−1 , kr ] ≤ exp 2 2 (34) Thus, the observation noise is conditionally σ-sub-Gaussian. The workload bounds also imply the parameter-norm bound  1/2 J X 2 ∥θ ∗n ∥2 ≤ S :=  Wj . (35) j=1

For the finite candidate set, a feature-norm bound is  1/2 J X 1   . ∥xk ∥2 ≤ max ′ 2 (f (k ) )2 k′ ∈[K] ϵ j=1 j j

(36)

These bounds are determined for each configuration and remain fixed throughout its identification phase. They are used to construct the confidence bounds in the distributed identification method introduced next. VII. D ISTRIBUTED BANDIT L EARNING FOR CPU A LLOCATION In this section, we formulate MEC CPU-allocation selection as a fixed-confidence best-arm identification problem in linear bandits. The objective is to identify an allocation with the predefined accuracy and confidence using as few learning rounds as possible. Each MEC server can solve this problem independently using LinGapE [27], without requiring workload homogeneity across servers. Under the homogeneity

8

assumptions introduced above, the servers can instead share observations to identify a common allocation. We adopt DistLinGapE [14] to exploit this collaboration and accelerate identification. Each MEC server acts as an agent, and each feasible CPUallocation strategy k ∈ [K] corresponds to an arm. Each configuration defines a separate identification problem, with observation rounds corresponding to the learning rounds of that problem. If identification uses Nn consecutive observation slots, it ends at time τ̂n = τn + Nn T . Before identification begins, the DT determines the feasible candidate allocations using the prescribed freshness requirements and workload, delay, and update-generation bounds. During each learning round, every server selects an allocation, applies it to the arriving tasks, and observes the scalar reward defined in (30). Meanwhile, the processed results are forwarded to the DT. The reward from each round is available before the allocation decision for the following round. We describe the procedure within a fixed configuration and omit the configuration index n for readability. If server m were to learn independently, its local observations would give the following quantities at the beginning of learning round s, with the server index omitted for simplicity: As = λI +

s−1 X

xkz x⊤ kz ,

z=1

bs =

s−1 X

xkz Yz ,

(37)

z=1

where λ > 0 is the regularization parameter, I is the J × J identity matrix, kz is the arm selected in round z, and Yz is the corresponding observed reward. The regularized least-squares estimate of the parameter vector would be θ̂ s = A−1 s bs [27]. However, When the servers collaborate, each server has access to its local observations in addition to information collected by the other servers. A coordinator, located at either an MEC server or the DT server, aggregates and distributes this information. Algorithm 1 on the next page and the following description summarize the application of DistLinGapE to our CPUallocation problem. The detailed algorithm and theoretical analysis are provided in [14]. A. Local Estimation and Information Sharing Let sℓ denote the first learning round of communication round ℓ, with s1 = 1. A communication round comprises the learning rounds between two successive synchronizations. At the beginning of round s, server m stores the statistics of its observations collected since round sℓ : ∆Am,s =

s−1 X

∆bm,s =

s−1 X

Am,s = λI + Acoor,ℓ + ∆Am,s , bm,s = bcoor,ℓ + ∆bm,s ,

(39)

θ̂ m,s = A−1 m,s bm,s . Thus, each estimate is based on the total observations from all servers up to the latest synchronization, together with the server’s subsequent local observations. Communication and information sharing follows the eventtriggered rule of [14], which measures the reduction in the volume of the confidence ellipsoid for the estimate of θ ∗ since the beginning of the current communication round. When any server meets this condition, all servers transmit their unshared statistics to the coordinator. If communication is triggered after learning round s, the coordinator updates Acoor,ℓ+1 = Acoor,ℓ + bcoor,ℓ+1 = bcoor,ℓ +

M X

∆Am,s+1 ,

m=1 M X

(40)

∆bm,s+1 ,

m=1

where the increments include all observations collected since the previous synchronization until round s. The coordinator broadcasts its updates, and the servers clear their local increments. The next communication round starts at sℓ+1 = s + 1. B. Allocation Selection and Stopping Rule Each server selects CPU allocations sequentially to identify the best feasible allocation. In each learning round, it selects an allocation that helps distinguish its currently preferred allocation from a competing allocation whose performance remains uncertain. Under the noise and parameter assumptions of [14], define the confidence radius for the parameter estimate [14], [25] s   √ det(Am,s )1/2 + λS, (41) Cm,s = σ 2 log λJ/2 (δ/M ) where σ is the conditional sub-Gaussian noise parameter, S bounds ∥θ ∗ ∥2 , and δ is the fixed error probability. For allocations i and j, the estimated reward difference and its confidence radius are [14] ˆ m,s (i, j) = (xi − xj )⊤ θ̂ m,s , ∆ βm,s (i, j) = Cm,s ∥xi − xj ∥A−1 . m,s

(42)

Server m first identifies the allocation with the largest estimated reward:

xkm,z x⊤ km,z ,

z=sℓ

Each server combines these statistics with its unshared local observations:

(38)

im,s ∈ arg max x⊤ i θ̂ m,s .

xkm,z Ym,z .

z=sℓ

Here, km,z and Ym,z are the allocation selected by server m and its reward in round i, respectively. Let Acoor,ℓ and bcoor,ℓ denote the cumulative statistics shared at the beginning of communication round ℓ, initially both zero.

(43)

i∈[K]

For K ≥ 2, it then selects the most ambiguous allocation, i.e., the one with the largest upper confidence bound on its improvement over im,s : n o ˆ m,s (j, im,s ) + βm,s (j, im,s ) . (44) jm,s ∈ arg max ∆ j∈[K]\{im,s }

9

Algorithm 1 DistLinGapE for CPU-Allocation Identification: Summary of [14] 1: Input: {xk }K k=1 , εBAI , δ, λ, σ, S, and communication

threshold Dth . 2: Initialize shared and local statistics to zero; set ℓ = 1 and

VIII. N UMERICAL R ESULTS In this section, we show the performance of our proposed approach for identifying a CPU-allocation strategy with minimum expected execution delay normalized by freshness, while meeting the task classes’ freshness requirements.

s1 = 1. 3: for s = 1, 2, . . . do 4: Each server forms its parameter estimate using (39). 5: Each server computes im,s , jm,s , and Bm,s using (43)–

(45). if some server m has Bm,s ≤ εBAI then 7: Broadcast and return k̂ = im,s . 8: end if 9: Each server selects an allocation km,s using (47) or allocation-ratio tracking [14]. 10: Each server applies its allocation in the slot corresponding to round s, observes Ym,s , and updates its local statistics. 11: if any server meets the communication condition with threshold Dth [14] then 12: All servers transmit their unshared updates to the coordinator, which aggregates them using (40) and broadcasts the updated totals. 13: Servers clear local increments and reset the communication counters; set sℓ+1 = s + 1 and ℓ ← ℓ + 1. 14: end if 15: end for 6:

The corresponding bound is ˆ m,s (jm,s , im,s ) + βm,s (jm,s , im,s ). Bm,s = ∆

(45)

If Bm,s ≤ εBAI , server m reports im,s to the coordinator and identification terminates. Here, εBAI ≥ 0 is the permitted reward suboptimality. Under the assumptions of [14], the returned allocation k̂ satisfies   ⊤ ∗ ⊤ ∗ P max xk θ − xk̂ θ ≤ εBAI ≥ 1 − δ. (46) k∈[K]

If the stopping condition is not met, the server samples an allocation that helps distinguish im,s from jm,s . DistLinGapE supports greedy sampling and allocation-ratio tracking [14], [27]. The greedy rule selects km,s ∈ arg min ∥xim,s − xjm,s ∥(Am,s +xk x⊤ −1 . k )

(47)

k∈[K]

This rule selects the allocation that minimizes the uncertainty for the estimated reward difference between im,s and jm,s after observing its reward. Any candidate allocation may be selected, not only im,s and jm,s , since the linear model allows observations from other allocations to inform this reward difference. Alternatively, allocation-ratio tracking selects allocations according to target sampling proportions to distinguish between im,s and jm,s . The target proportions and tracking rule are given in [14], [27]. After identification, the coordinator distributes the recommended CPU allocation to the MEC servers for deployment.

A. Simulation Setup We consider a 600 m × 600 m region containing M = 4 MEC servers and C = 16 IoT clusters. The servers are located at (150, 150), (150, 450), (450, 150), and (450, 450) m. Four clusters are independently and uniformly placed within each server’s quadrant and associated with their nearest MEC server. Each server has a processing capacity of F = 8 GHz and processes tasks belonging to J = 8 classes. The slot duration is T = 200 ms. At the beginning of slot r, cluster c generates Nc,j,r = 1 + Bernoulli(pj ) tasks of class j. In the main experiment, we use p = [0.95, 0.90, 0.60, 0.50, 0.20, 0.20, 0.10, 0.10]⊤ . Each task has an independently and uniformly distributed size between 40 and 60 kbytes. The class-specific computational requirements are κ = [44, 40, 20, 16, 6, 5, 4, 3]⊤ cycles per input bit. Each cluster has an uplink rate of 30 Mbit/s, with the four clusters associated with a server served simultaneously. Uploading the maximum total input generated by one cluster requires 17.68 ms. We therefore use a common uplink delay bound of u = bUL = 20 ms. Each MEC server has a dedicated j 100 Mbit/s connection to the DT server, and preprocessing reduces the forwarded data volume to 10% of the input size. The combined forwarding and DT-incorporation delay is assumed to be bounded by bDT = 1 ms. j The class-specific freshness requirements are ϵ = [400, 400, 400, 400, 375, 375, 350, 350]⊤ ms. Since every cluster generates at least one task of each class in every slot, we use hj = 1. B. Candidate Strategies and Evaluation Each candidate set contains K = 30 distinct feasible CPUallocation strategies. We determine the minimum allocations from the workload upper bounds and freshness requirements using (19), and distribute the remaining capacity according to (20). Every set includes equal CPU allocation, fjeq = 1 GHz, and an allocation that distributes the residual capacity equally above the class-specific minima. For the main experiment, the remaining candidates comprise 14 allocations generated using symmetric Dirichlet(1, . . . , 1) weights and 14 using Dirichlet(3, . . . , 3) weights. The results are obtained over 100 algorithm runs. The suboptimality gap of candidate k is ∆k = µk⋆ −µk . The smallest gap, ∆min = mink̸=k⋆ ∆k , is the expected reward difference between the best and second-best candidates. In the main example, ∆min ≈ 0.0652. We also consider candidate sets with broader and smaller overall reward separation and minimum gaps in Figs 4 and 5. We compare DistLinGapE with equal CPU allocation, random allocation, independent LinGapE, shared uniform exploration, and an oracle. Equal CPU allocation always assigns

10

the same capacity to every class, whereas random allocation selects uniformly from the candidate set in each round. Independent LinGapE uses only local observations, and each server stops and deploys its recommendation independently. Shared uniform exploration cycles through all candidates equally, while using the same linear estimator, communication rule, and stopping criterion as DistLinGapE. The oracle knows the mean workloads and selects the candidate minimizing the expected freshness-normalized execution time loss. Each server receives one scalar observation per round, giving M observations across the network. The learning methods begin with 30 initialization rounds in which each server samples every candidate once. We use an identification tolerance of εBAI = 0.02, an overall error probability of δ = 0.2, and ridge regularization λ = 0.1. Learners observe only the scalar freshness-normalized execution time loss. After identification, each method deploys its recommended allocation for the remaining rounds.

Fig. 2: Mean freshness-normalized execution time loss for the main candidate set.

C. Freshness-Normalized Loss and CPU Execution Delay We first evaluate the freshness-normalized execution time loss averaged across MEC servers, M M J 1 X X Wm,j,r 1 X Lm,r (km,r ) = . M m=1 M m=1 j=1 ϵj f (km,r ) j

This dimensionless metric directly corresponds to the optimization objective. Fig. 2 shows that DistLinGapE reaches the oracle’s performance earlier than the other learning methods. It satisfies its stopping condition after an average of 1354 rounds, with stopping times ranging from 1260 to 1455 rounds across the 100 trials. Shared uniform exploration requires an average of 2932 rounds. Independent LinGapE requires 5127 rounds per server on average, while all four servers complete identification after an average of 5264 rounds. All three learning methods identify the exact best candidate in this experiment. Over the final 500 rounds, their mean normalized losses coincide with the oracle at approximately 0.7774, compared with 0.9627 for equal CPU allocation and 0.9776 for random allocation. The benefit of DistLinGapE is therefore earlier identification and deployment, rather than a different final allocation. To express the resulting performance in milliseconds, we also show the unnormalized mean class CPU execution time, M

J

1 X X Wm,j,r . M J m=1 j=1 f (km,r ) j

This metric averages class execution durations across servers and is distinct from per-task delay and end-to-end DT update delay. Minimizing the freshness-normalized loss does not generally minimize this unnormalized metric, since classes receive different weights through their freshness requirements. Here, the thresholds are relatively close, ranging from 350 to 400 ms, so the weights differ only modestly. We therefore report CPU execution times as an additional practical performance measure, while assessing optimality using the normalized objective.

Fig. 3: Mean class CPU execution time for the main candidate set.

Fig. 3 shows that the allocation selected by all three learning methods and the oracle achieves a mean execution time of approximately 38.34 ms over the final 500 rounds, compared with 47.74 ms for equal CPU allocation and 47.96 ms for random allocation. Thus, optimizing the normalized objective also reduces the unnormalized execution time in this experiment. We also evaluate allocation sets with broader or smaller overall reward separation and minimum gaps in Figs. 4 and 5. For these experiments, we use p = [0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1]⊤ and computation requirements κ = [32, 28, 24, 20, 16, 14, 12, 10]⊤ cycles per input bit. Each experiment includes ten candidate sets and ten independent workload realizations per set. The freshness thresholds remain unchanged. Fig. 4 considers candidates selected by geometric coverage from options generated using symmetric Dirichlet distributions with concentrations 0.5, 1, and 5. This produces larger reward gaps to many suboptimal candidates. DistLinGapE stops after an average of 68 rounds, compared with 133 rounds for shared uniform exploration and 221 rounds per server for independent

11

Fig. 4: Mean class CPU execution time for geometrically spread feasible candidates. LinGapE. All three methods identify the exact best candidate under the normalized objective in all trials. Fig. 5 considers candidates generated using symmetric Dirichlet distributions with concentrations 2 and 5, without separation filtering. Their best–second-best reward gaps range from approximately 6.43 × 10−5 to 0.0124. DistLinGapE requires an average of 1948 rounds. All 100 recommendations are εBAI -optimal for εBAI = 0.02, while 89 identify the exact best candidate. Within the 7000-round horizon, shared uniform exploration completes identification in 72 of the 100 trials. For independent LinGapE, all four servers finish in 40 of the 100 trials. Their late-stage execution times therefore include continued exploration in unfinished runs. These results show that identification complexity depends on the observed rewards, reward gaps, and the stopping conditions. DistLinGapE uses adaptive sampling and information sharing to reduce the exploration needed before deployment. Since its objective is identification rather than immediate delay minimization, it may select suboptimal allocations during exploration. D. Collaboration Speedup We evaluate the benefit of collaboration using the smallgap candidate sets and M ∈ {1, 2, 4, 8} agents. Each server serves four clusters, giving C = 4M . This preserves the peragent workload distribution while increasing the number of observations collected concurrently. For M = 1, the agent learns independently without communication. Each value of M is evaluated over 100 trials using the same candidate sets and fresh workload realizations. Fig. 6 shows that the mean number of identification rounds decreases from approximately 7323 for one agent to 3746, 1943, and 1052 for two, four, and eight agents, respectively. All runs satisfy the stopping condition and return an εBAI optimal candidate. We estimate the learning speedup, which is the ratio of mean number of samples per server in the independent case to the collaborative case [14]. Fig. 7 compares the measured speedup

Fig. 5: Mean class CPU execution time for candidate sets with small best–second-best reward gaps.

Fig. 6: Mean identification rounds versus the number of collaborating MEC servers for the small-gap candidate sets.

with the ideal speedup which is proportional to the number of collaborating servers. The observed speedups are 1.95, 3.77, and 6.96 for two, four, and eight CPUs, respectively. The deviation from ideal linear speedup may result from initialization, server’s sampling decisions, and delayed information sharing. Changing the communication threshold Dth controls the local computation and communication tradeoff, which can affect the speedup. IX. C ONCLUSION In this paper, we proposed an approach to reduce the DTupdate delays in IoT applications with large computational workloads, where the DT can be updated using a subset of the IoT data or some information extracted from it. We considered sensing tasks belonging to multiple classes, with different preprocessing demands and freshness requirements. The proposed approach relies on mutual support between the DT and MEC servers: the DT constructs freshness-feasible CPU allocations, while the MEC servers collaboratively apply DistLinGapE to identify an allocation with minimum expected freshness-normalized execution delay. The numerical results show the effectiveness of this approach, while showing that

12

Fig. 7: Learning speedup relative to a single independent agent, compared with ideal linear speedup. learning complexity depends on the candidate CPU allocations. Collaboration significantly reduces the number of learning rounds, achieving near-linear speedup in the evaluated scenarios. Future work will investigate collaboration among heterogeneous MEC servers, and a better utilization of the CPU resources for further delay reduction. R EFERENCES [1] R. Chai, J. Pan, X. Wu, and T. Qiu, “Cost-efficient age-of-information minimization in digital twins for internet of vehicles,” in IEEE INFOCOM 2026-IEEE Conference on Computer Communications, pp. 1–6, IEEE, 2026. [2] E. Bozkaya-Aras, “Digital twin-enabled age of information-aware scheduling for industrial IoT edge networks,” Pervasive and Mobile Computing, vol. 112, p. 102083, 2025. [3] M. R. Kabir, F. S. Shishir, S. Shomaji, and S. Ray, “Digital twins in healthcare IoT: A systematic review,” High-Confidence Computing, vol. 5, no. 3, p. 100340, 2025. [4] A. Alkhateeb, S. Jiang, and G. Charan, “Real-time digital twins: Vision and research directions for 6G and beyond,” IEEE communications magazine, vol. 61, no. 11, pp. 128–134, 2023. [5] B. Li, H. Cai, L. Liu, and Z. Fei, “Delay-aware digital twin synchronization in mobile edge networks with semantic communications,” IEEE Transactions on Vehicular Technology, vol. 74, no. 7, pp. 10974–10983, 2025. [6] K. Noroozi, T. D. Todd, D. Zhao, and G. Karakostas, “Age of information in digital twin migration,” IEEE Transactions on Vehicular Technology, 2025. [7] X. Zhou, Y. Peng, T. Lan, Z. Zhang, B. Tang, and X. Guan, “Digital twin empowered task offloading for mobile-edge computing in 6G internet of vehicles,” IEEE Internet of Things Journal, vol. 12, no. 15, pp. 29189– 29202, 2025. [8] Y. Sanjalawe, S. Fraihat, S. Al-E’mari, and S. N. Makhadmeh, “Bridging the gap: A comprehensive survey on AI-driven digital twin networks for future wireless systems,” Journal of King Saud University Computer and Information Sciences, vol. 38, no. 3, p. 113, 2026. [9] M. Krantzik, A. Klein, and L. Xiang, “Optimizing sensor data compression and digital twin synchronization via a Stackelberg game,” in 2025 IEEE 36th International Symposium on Personal, Indoor and Mobile Radio Communications (PIMRC), pp. 1–6, IEEE, 2025. [10] J. Tang, J. Nie, J. Bai, J. Xu, S. Li, Y. Zhang, and Y. Yuan, “UAVassisted digital-twin synchronization with tiny-machine-learning-based semantic communications,” IEEE Internet of Things Journal, vol. 11, no. 17, pp. 28437–28451, 2024. [11] S.-S. Tzeng, Y.-J. Lin, and S.-W. Wang, “Age of information in IoT devices with integrated heterogeneous sensors under slotted ALOHA,” IEEE Sensors Journal, vol. 25, no. 11, pp. 20842–20853, 2025. [12] T. Park, W. Saad, and B. Zhou, “Centralized and distributed age of information minimization with nonlinear aging functions in the internet of things,” IEEE Internet of Things Journal, vol. 8, no. 10, pp. 8437– 8455, 2020.

[13] H. Choi, H. Yu, and E. Lee, “Latency-classification-based deadlineaware task offloading algorithm in mobile edge computing environments,” Applied Sciences, vol. 9, no. 21, p. 4696, 2019. [14] M. Yahya, A. Sezgin, and S. Maghsudi, “Service placement in small cell networks using distributed best arm identification in linear bandits,” IEEE Transactions on Mobile Computing, 2026. [15] J. Li, J. Wang, Q. Chen, Y. Li, and A. Y. Zomaya, “Digital twin-enabled service satisfaction enhancement in edge computing,” in IEEE INFOCOM 2023-IEEE Conference on Computer Communications, pp. 1–10, IEEE, 2023. [16] Y. Guo, Y. Fu, Y. Zhang, and T. Q. S. Quek, “Age-of-information and energy optimization in digital twin edge networks,” in GLOBECOM 2024 - 2024 IEEE Global Communications Conference, p. 3194–3200, IEEE, Dec. 2024. [17] J. Li, S. Guo, W. Liang, J. Wang, Q. Chen, Z. Hong, Z. Xu, W. Xu, and B. Xiao, “AoI-aware service provisioning in edge computing for digital twin network slicing requests,” IEEE Transactions on Mobile Computing, vol. 23, no. 12, pp. 14607–14621, 2024. [18] M. Heydari, T. D. Todd, D. Zhao, and G. Karakostas, “Channel sharing using digital twins and federated optimization,” IEEE Internet of Things Journal, 2026. [19] D. Van Huynh, V.-D. Nguyen, S. R. Khosravirad, G. K. Karagiannidis, and T. Q. Duong, “Distributed communication and computation resource management for digital twin-aided edge computing with short-packet communications,” IEEE Journal on Selected Areas in Communications, vol. 41, no. 10, pp. 3008–3021, 2023. [20] M. Wirth, A. Ortiz, and A. Klein, “Risk-aware learning for digital twin placement in non-stationary hierarchical edge computing,” in 2026 IEEE Wireless Communications and Networking Conference (WCNC), pp. 1– 6, IEEE, 2026. [21] R. Bhardwaj, K. Kandasamy, A. Biswal, W. Guo, B. Hindman, J. Gonzalez, M. Jordan, and I. Stoica, “Cilantro: Performance-aware resource allocation for general objectives via online feedback,” in 17th USENIX Symposium on Operating Systems Design and Implementation (OSDI 23), pp. 623–643, 2023. [22] Z. Wang, P. Li, C.-J. M. Liang, F. Wu, and F. Y. Yan, “Autothrottle: A practical bi-level approach to resource management for SLO-targeted microservices,” in 21st USENIX Symposium on Networked Systems Design and Implementation (NSDI 24), pp. 149–165, 2024. [23] X. Ai, W. Liang, and C. Liu, “Joint optimization of model retraining and inference services in DT-assisted edge computing,” IEEE Transactions on Networking, vol. 34, pp. 1804–1819, 2025. [24] T. Lattimore and C. Szepesvári, Bandit algorithms. Cambridge University Press, 2020. [25] Y. Abbasi-Yadkori, D. Pál, and C. Szepesvári, “Improved algorithms for linear stochastic bandits,” Advances in Neural Inf. Proc. Sys., vol. 24, pp. 1–9, 2011. [26] J.-Y. Audibert and S. Bubeck, “Best arm identification in multi-armed bandits,” in COLT-23th Conference on learning theory-2010, pp. 13–p, 2010. [27] L. Xu, J. Honda, and M. Sugiyama, “A fully adaptive algorithm for pure exploration in linear bandits,” in International Conference on Artificial Intelligence and Statistics, pp. 843–851, PMLR, 2018. [28] M. Soare, A. Lazaric, and R. Munos, “Best-arm identification in linear bandits,” Advances in Neural Inf. Proc. Sys., vol. 27, 2014.

Related documents

• OpenDT: Exploring Datacenter Performance and Sustainability with a Self-Calibrating Digital Twin#10309
• Smart Adaptive Computing Across the Continuum: LLMs in IoT-Edge-Cloud Resource Management#987105
• Logistics equipment condition monitoring and prediction based on digital twin and machine learning.#123135
• SMCC-Empowered Digital Twins for Sensorless Monitoring in Large-Scale AI-Driven IoT Systems#986934
• Can AI Agents Detect and Repair Artifact Drift in Network Experiments?#996666