Clock-Free Stochastic Scheduling for Real-Time Synchronized Content Delivery

1

Clock-Free Stochastic Scheduling for Real-Time Synchronized Content Delivery

arXiv:2610.15114v1 [cs.NI] 10 Oct 2026

Xuan Wang, Xiaoyi Wu, Ying Sun, Atilla Eryilmaz, Senior Member, IEEE, and Bin Li, Senior Member, IEEE

Abstract—Real-time synchronized content delivery is critical for applications such as cloud gaming, collaborative mixed reality, and live streaming, where a server must ensure that a group of users perceives the same content simultaneously for each delivery. Due to heterogeneous and unpredictable network delays, ensuring synchronization is highly challenging. We propose a clock-free scheduling framework that introduces latency compensation to control the server’s delivery time for each user, aiming to maximize synchronization performance (i.e., minimizing the gap between the maximum and minimum latencies) while maintaining a low overall latency cost. Unlike prior work requiring synchronized clocks or client-side timestamps, our approach uses only acknowledgment feedback, enabling flexible deployment across diverse environments. We formulate the problem as a convex stochastic optimization with a non-smooth objective. To solve the problem, we employ the stochastic proximal point (SPP) algorithm that updates the delay compensation, using only the previous latency samples, rather than the latency distribution. By exploiting the subproblem structure, we apply ADMM to enable efficient updates with per-iteration complexity of at most O(N log N ), where N is the √ number of users. We establish a convergence rate of O(1/ K), where K is the number of content deliveries for transmission. The framework is further extended to handle transmission failures, where packet loss results in successful delivery to only a subset of users. Finally, simulations using both synthetic and real-world latency traces demonstrate the consistent superiority of our algorithm against baseline methods. Index Terms—Collaborative Content Delivery, Synchronized Scheduling, Stochastic Optimization.

I. I NTRODUCTION E consider the problem of real-time synchronized scheduling for collaborative content delivery, motivated by applications such as cloud gaming [1], collaborative mixed reality [2], e-commerce live streaming [3], and Industrial Internet of things (IIoT) system [4]. For example, in cloud gaming, a cloud server renders high-quality images and must deliver them simultaneously to a group of players to ensure a smooth gaming experience. In collaborative mixed reality (MR) based firefighter training, the server runs fire accident simulations and delivers high-quality virtual fire visuals to the MR headsets of a group of firefighters depending on their location and perspective. It is essential that all firefighters see the same status of virtual fire accidents simultaneously to facilitate effective collaboration. In e-commerce live streaming, the server must ensure that all users see the same live

W

This work was supported in part by the ARO Grant W911NF-24-1-0103, NSF AI Institute (AI-EDGE) 2112471, CNS-NeTS-2106679, ECCS-CSCS2619078. Xuan Wang, Xiaoyi Wu, Ying Sun, and Bin Li are with the Department of Electrical Engineering, The Pennsylvania State University, University Park, PA, USA. Atilla Eryilmaz is with the Department of Electrical and Computer Engineering, The Ohio State University, Columbus, OH, USA.

status to avoid chaos during limited-time promotional offers. In autonomous driving, a high-speed vehicle must simultaneously broadcast its real-time statuses, such as location and speed, to neighboring vehicles for collision prevention and overall safe navigation. For IIoT systems, concurrent commands from the control center to distributed devices are crucial for cohesive collaboration. In all these applications, synchronized content reception for a group of users is crucial. However, fluctuating network transmission rates naturally cause asynchronous content reception for each user, leading to non-smooth collaborative experiences. One possible solution is for the server to deliver the content with precise display times for users through an efficient network time protocol (NTP) [5] or precision time protocol (PTP) [6], which provides synchronized clock information. However, this strategy faces significant practical limitations. First, NTP may experience calibration errors of up to 100 ms in dynamic network environments, while the high precision of PTP requires specialized hardware typically unavailable on consumer devices [7]. Moreover, the content in the above collaborative applications is far more complex than simple commands and text, involving substantial amounts of data. For instance, a high-resolution rendered gaming image can exceed 5MB [8]. In such a case, accurately estimating content delivery time is challenging due to fluctuating network transmission rates. Consequently, NTP and PTP, which merely provide synchronized clock information, fail to ensure synchronization among a group of users for each content delivery. Therefore, the efficient design of real-time synchronized scheduling for collaborative content delivery is essential. The majority of existing content delivery methods aim to minimize transmission latency. Some researchers use multipath routing to prioritize scheduling data delivery designed for large-scale networks with multiple hops [9]. In multiuser video streaming applications, most algorithms adaptively adjust the bitrate of images or the buffer size according to the alteration of latency, which is at the cost of image quality and thus leads to a fluctuating user experience [10] [11] [12]. However, these methods do not address the synchronization problem, which is particularly critical for cloud gaming, collaborative MR, and e-commerce live streaming. Many works (e.g., [5], [6]) studied different types of clock synchronization in the field of network, such as NTP and PTP, but typically these kinds of synchronization are achieved through frequent calibration of the target clock by minimizing the observed clock deviation from the time reference. Subsequently, some immersive applications (e.g., [13]) began addressing the synchronization problem, as network synchronization significantly impacts the consistency of views

2

in a shared scene, thereby influencing the users’ sense of presence. However, most of these applications still rely on the classical NTP approach. Although existing studies (e.g., [14], [15]) employed network latency compensation to ensure user synchronization, they used heuristic methods to manipulate stochastic network latency to achieve synchronization, rather than providing a theoretical guarantee of their approach. In this paper, we propose a clock-free scheduling framework that introduces latency compensation to control the server’s delivery time for each user, enhancing synchronization performance by minimizing the gap between maximum and minimum latencies. The framework uses delivery feedback from users to estimate user-specific latency, allowing synchronization to be handled at the server side with minimal client-side timing requirements. However, this approach also increases the latency for each user to receive and view the content. Our goal is to determine the optimal latency compensation that maximizes synchronization performance while keeping the overall latency cost as low as possible. Due to the randomness of latency, our formulated problem is a stochastic optimization problem. Given that we can collect latency samples from each user based on previous content deliveries, our aim is to develop an efficient, low-complexity stochastic optimization method with fast convergence. However, our objective function includes a non-smooth component arising from the difference between the maximum and minimum latencies after latency compensation. To address this, we employ the stochastic proximal point (SPP) method for each content delivery using the previous latency samples collected from each user, leading to non-smooth deterministic subproblems. Then, instead of directly using a general-purposed solver such as SDPT3 and SeDuMi, we explore the inherent problem structure and utilize the alternating direction method of multipliers (ADMM) to decompose the computation, resulting in a computational complexity of at most O(N log N ) per iteration. We further demonstrate that our √proposed algorithm achieves a convergence rate of O(1/ K) and its adaptability in handling packet drops in realistic network environments. Our main contributions are summarized as follows: • We formulate the real-time synchronized scheduling problem as a stochastic convex optimization task, aiming at minimizing both the maximum-minimum latency gap and the overall latency cost by controlling latency compensation. Unlike prior work relying on synchronized clocks, our approach is clock-free and uses only acknowledgment feedback naturally available in systems such as cloud gaming and MR, requiring no specialized hardware or client-side timestamps, enabling practical deployment in diverse network environments. • We propose the Synchronized Content Scheduling (SCS) algorithm based on the SPP method, which efficiently uses only previous latency samples. By exploiting the subproblem structure and applying ADMM to decompose computations, the algorithm achieves a lightweight O(N log N ) scalar operations per iteration. We further extend the framework to handle packet-dropping scenarios by updating only the subset of acknowledged users, thereby ensuring robust synchronization under unreliable network conditions. √ • We establish a convergence rate of O(1/ K) for the

proposed algorithm, and validate its performance through extensive simulations using both synthetic and real-world latency traces. Extensive experimental results demonstrate the superiority of the proposed algorithm over baseline methods in synchronization performance and computational efficiency. Note on Notation: We use boldface to denote vectors and script font to denote sets. The symbol ⪰ represents the component-wise “greater than or equal to” operation. The ℓ2 norm of a vector x is denoted by ∥x∥. Let H be an index set, then we denote ∥x∥ H as the ℓ2 norm restricted P 2 to the set H, i.e. ∥x∥2H ≜ n∈H (x(n)) . Let x denote the vector of the mean of the elements in the vector x. We use [N ] to denote the set of {1, 2, . . . , N }. Let RN and Z+ denote the N −dimensional Euclidean space and the set of positive integers, respectively. We use O(·) and Ω(·) to denote asymptotic upper and lower bounds, respectively. Specifically, for functions f (x) and g(x) > 0, we denote f (x) = O(g(x)) if there exist constants C > 0 and x0 such that |f (x)| ≤ Cg(x) for all x ≥ x0 , and f (x) = Ω(g(x)) if there exist constants C > 0 and x0 such that |f (x)| ≥ Cg(x) for all x ≥ x0 . II. R ELATED W ORK In this section, we provide an overview of key topics closely related to our work: collaborative content delivery, synchronization in networking, and stochastic network scheduling. Collaborative content delivery: Collaborative content delivery underpins a wide range of applications, such as cloud gaming, video streaming, and VR, all of which require tight inter-user synchronization to maintain quality of experience (QoE). In online games, for instance, latencies exceeding 20 to 30ms can significantly degrade the user experience [16]. Li et al. [17] propose a real-time lag compensation mechanism for cloud gaming that equalizes uplink and downlink delays, improving fairness and QoE in multiplayer FPS games. Kassir et al. [18] propose a joint update rate adaptation algorithm for multiplayer cloud gaming that dynamically adjusts player update rates to mitigate the impact of network delays. In addition, real-time content delivery also plays a critical role in Video streaming and VR applications. Gao et al. [10] propose a cooperative mobile video streaming framework that optimizes bitrate adaptation and downloading using a Lyapunovbased algorithm to enhance QoE in multi-user environments. Park et al. [19] optimize end-to-end latency in wireless VR social interactions by allocating bandwidth, thereby addressing synchronization challenges arising from disparities between virtual and physical users. While these studies offer valuable strategies for improving QoE, like reducing latency and enhancing video quality, they mainly target individual user performance and often overlook the stringent synchronization demands for simultaneous content reception across users. Even when synchronization is considered, most approaches rely on heuristic clock alignment without theoretical guarantees on synchronization performance. This critical gap highlights the need for provably efficient and theoretically grounded algorithms for real-time synchronization in collaborative content delivery applications. Synchronization in networking: Clock synchronization is crucial for accurate timekeeping in distributed systems.

3

Numerous studies (e.g., [5], [6]) have explored various synchronization techniques such as NTP and PTP, which operate by periodically calibrating local clocks against a reference source. Software-based NTP is vulnerable to path asymmetry and jitter, which can result in calibration errors of up to 100 ms in wireless or mobile environments. PTP improves accuracy through hardware time-stamping at network interface controllers, but it requires specialized hardware that is typically absent in commodity systems. Other techniques aim to enhance accuracy and robustness. Synchronous Ethernet (SyncE) [20], for example, embeds timing information at the physical layer to reduce packet delay variation, but demands SyncE-compatible hardware with built-in clock recovery, making it incompatible with standard Ethernet infrastructure. Overall, existing methods either struggle under dynamic network conditions or rely on dedicated hardware for precision. To address these challenges, we propose a latency compensation technique that is efficient, easy to deploy, and robust against varying network conditions, offering a practical solution to high-precision synchronization. Stochastic network scheduling: Stochastic network scheduling has been extensively studied. Jiang and Walrand [21] propose the Deficit Maximum Weight algorithm for utility-maximizing and stable scheduling in stochastic processing networks. More recent research tailors scheduling to emerging applications and metrics. Li et al. [22] develop an algorithm that equalizes packet completion times across multiple nodes. In distributed learning, Yang et al. [23] analyze how wireless scheduling impacts the convergence rate of federated learning. While the focus of stochastic network scheduling is shifting from traditional metrics, such as throughput and delay, towards data freshness with the Age of Information [24]– [27], the “synchrony” in these pioneering works is limited to aligning data freshness. These approaches fail to address the stricter temporal alignment of content delivery essential for real-time applications, leaving application-aware synchronization largely under-explored. III. S YSTEM M ODEL We consider the synchronized content transmission from a single server to N users, whereby the server aims to deliver consecutive content to all users simultaneously so that they receive and view the content at the same time. Let dk (n) denote the latency experienced by user n to receive and view the k th content. In practice, dk (n) is measured as the elapsed time between sending the content packet and receiving the corresponding acknowledgment (ACK). Since the ACK (a few bytes) is much smaller than the content payload, this RTT-like measurement serves as a practical proxy for the downlink delivery latency, although its accuracy may be affected by uplink/downlink asymmetry and ACK jitter. We model dk (n) as a random variable to account for the fluctuating transmission rates, varying content information, and random ACK-path variations. For example, in video streaming, the frame size changes over time, as shown in Fig. 2 in [28]. We assume dk (n) is within a finite duration τmax . For example, the finite duration (or maximum tolerable latency)

(a) Before latency compensation

(b) After latency compensation

Fig. 1: Content delivery: incorporating latency compensation enhances synchronization for all users, though it increases latency for individual users.

in VR streaming is typically within 20ms [16]. We assume that {dk (n), ∀n = 1, 2, . . . , N, ∀k = 1, 2, . . .} are identically and independently distributed (i.i.d.) across delivered content for each user and independently distributed across users1 . For each content k, the latency experienced by each user varies. Thus, we employ latency compensation for each user to postpone their transmission and ensure synchronization across all users for each content delivery. Let xk (n) denote the latency compensation of user n for delivering the k th content, i.e., the server delivers the k th content to user n after xk (n) time units. Here, we note that xk (n) ≥ 0, ∀n, ∀k, since we can only delay the transmission, not send it in advance. N Let dk ≜ (dk (n))N n=1 and xk ≜ (xk (n))n=1 represent the vectors for each user’s latency and latency compensation when delivering the k th content, respectively. While latency compensation can potentially improve synchronization among all users, it increases the latency for each user to receive and view the content. As such, we need to carefully manage the latency compensation to maximize synchronization among all users for each content delivery, i.e., minimizing the gap between maximum and minimum latencies after latency compensation while keeping the overall user-perceived latency as small as possible. Fig. 1 illustrates the scenarios before and after applying latency compensation. It is evident from Fig. 1 that adding latency compensation enhances synchronization among all users, albeit at the cost of increased latency for each user. Since dk is i.i.d. across delivered content, we omit the index k for simplicity. As such, we aim to solve the following optimization problem: min F (x) ≜ Ed [f (x; d)] , x⪰0

(1)

where the instantaneous synchronization performance f (x; d) ≜ max[x(n) + d(n)] − min[x(n) + d(n)] n

n

+w

N X

(cn (x(n) + d(n))),

n=1

and w ≥ 0 is some non-negative weighting parameter that balances the synchronization and delay performance. The cost 1 We note that this assumption aids in the development and analysis of our algorithm. However, as demonstrated through simulations with real-world data in Section VIII, our proposed algorithm does not depend on this assumption.

4

where the latency of delivering content to each user follows the distribution described below. P[d(n) = 1] = pn and P[d(n) = 0.1] = qn , ∀n = 1, 2,

(a) Objective value

(b) Improvement ratio

Fig. 2: Impact of weighting parameter w.

function cn (·) : R+ → R+ represents the latency-induced cost perceived by user n. It is assumed to be smooth, nonnegative, and convex2 , reflecting increasing user dissatisfaction with higher latency. Typical examples of such cost functions include linear and quadratic forms such as cn (x(n) + d(n)) = x(n)+d(n) or cn (x(n)+d(n)) = (x(n)+d(n))2 , as discussed in [29]. We can show that both f ( · ; d) and F are proper3 and convex in x, as demonstrated in Appendix A. This ensures the existence of the optimal solution to the optimization problem (1). Let x⋆ ≜ (x⋆ (n))N n=1 be the optimal solution to the above convex optimization problem, i.e., x⋆ ∈ argminx⪰0 F (x). Directly solving the optimization problem (1) requires knowledge of the latency distributions for all users, which is typically unavailable in practice. Instead, prior to each content delivery, we can collect latency samples from each user based on the previous content delivery. This motivates us to develop an efficient stochastic optimization method with fast convergence. Here, we emphasize that synchronization performance is measured by the discrepancy between the maximum and minimum latencies after latency compensation. This max-min criterion directly controls the worst inter-user latency gap, unlike variance-type metrics which measure average dispersion around the mean. For example, if one user has compensated latency x(1) + d(1) = M and all others have x(n) + d(n) = 0, then the max-min discrepancy is M , while the variance M 2 (N − 1)/N 2 decreases as the number of users increases. However, our stricter synchronization requirement renders the objective function non-smooth4 , presenting considerable challenges in designing fast algorithms. Despite this, we explore the inherent problem structure to accelerate the computation, enabling real-time scheduling in practice. Next, we provide a numerical example demonstrating the benefits of incorporating latency compensation. IV. A M OTIVATING E XAMPLE In this section, we consider a simple (albeit hypothetical) numerical example to illustrate the advantages of incorporating latency compensation, given the latency distributions of all users. Specifically, we consider a scenario with two users, 2 A function f is called convex if f (λx+(1−λ)y) ≤ λf (x)+(1−λ)f (y) holds for any vectors x and y within its domain and any parameter λ ∈ [0, 1]. 3 A function f is called proper if it never takes the value −∞ and has at least one finite value. 4 A function is non-smooth if it includes non-differentiable components, such as the maximum and minimum operations in our objective function.

where 0 ≤ pn ≤ 1, ∀n = 1, 2, and pn + qn = 1. The cost function is defined as cn (x(n) + d(n)) ≜ (x(n) + d(n))2 . Hence, the objective function in (1) can be expressed as follows:

F (x) = p1 p2 |x1 − x2 | + w (x1 + 1)2 + (x2 + 1)2

+p1 q2 |x1 − x2 + 0.9| + w (x1 + 1)2 + (x2 + 0.1)2

+q1 p2 |x1 − x2 − 0.9| + w (x1 + 0.1)2 + (x2 + 1)2

+q1 q2 |x1 − x2 | + w (x1 + 0.1)2 + (x2 + 0.1)2 . (2) We can obtain the optimal latency compensation based on parameters p1 , p2 , and w using an optimization solver, which serves as the benchmark. We compare it with a heuristic that aligns users according to their average compensated delivery times while retaining the latency-cost term. Specifically, it solves the deterministic problem: min f (x; E[d]). x⪰0

(3)

Here, E[d] can be estimated from observed latency samples. To evaluate the synchronization performance, we define the improvement ratio as: Improvement Ratio(x) =

F (0) − F (x) , F (0)

(4)

where F (x) is the objective function value under a given latency compensation vector x, and F (0) denotes the baseline value with no latency compensation applied. This metric measures the relative reduction in our synchronization objective function, F (·), compared to a baseline with no compensation. Therefore, a higher improvement ratio indicates a more significant enhancement in synchronization performance. Fig. 2 illustrates the performance of different latency compensation methods (i.e., optimal latency compensation, heuristic latency compensation, and no latency compensation) for p1 = 0.1 (q1 = 0.9) and p2 = 0.8 (q2 = 0.2). We can see from Fig. 2a that the optimal latency compensation method results in the lowest objective function value. In contrast, the heuristic latency compensation performs even worse than no latency compensation when the weighting parameter w is relatively large (e.g., w = 0.4). Fig. 2b further demonstrates the impact of the weighting parameter w on the improvement ratio compared to no latency compensation. We can observe from Fig. 2b that the improvement ratio of optimal latency compensation can reach up to around 60%, outperforming the heuristic approach, particularly when the weighting parameter is small (e.g., less than 0.2). Moreover, the improvement ratio decreases as the weighting parameter w increases. This is because a large w places more emphasis on latency, and adding the latency compensation increases the latency for each user. Fig. 3 illustrates the impact of latency heterogeneity when the weighting parameter w = 0.2. Fig. 3 shows that the improvement ratio is substantial, reaching up to 63.7%, particularly when there is a significant disparity in user latency (e.g., a large difference between p1 and p2 ).

5

some initial value x0 ⪰ 0 for the latency compensation at k = 0, we construct the SPP update rule:  xk+1 = argmin f x; dk x⪰0

Fig. 3: Impact of latency disparity when w = 0.2.

This simple example demonstrates the substantial performance improvement achieved by optimally selecting latency compensation, particularly when synchronization performance is critical (e.g., with a small weighting parameter) or significant latency disparities across users. However, this requires knowledge of the latency distribution for all users, which is typically unavailable in practice. In the next section, we will develop a stochastic optimization algorithm that only requires latency samples from each user for each content delivery and exhibits fast convergence.

V. S YNCHRONIZED S CHEDULING A LGORITHM D ESIGN In this section, we develop a real-time synchronized scheduling algorithm for collaborative content delivery, which efficiently solves the stochastic optimization problem (1) using latency measurement samples from each user for each content delivery. The proposed algorithm integrates the classic stochastic proximal point (SPP) method (see [30], [31]) and the alternating direction method of multipliers (ADMM) (see [32, Ch. 15]), and the inherent problem structure to accelerate computation. Next, we discuss the motivation for employing SPP and ADMM methods to solve problem (1). Note that our objective function includes a non-smooth component resulting from the difference between the maximum and minimum latencies after latency compensation (see (2) for an example in the case with two users). As such, it is natural to employ the stochastic subgradient method. However, it is known that even in the deterministic setting, subgradient methods can suffer from numerical instabilities such as being sensitive to the step size choice and not being a descent method (i.e., the objective can increase between iterations). On the contrary, proximal point methods are generally more stable than gradient iterations and, in the deterministic setting, converge for a wide range of step size choices [33]. Motivated by these numerical advantages, we apply its stochastic version as the framework for our algorithm design. Recall that dk is the random latency experienced by the users when the server delivers the k th content. Starting with

 1 2 + ∥x − xk ∥ , 2γk

(5)

where the step size γk > 0 will be specified in Proposition 2. The subproblem (5) is deterministic, strongly convex, and has a unique solution. A straightforward solution is to directly solve it using a general-purposed solver such as SDPT3 [34] and SeDuMi. However, as the complexity of these solvers generally scales polynomially with the problem dimension, the latency generated by solving the problem can easily exceed 6 ms for a moderate user number N , rendering the compensation control meaningless. As such, there is a pressing need for a low computational complexity algorithm for (5), which will be developed next. As the first step, we apply a change of variable and define y ≜ x + dk and yk ≜ xk + dk . Substituting the expression of f into (5), we can equivalently rewrite it as  yk+1 = argmin y⪰dk

max y(n) − min y(n) n∈[N ]

+w

N X

n∈[N ]

cn (y(n)) +

n=1

 1 ∥y − yk ∥2 . 2γk

(6)

Denote fe(y) ≜ maxn∈[N ] y(n) − minn∈[N ] y(n). The difficulty in solving (6) is the co-existence of the nonsmooth term fe and the element-wise inequality constraint y ⪰ dk . This structure motivates applying the ADMM algorithm to simplify the computation by decoupling the two terms and just optimizing with respect to (w.r.t.) one of them per update.

A. ADMM for Solving (6) Introducing auxiliary vector z, we rewrite (6) as (

N X

1 ∥y − yk ∥2 min fe(z) + w cn (y(n)) + y,z 2γ k n=1 s.t.

z = y,

) (7)

y ⪰ dk .

Let λ ∈ RN be the Lagrange multiplier vector corresponding to the equality constraint. After relaxing the equality, the augmented Lagrangian is given by:

Lρ (y, z, λ) ≜ fe(z) + w

N X n=1

cn (y(n)) +

1 ∥y − yk ∥2 2γk (8)

ρ + ⟨λ, z − y⟩ + ∥z − y∥2 , 2 where ρ > 0 is a suitably chosen step size.

6

Let superscript t ∈ Z+ denote the ADMM iteration index. Given initialization λ0k ∈ RN , z0k = yk0 ⪰ dk , the variables are updated as: N n X η ykt+1 = argmin w c′n (ykt (n))y(n) + ∥y − ykt ∥2 2 y⪰dk n=1 2o 1 1 ρ t + zk − y + λtk , (9) ∥y − yk ∥2 + 2γk 2 ρ 2 1 ρ z − ykt+1 + λtk , (10) zt+1 = argmin fe(z) + k 2 ρ z λt+1 =λtk + ρ (zt+1 − ykt+1 ), (11) k k

where c′n (·) representing the derivative of the cost function and η is a tunable parameter. The y-update (9) follows a linearized ADMM scheme [35], where the cost term is approximated at the current iterate using the first-order gradient information. Since y-update (9) is a separable convex optimization problem, each element admits a closed-form update: yk (n) t t ′ t t γk + ρzk (n) + λk (n) − wcn (yk (n)) + ηyk (n) , 1 γk + ρ + η ykt+1 (n) = max{dk (n), ŷkt+1 (n)}, ∀n ∈ [N ]. (12)

ŷkt+1 (n) =

In particular, when cn (·) is linear, setting η = 0 recovers the standard ADMM update, as shown in our prior work [36]. It remains to specify how to compute the z-update (10). As such, we introduce the proximal mapping ρ (13) proxfe/ρ (x) ≜ argmin fe(y) + ∥y − x∥2 . 2 y As such, the z-update (10) corresponds to the calculation of proxfe/ρ (yt+1 − ρ1 λt ). Next, we introduce a fast algorithm to compute the proximal mapping.

nmin = nmax , then all elements of y⋆ are equal. When nmin < nmax , then the elements of y⋆ satisfies y ⋆ (N ) = · · · = y ⋆ (nmax ) > y ⋆ (nmax − 1) ≥ · · · ≥ y ⋆ (nmin + 1) > y ⋆ (nmin ) = · · · = y ⋆ (1).

Given these nice structure properties, we can effectively calculate y⋆ as follows. Proposition 1. Assume x has non-decreasing elements and let nmin and nmax be the indices satisfying (14). Then (1) When nmin = nmax , then N

1 X x(n). y (1) = y (2) = · · · = y (N ) = N n=1 ⋆

We note that fe(y) is convex and ρ2 ∥y − x∥2 is ρ-strongly convex for ρ > 0. Hence, the proximal subproblem is strongly convex, and proxfe/ρ (x) is the unique optimal solution. Before introducing the algorithm for (13), we need the following lemma regarding the property of proxfe/ρ . For brevity, we denote proxfe/ρ (x) as y⋆ . Lemma 1. Let x ≜ (x(n))N n=1 be sorted in non-decreasing order: x(1) ≤ x(2) ≤ · · · ≤ x(N ). Then the elements of proxfe/ρ (x) must also be non-decreasing. Proof. See Appendix B. Assisted by Lemma 1, we are now ready to introduce the algorithm for efficiently computing (13). First, note that problem (13) is permutation invariant. Therefore, without loss of generality, we assume the elements of x are in nondecreasing order. According to Lemma 1, it must hold that argmaxn∈[N ] y ⋆ (n) = {N, N − 1, . . . , nmax } for some positive integer nmax ≤ N . That is, the indices for which y ⋆ (n) attain its maximum must include N and decrease consecutively until nmax . Similarly, for the indices where y ⋆ (n) attain its minimum, we have argminn∈[N ] y ⋆ (n) = {1, 2, . . . , nmin } for some positive constant nmin , where nmin ≤ nmax . When

⋆

⋆

(2) When nmin < nmax , then  x(n),     PN n=nmax x(n)−1/ρ y ⋆ (n) = , N −nmax +1   Pnmin   n=1 x(n)+1/ρ , nmin

(15)

nmin < n < nmax n ≥ nmax

(16)

n ≤ nmin .

Proof. In the setting of Prop. 1, by Lemma 1, when nmin = nmax , we have y ⋆ (1) = y ⋆ (2) = · · · = y ⋆ (N ) = y and thus problem (13) is equivalent to N

min y

1X 2 (y − x(n)) . 2 n=1

It is clear that the optimal y value is equal to the average of the elements in the vector x. When nmin < nmax , problem (13) is equivalent to N

minimize B. Fast Computation of the Proximal Mapping proxfe/ρ (x)

(14)

y(1),...,y(N )

subject to

y(N ) − y(1) +

ρX (y(n) − x(n))2 2 n=1

y(1) = · · · = y(nmin ),

(17)

y(nmax ) = · · · = y(N ). Solving for each y(n) element-wise completes the proof. Proposition 1 reveals that computing proxfe/ρ (x) is roughly averaging respectively the nmin smallest and N − nmax + 1 largest elements of x, while leaving middle elements unchanged. This solution makes intuitively sense, as the objective of (13) requires minimizing the max-min gap of y⋆ while keeping it as close to x as possible. It remains to find nmin and nmax so that (14) holds. The structure of (16) suggests we can search for nmin and nmax starting from the two ends towards the center. Specifically, we initialize the search with nmin = 1 and nmax = N . Then for each pair (nmin , nmax ), we compute (16) and check if (14) is satisfied. If the edge condition y ⋆ (nmax ) > y ⋆ (nmax − 1) (respectively y ⋆ (nmin + 1) > y ⋆ (nmin )) is violated, we decrease nmax (respectively increase nmin ) by 1. Otherwise, the algorithm terminates. For example, consider x = (1, 1, 2) and ρ = 0.5. To calculate the proxfe/ρ (x), we first start nmin = 1 and nmax = 3. Following Proposition 1, we have y⋆ = (3, 1, 0) and thus y ⋆ (nmax ) < y ⋆ (nmax − 1) and y ⋆ (nmin ) > y ⋆ (nmin + 1).

7

Algorithm 1 Compute proxfe/ρ (x)

Algorithm 2 Synchronized Content Scheduling (SCS)

Require: Latency compensation vector x Ensure: The proximal mapping proxfe/ρ (x), denoted as y⋆ 1: Sort x in non-decreasing order and keep track of the original indices 2: Initialize nmin ← 1 and nmax ← N 3: while true do ▷ Compute y ⋆ (n) using Proposition 1 4: if nmax = nmin then 5: Using (15) to compute y ⋆ (n) 6: break 7: end if 8: if (14) is satisfied then 9: break 10: else 11: if y ⋆ (nmax − 1) ≥ y ⋆ (nmax ) then 12: nmax ← nmax − 1 13: else if y ⋆ (nmin + 1) ≤ y ⋆ (nmin ) then 14: nmin ← nmin + 1 15: end if 16: Using (16) to compute y ⋆ (n) 17: end if 18: end while 19: Resort y⋆ to match the original indices of x 20: return proxfe/ρ (x)

Require: Initial latency compensation vector x0 , initial latency d0 , number of contents K, and parameters ρ, η. 1: Initialize x ← x0 2: for k = 0 to K − 1 do 3: Initialize yk0 , z0k , and λ0k . 4: for t = 0 to Tk − 1 do 5: Update ykt+1 using (12) 6: Update zt+1 using Algorithm 1 for computing k   t+1 proxfe/ρ yk − ρ1 λtk

Hence, we have to increase nmin and decrease nmax by 1, respectively, which leads to nmin = nmax = 2. Thus, according to Proposition 1, we have y ⋆ = (4/3, 4/3, 4/3). In another example, consider x = (1, 2, 5) and ρ = 1. To calculate the proxfe/ρ (x), we first start nmin = 1 and nmax = 3. Following Algorithm 1, we have y⋆ = (2, 2, 4), satisfying that y ⋆ (1) ≤ y ⋆ (2) ≤ y ⋆ (3). The procedure is summarized in Algorithm 1, with the worst-case complexity involving only N scalar additions, divisions, and comparisons. This, combined with the computational complexity of sorting N numbers, results in a total computational complexity of O(N log N ). Combining the above components, the Stochastic Content Scheduling (SCS) algorithm for the server for each content delivery is summarized in Algorithm 2. The SCS algorithm begins with an initial latency sample d0 for each user. For each (k + 1)th content delivery, the latency compensation is determined by iteratively updating equations (11), (12), and Algorithm 1 over Tk iterations. The content is then transmitted to user n after a delay of xk+1 (n) time units, and the latency during this delivery is collected to determine the latency compensation in the next delivery. This deliveryfeedback loop repeats for each content, progressively refining the compensation vector to improve synchronization over time. VI. C ONVERGENCE A NALYSIS This section provides the convergence analysis of Algorithm 2. For convenience, define g(x; dk ) ≜ f (x; dk )+IR+ (x) with IR+ being the indicator function of the nonnegative orthant. Specifically, IR+ (x) equals to 0 if x ∈ R+ and

Update λt+1 using (11) k end for 9: Compute the latency compensation xk+1 ← ykTk 10: Transmit the (k + 1)th content to user n after a delay of xk+1 (n) time units, and collect the latency vector dk+1 during (k + 1)th delivery 11: end for 7: 8:

+∞ if x ∈ / R+ . Since ADMM is an iterative algorithm that converges asymptotically, in practice, one cannot solve exactly the subproblem (5). Therefore, we consider solving it inexactly by finding an ϵk -minimizer, i.e., xk+1 satisfies 1 2 g(xk+1 ; dk ) + ∥xk+1 − xk ∥ 2γk ( ) 1 2 ≤ min g(x; dk ) + ∥x − xk ∥ + ϵk . (18) x 2γk Let G(x) ≜ F (x) + IR+ (x). We note that the optimal solution to minx⪰0 F (x) is equivalent to the optimal solution to minx G(x). Next, we show that our proposed SCS algorithm converges under suitably chosen ϵk in each iteration k, as stated in the following proposition. Proposition 2. Let {xk }k≥0 be the sequence generated by Algorithm 2, and let x⋆ be a minimizer of G. Then, for all K ≥ 1, it holds
2 √ ∥x0 − x⋆ ∥ + 2AK + 2BK ⋆ E [G(xK )] − G(x ) ≤ , PK 2 k=0 γk PK PK √ 2γk ϵk , and where xK ≜ PK1 γ k=0 γk xk , AK ≜ k=0 k k=0
PK 2 ′ ⋆ 2 BK ≜ k=0 γk ϵk + γk E[∥f (x ; dk )∥ ]/2 . √ Moreover, suppose the stepsizes satisfy γk = γ0 / K for some γ0 > 0, and the ϵk is decreased as O(1/k p ) with p > 2. Then we see that   1 ⋆ E[G(xK )] − G(x ) ≤ O √ . K Proof. We start from the optimality condition of the subproblem (18). By [37, Lemma 2], for any xk+1 √ satisfying (18) there exists some vector ek such that ∥ek ∥ ≤ 2γk ϵk and −

1 (xk+1 − xk + ek ) ∈ ∂ϵk g(xk+1 ; dk ), γk

(19)

where ∂ϵ g(x; d) is the ϵ-subdifferential set of g(·; d) at x defined as ∂ϵ g(x; d) ≜ {ξ | g(y; d) ≥ g(x; d) + ξT (y − x) − ϵ, ∀y}.

8

Letting y = x⋆ , x = xk+1 and ξ = − γ1k (xk+1 − xk + ek ) in ∂ϵ g(x; d), thus gives g(xk+1 ; dk ) ⋆

≤ g(x ; dk ) +

Dx

k+1 − xk + ek

γk

⋆

E

, x − xk+1 + ϵk

1 1 = g(x⋆ ; dk ) + ∥xk − x⋆ ∥2 − ∥xk+1 − x⋆ ∥2 2γk 2γk D 1 ek E − + x⋆ − xk+1 , ∥xk+1 − xk ∥2 + ϵk γk 2γk 1 1 (20) ∥xk − x⋆ ∥2 − ∥xk+1 − x⋆ ∥2 ≤ g(x⋆ ; dk ) + 2γk 2γk 1 1 + ∥ek ∥∥x⋆ − xk+1 ∥ − ∥xk+1 − xk ∥2 + ϵk γk 2γk 1 1 ∥xk − x⋆ ∥2 − ∥xk+1 − x⋆ ∥2 ≤ g(x⋆ ; dk ) + 2γk 2γk r 2ϵk ⋆ 1 + ∥x − xk+1 ∥ − ∥xk+1 − xk ∥2 + ϵk γk 2γk

Define filtration Fk ≜ σ(d1 , ..., dk ). It holds xk ∈ Fk−1 . Taking the conditional expectation of (21) on both sides w.r.t. Fk−1 we have 1 E[∥xk+1 − x⋆ ∥2 |Fk−1 ] 2γk
γk ≤ − G(xk ) − G(x⋆ ) + E[∥g ′ (x⋆ ; dk )∥2 ] 2 r 1 2ϵk ⋆ 2 E[∥xk+1 − x ∥ |Fk−1 ] + ∥xk − x⋆ ∥2 + ϵk , + γk 2γk where we use the fact that dk is independent of Fk−1 . Rearranging terms, multiplying 2γk to both sides of the inequality, and taking expectation w.r.t. Fk−1 , we obtain 2γk E[G(xk ) − G(x⋆ )] + E[∥xk+1 − x⋆ ∥2 ] p ≤ E[∥xk − x⋆ ∥2 ] + 2 2ϵk γk E[∥xk+1 − x⋆ ∥]

Summing up over k = 0, ..., K, and using telescopic cancellation, we have the result

where the third step follows from Cauchy–Schwarz inequality. Rearranging terms on (20), we can get for any subgradient g ′ (x⋆ ; dk ) ∈ ∂g(x⋆ ; dk )5 it must be

K X

2γk E[G(xk ) − G(x⋆ )] + E[∥xK+1 − x⋆ ∥2 ]

k=0

≤ E[∥x0 − x⋆ ∥2 ] +

1 ∥xk+1 − x∗ ∥2 2γk

K X

γk2 E[∥g ′ (x⋆ ; dk )∥2 ]

k=0

1 ≤ g(x⋆ ; dk ) − g(xk+1 ; dk ) + ∥xk − x∗ ∥2 2γk r 2ϵk 1 ∥xk+1 − x⋆ ∥ − ∥xk+1 − xk ∥2 + ϵk + γk 2γk 1 ∥xk − xk+1 ∥2 ≤ ⟨g ′ (x⋆ ; dk ), x⋆ − xk ⟩ + 2β 1 β + ∥g ′ (x⋆ ; dk )∥2 + ∥xk − x∗ ∥2 + ϵk 2 2γk r 2ϵk 1 ∥xk+1 − x⋆ ∥ − ∥xk+1 − xk ∥2 + γk 2γk
1 ∥xk − xk+1 ∥2 ≤ − g(xk ; dk ) − g(x⋆ ; dk ) + 2β r 1 2ϵk ∗ 2 + ∥xk − x ∥ + ∥xk+1 − x⋆ ∥ + ϵk 2γk γk 1 β − ∥xk+1 − xk ∥2 + ∥g ′ (x⋆ ; dk )∥2 2γk 2

+

K  X

 p 2 2ϵk γk E[∥x⋆ − xk+1 ∥] + 2γk ϵk .

(23)

k=0

Note that (23) holds for any subgradient g ′ (x⋆ ; dk ). Since ∂g(x⋆ ; dk ) = ∂f (x⋆ ; dk ) + NR+ (x) with NR+ (x⋆ ) being the normal cone of R+ at x⋆ [38, Thm. 2.26], and x⋆ must be nonnegative, we can always pick g ′ (x⋆ , dk ) such that E[∥g ′ (x⋆ ; dk )∥2 ] = E[∥f ′ (x⋆ ; dk )∥2 ], which is bounded by Lemma 2. The rest of the proof follows PK [37] √ with a slight modification. Denote AK ≜ ≜ k=0
2γk ϵk and BK PK 2 ′ ⋆ 2 γ ϵ + γ E[∥f (x ; d )∥ ]/2 . We will have k k k k k=0
2 √ K X   ∥x0 − x⋆ ∥ + 2AK + 2BK γk E G(xk ) − G(x⋆ ) ≤ . 2 k=0

where the second step follows [31, Lemma 3.2], β > 0 is an adjustable constant, and the last step is by the first-order conditions of convexity. Choosing β = γk yields 1 ∥xk+1 − x⋆ ∥2 2γk
1 ≤ − g(xk ; dk , ) − g(x⋆ ; dk ) + ∥xk − x⋆ ∥2 2γk r γk ′ ⋆ 2ϵk 2 + ∥g (x ; dk )∥ + ∥xk+1 − x⋆ ∥ + ϵk . 2 γk

(22)

+ γk2 E[∥g ′ (x⋆ ; dk )∥2 ] + 2γk ϵk .

(21)

5 The subdifferential of f at x, denoted by ∂f (x), is defined as ∂f (x) ≜ {ξ|f (y) ≥ f (x) + ⟨ξ, y − x⟩, ∀y ∈ domf }, and domf is the domain of f .

As G(·) is convex, with the Jensen’s inequality, we get, √ (∥x0 − x⋆ ∥ + 2AK + 2BK )2 ⋆ E[G(xK )] − G(x ) ≤ PK 2 k=0 γk PK where xK ≜ PK1 γ k=0 γk xk . k=0 k √ Set the stepsize γk ≜ γ0 / K for k ≥ 0 and ϵk is decreased as O(1/k p ), the desired result follows from the following Lemma. Lemma 2. Let ∂f (x; d) denote the subdifferential of the function f (· ; d) as defined in (1), evaluated at x. For some constant L ≥ 0, and for any subgradient f ′ (x; d) ∈ ∂f (x; d), it holds h i 2 E ∥f ′ (x; d)∥ ≤ 4 + 2N w2 L2 . (24) The proof is available in Appendix C.

9

Algorithm 3 Dropping-Case Variant of SCS (D-SCS)

where we define the synchronization metric as

Require: Initial latency vector d0 , acknowledged set H0 , zero e0 , and maximum waiting time τmax . compensation x0 = x 1: for k = 1 to K do, ek 2: Set xk ← x 3: Solve the subproblem over Hk :   1 2 ∥x − xk ∥Hk xk+1 = argmin f (x; dk , Hk ) + 2γk x⪰0 (25) 4: Determine the postpone time of the (k + 1)th delivery ek+1 ≜ (e x xk+1 (n))N n=1 : ( xk+1 (n), if n ∈ Hk x ek+1 (n) ← x ek (n), otherwise Deliver the (k + 1)th content to each user n after a delay of x ek+1 (n) time units. 6: Wait for ACKs up to time limit τmax , determine the acknowledged set Hk+1 , and observe dk+1 latency. 7: end for

5:

Since linearized ADMM converges at a rate of O(1/t) for convex problems [35, Thm. 2.5], the iteration number Tk in Algorithm 2 can be set as Ω(k p ) to ensure that ϵk = O(1/k p ).

VII. S YNCHRONIZATION WITH PACKET D ROPS We extend the framework to the dropping case, where only a subset of users may receive each delivery due to packet losses. In practice, a server expects an acknowledgment (ACK) from each user within a maximum tolerable latency τmax (e.g., 2 or 3 frames in an MR system). If no ACK is received in time, the user is considered to have missed the content. Let Ik (n) ∈ {0, 1} indicate whether user n successfully receives the k th content, with Ik (n) = 1 implying content k having been successfully delivered to user n and Ik (n) = 0 otherwise. We assume that the dropping event Ik (n) is i.i.d. across delivery rounds k and independent across users n. Define the corresponding acknowledged set as Hk ≜ {n ∈ [N ] : Ik (n) = 1} , which captures the users for whom content delivery succeeds in the k th delivery. Note that the acknowledged set Hk is i.i.d. across k, as each set is generated from the independent i.i.d. dropping event Ik (n). In this setting, we aim to maintain synchronization within the acknowledged set Hk by minimizing the latency discrepancy while avoiding excessive latency cost. Since both the latency dk and the acknowledged set Hk are i.i.d., we omit the subscript k in the optimization formulation for notational simplicity. This leads to the following stochastic optimization problem, min F (x) ≜ E [f (x; d, H)] , x⪰0

(26)

f (x; d, H) ≜ max(x(n) + d(n)) − min(x(n) + d(n)) n∈H n∈H X +w cn (x(n) + d(n)) (27) n∈H

The dropping case (26) differs from the full-delivery case (1) in the randomness of the H, making the objective dependent on both the random latency vector d and the acknowledged set H. Notably, when the network conditions are stable and the dropping probability satisfies P[Ik = 0] = 0 for all n ∈ [N ], the formulation reduces to the original full-delivery model with H = [N ]. To accommodate dynamic network conditions with packet drops, we extend the SCS algorithm, named D-SCS, as detailed in Algorithm 3. Note that the waiting step is a feedback cutoff, not a blocking operation: the server continues rendering and transmitting contents using the latest compensation vector, while τmax only determines which ACKs are used to update the next compensation decision. In each round, the proximal update is computed only for the acknowledged users in Hk , leaving compensation values for n ∈ / Hk unchanged. Specifically, for users n ∈ / Hk , no ACK is received within τmax , so their compensation values are carried over as x ek+1 (n) = x ek (n), following step 4 of Algorithm 3. Thus, the resulting subproblem is now restricted to the smaller subset Hk ⊆ [N ]. As demonstrated in later simulations (see VIII-C), this modification preserves the algorithm’s ability to maintain synchronization under realistic drop rates. The empirical results strongly suggest that the convergence behavior of D-SCS is preserved. However, formal analysis remains challenging, as packet drops induce random, time-varying coordinate updates that break the telescoping structure used in the SCS convergence proof and obscure the influence of the dropping probability. A rigorous theoretical treatment of D-SCS is thus a promising direction for future work. VIII. S IMULATIONS In this section, we first conduct synthetic simulations to validate the performance of our proposed synchronized scheduling algorithm. Then, we demonstrate the superiority of our algorithm using two real-world latency datasets: one from network latencies in Seattle [39] and the other from content delivery latency in MR-based firefighter training [40]. Additionally, we show that the proposed algorithm can handle the dropping case in realistic network conditions. Throughout, we use the improvement ratio (defined in (4)) as the primary performance metric, measuring the relative reduction in the objective function compared to the no-compensation case. Hardware. The simulations are conducted on a Dell Precision 7920 workstation equipped with Intel(R) Xeon(R) Gold 6242R CPU @3.10Ghz, and 128 GB RAM. Baseline. We compare our proposed algorithm with the following three baselines. SRA: Simple running average (SRA) is a heuristic latency compensation method. It determines latency compensation by solving the optimization problem (3) using the running average of all previous latency samples.

10

(a) Truncated normal (N = 5)

(b) Truncated normal (N = 20)

(c) Log-normal (N = 50)

(d) Log-normal (N = 100)

Fig. 4: Synthetic simulation: Impact of parameter T .

(a) Truncated normal (N = 5)

(b) Truncated normal (N = 20)

(c) Log-normal (N = 50)

(d) Log-normal (N = 100)

Fig. 5: Synthetic simulation: improvement ratio.

ERA: Exponential running average (ERA) solves (3) using an exponentially weighted running average of latency samples, where the newest latency sample receives weight 0.1 and the previous estimate receives weight 0.9. VAR: Variance-minimization (VAR) determines latency compensation by minimizing the compensated latencies across all users rather than the stricter max-min gap, while keeping the same latency-cost term. SSGD: Stochastic subgradient descent (SSGD) is a firstorder baseline that directly updates the compensation vector using a stochastic subgradient of f (x; dk ) at each delivery round, followed by projection onto x ⪰ 0. A. Synthetic Trace Simulation We evaluate content delivery latency across varying system scales, with the number of users N ranging from 5 to 100. We use two common distributions: truncated normal and lognormal6 . The detailed parameter settings are as follows: • Truncated Normal: The mean is uniformly sampled from 10–200 ms, and the standard deviation from 1–100 ms. Latency values are truncated between 0 and 1000 ms to reflect practical bounds. • Log-Normal: The mean is uniformly sampled from 0.1–0.2 s, and the standard deviation from 1–100 ms. To ensure finite support, latency values are clipped at 10 s. 1) Impact of parameter T in SCS: Our Proposition 2 indicates that theoretically, the precision of ADMM iterations, ϵk , needs to decay at rate O(1/k p ) with p > 2 to ensure the convergence to the optimal objective value. However, in practice, such a choice can be too conservative and unnecessarily 6 Log-normal distributions have been shown to accurately model real-world network traffic, especially in large-scale data center systems [41], [42].

increase the computation time. We would like to evaluate the impact of early termination in ADMM by executing a finite T number of iterations on the convergence of our proposed algorithm. Here, the optimal objective value F ⋆ is obtained using an offline Monte Carlo simulation (see [43]). As shown in Fig. 4, the proposed algorithm consistently converges to the optimal objective value across both latency distributions and a wide range of user scales (N = 5 to 100), demonstrating strong robustness and scalability. The designed SCS algorithm remains effective with a finite number of ADMM iterations. When T = 10 or 20, the algorithm converges with negligible optimality gaps. Even with T = 5, it achieves near-optimal performance in most cases, with only slight degradation under large user scales (see Fig. 4(c) and (d)), showcasing its practicality under constrained computational budgets. Moreover, larger values of T (i.e., a more accurate solution for each content delivery) lead to faster convergence across all settings, indicating a favorable trade-off between computational cost and performance in practice. 2) Improvement ratio: Next, we evaluate the performance of the proposed SCS algorithm with T = 10 compared with the baseline methods SRA, ERA, and VAR, as illustrated in Fig. 5. From Fig. 5b, we can observe that SCS outperforms all baseline algorithms when the latency follows the truncated normal distribution. Specifically, SCS achieves up to more than 80% improvement ratio when the weighting parameter w is small while SRA and ERA have relatively small improvement. Notably, VAR can even degrade synchronization performance, highlighting that merely minimizing latency variance across users cannot guarantee effective synchronization. For the Lognormal latency distribution, as shown in Fig. 5c and 5d, SCS again demonstrates superior performance, particularly when w

11

Fig. 6: Synchronization–violation tradeoff. The shaded region shows the average user violation probability ± one standard deviation. Horizontal lines denote no-compensation baselines. is small. It significantly outperforms both SRA and ERA, and maintains an advantage over VAR. To further illustrate the role of the weighting parameter w, we report the average max-min delay gap and the average violation probability under different values of w, as shown in Fig. 6. We consider N = 5 users with log-normal latency distributions and define a violation event as xk (n) + dk (n) > 250 ms. A smaller w prioritizes synchronization and yields a smaller average max-min delay gap, whereas a larger w reduces the average violation probability at the cost of a larger delay discrepancy. These results confirm that w provides a tunable tradeoff between synchronization performance and delayconstraint satisfaction. Accordingly, synchronization-critical applications, such as collaborative MR, may favor a smaller w, whereas applications prioritizing compliance with latency requirements, such as multi-party video conferencing, may favor a larger w. In practice, w can be selected using representative validation traces to meet application-specific requirements. For instance, under the setting in Fig. 6, a target average violation probability of around 3% at the 250 ms threshold suggests w ≈ 0.1. More generally, the operator may choose the smallest feasible w under a latency constraint, or the largest feasible w under a synchronization-gap requirement to reduce latency. 3) Convergence rate comparison: We compare the proposed SCS algorithm, based on the SPP framework, with the SSGD method. Our experiments consider N = 5 users experiencing latencies modeled as latency-truncated normal distributions, under varying mean latency µ and standard deviation σ patterns, detailed in Table I: TABLE I: Latency parameters configurations. Pattern

Mean vector µ [ms]

Std. dev. vector σ [ms]

Low µ, low σ High µ, low σ High µ, high σ

[2, 4, 6, 8, 10] [10, 20, 30, 40, 50] [10, 20, 30, 40, 50]

[0.5, 1, 1.5, 2, 2.5] [0.5, 1, 1.5, 2, 2.5] [5, 10, 15, 20, 25]

We first evaluate the impact of the mean latency vector µ by fixing the standard deviation σ (Fig. 7a). As µ increases, the latency disparities among the users become more significant. Although both SCS and SSGD ultimately converge to the optimal value, SCS consistently requires fewer content deliveries to achieve near-optimality. Notably, when the mean latency differs from 40 ms, SCS reaches near-optimality performance in about 250 deliveries, whereas SSGD necessitates

(a) Effect of different mean la- (b) Effect of different latency varitency on convergence ance on convergence

Fig. 7: Synthetic simulation: convergence of SCS vs. SSGD under varying latency distribution patterns.

(a) Truncated normal (N =5)

(b) Log-normal (N =50)

Fig. 8: Impact of parameter ρ on the convergence of SCS.

approximately 800, demonstrating SCS’s superior efficiency under high mean latency. Next, we compare performance under two variance conditions: high µ with low σ versus high µ with high σ (Fig. 7b). As σ increases, both algorithms experience slower convergence due to the increased variance in latency samples. In the setting with low σ, indicating a more stable network with low jitter, SCS converges in fewer than 150 deliveries, whereas SSGD requires more than 500 round contents. Overall, SCS consistently exhibits superior convergence speed to SSGD across a diverse range of latency patterns. 4) Impact of parameter ρ: We evaluate the sensitivity of SCS to the ADMM penalty parameter ρ across two representative settings: truncated normal latencies with N = 5 users and log-normal latencies with N = 50 users. As shown in Fig. 8, while slight differences in convergence speed are observed, all tested values of ρ converge to near-optimal performance in both settings, demonstrating that the algorithm is robust to the choice of ρ. These results suggest that, in practice, ρ can be selected within a reasonable range without significantly affecting synchronization performance. B. Real-world Trace Simulation In this subsection, we demonstrate the effectiveness of the proposed algorithm SCS using two real-world latency datasets. First, we use the network traces from [39], which collect the round trip times (RTTs) between 99 nodes in the Seattle network over 688 distinct time periods. We repeated the use of one trace to simulate the same network condition to let the nodes be 100.

12

(a) Latency traces in Seattle (N = 50)

(b) Latency traces in Seattle (N = 100)

(c) MR-based firefighter training (d) MR-based firefighter training (N = 5) (N = 20)

Fig. 9: Real-world trace simulation: improvement ratio.

(a) Latency traces in Seattle

(b) MR-based firefighter training

Fig. 10: Real-world trace simulation: computational time.

1) Improvement ratio: As shown in Fig. 9a and 9b, we observe that the proposed SCS consistently exhibits a larger improvement ratio than baseline algorithms. Specifically, when w = 0.01 and N = 50 (see Fig. 9a), SCS achieves an improvement ratio of around 10%, while SRA and ERA adversely impact performance, resulting in undesirable experiences for users. VAR, in contrast, shows no meaningful improvement in large-scale network synchronization. Additionally, we examine the performance of SCS on the dataset from an MR-based firefighter training platform, which records real transmission latency from the server to multiple participants [40]. As shown in Fig. 9c and 9d, the improvement ratio of SCS is higher than SRA, ERA, and VAR across the weighting parameter w from 0 to 0.2, This demonstrates the effectiveness of the proposed algorithm, especially when synchronization performance is prioritized. These results highlight the robustness and effectiveness of SCS, particularly in scenarios where precise synchronization is critical. 2) Computational time: Moreover, we evaluate the computational time of the proposed algorithm SCS. Fig. 10a and Fig. 10b illustrate the computational time per content delivery compared against the toolbox CVXPY. We can see that the computational time of SCS is significantly less than that of CVXPY. Specifically, the computation time for CVXPY exceeds 5 ms, while our algorithm requires usually less than 2 ms even when there are 50 users. This illustrates that the proposed SCS is time-efficient, making it promising for realtime content delivery in practical systems. 3) Adaptability to different cost functions: We study the practical impact of varying cost functions in the synchronization tasks. We employ five representative network traces and

set the weighting parameter w = 0.1 to ensure a consistent experimental environment. The proposed SCS algorithm is compared against baseline algorithms across three common cost functions cn (x): linear (x), quadratic (x2 ), exponential (e0.1x − 1). As depicted in Fig. 11, SCS consistently achieves a higher improvement ratio across all cost functions. Particularly, under the exponential function, SCS achieves over 70% improvement, significantly outperforming SRA, which attains approximately 20% improvement. These results highlight the strong adaptability of SCS across diverse latency cost models in practical synchronization scenarios.

Fig. 11: Real-world trace simulation: adaptability to different cost functions.

C. Dropping Case Simulation To evaluate the performance of the proposed D-SCS algorithm under dropping case, we introduce an i.i.d. packet dropping rate with a fixed probability q(n) = q for all users. The dropping probability q takes values from the set {0, 0.05, 0.1, 0.2}, simulating increasing challenging network environments. We evaluate the algorithm in two representative scenarios: N = 5 users with truncated-normal latencies and N = 20 users with log-normal latencies. Fig. 12 shows the objective value versus the number of contents K in which dashed lines indicate the optimal function value corresponding to each dropping rate. In both scenarios, D-SCS algorithm demonstrates robust convergence behavior, maintaining nearoptimal performance even under severe packet loss conditions (e.g., q = 0.2). These results underscore the resilience and effectiveness of the proposed algorithm in maintaining synchronization in realistic network conditions with packet drops.

13

where the second step follows from the convexity of f (x; d). Thus, F is a convex function. Next, we show that the function f (·; d) is proper. In addition, given that x and d are non-negative, it follows that f (x; d) ≥ 0 for all x ⪰ 0. Moreover, when x = 0, f (0; d) < +∞ for the finite d. Hence, the function f (·; d) is proper and consequently, F is also proper. (a) Truncated normal (N =5)

A PPENDIX B P ROOF OF L EMMA 1

(b) Log-normal (N =20)

Fig. 12: Dropping case simulation: convergence under varying dropping rates. Dashed lines denote the optimal function value. IX. C ONCLUSION In this paper, we considered the problem of real-time synchronized scheduling for collaborative content delivery from a server to a group of users. We introduced latency compensation to control the server’s delivery time for each user. Crucially, our framework is clock-free, relies only on simple acknowledgment feedback without requiring a synchronized clock or client-side timestamps. Our goal is to minimize the discrepancy between maximum and minimum latencies while keeping the overall latency costs experienced by all users low. Due to the randomness of latency, we formulated this as a stochastic optimization problem involving a nonsmooth component from the synchronization. To tackle this challenge, we utilized SPP, which only requires historical latency samples. We explored the inherent problem structure and leveraged the ADMM to address the challenges posed by constraints and the non-smooth component, resulting in only the computational complexity of O(N log N ) per iteration. We further demonstrate that our proposed algorithm converges √ to the optimal objective value at the rate of O(1/ K). Additionally, we extended our design to handle packet drops during delivery, confirming its robustness in degraded network conditions. Finally, our simulations evaluated the effectiveness of the proposed algorithm against baselines. An interesting future direction is to extend the framework to dynamic user scenarios where users may join or leave, which would require modeling time-varying active user set and analyzing convergence under changing problem dimensions. A PPENDIX A P ROPER AND C ONVEX O BJECTIVE F UNCTION Claim 1. f ( · ; d) and F are proper and convex functions. Proof. Given any realization of the N -dimensional random vector d, the function maxn∈[N ] (xn + dn ) isP convex w.r.t. x, minn∈[N ] (xn +dn ) is concave w.r.t. x, and w n∈[N ] cn (xn + dn ) is convex w.r.t. x. Therefore, the function f (x; d) is convex w.r.t. x for any fixed d. Recall F (x) ≜ E[f (x; d)]. For any λ ∈ [0, 1], we have F (λx1 + (1 − λ)x2 ) = E [f (λx1 + (1 − λ)x2 ; d)] ≤ E [λf (x1 ; d) + (1 − λ)f (x2 ; d)] = λE[f (x1 ; d)] + (1 − λ)Ed [f (x2 ; d)] = λF (x1 ) + (1 − λ)F (x2 ),

For simplicity, we denote yn⋆ as y ⋆ (n) for any n ∈ [N ] in ⋆ this proof. We want to show that ym ≥ yn⋆ for m > n. We will ⋆ prove this by contradiction. Suppose ym < yn⋆ when m > n. According to the Lemma condition, there are only two cases to consider: xm > xn and xm = xn . ⋆ First, if xm > xn , we will show that swapping ym and yn⋆ will reduce the objective value, contradicting the optimality of y. Second, if xm = xn , the swap will generate two optimal solutions, contradicting the uniqueness of y⋆ . Since fe is permutation invariant, we need to focus only on the quadratic term. By computing the difference in the objective ⋆ value before and after swapping ym and yn⋆ , we have ⋆ (ym − xm )2 + (yn⋆ − xn )2 ⋆ 2 ⋆ = (ym ) + (yn⋆ )2 + x2m + x2n − 2(ym xm + yn⋆ xn ) ⋆ 2 ⋆ ≥ (ym ) + (yn⋆ )2 + x2m + x2n − 2(ym xn + yn⋆ xm )

(28)

⋆ = (yn⋆ − xm )2 + (ym − x n )2 ,

where the inequality holds since ⋆ ⋆ (ym xm + yn⋆ xn ) − (ym xn + yn⋆ xm ) ⋆ = ym (xm − xn ) + yn⋆ (xn − xm ) ⋆ = (ym − yn⋆ )(xm − xn ) ≤ 0. ⋆ If xm > xn , then (28) holds strictly and thus swapping ym ⋆ and yn yields a smaller objective value, contradicting the optimality of y⋆ . If xm = xn , then (28) becomes equality and ⋆ swapping ym and yn⋆ does not change the objective value but yields another optimal solution, contradicting y⋆ ’s uniqueness.

A PPENDIX C P ROOF OF LEMMA 2 Define Imax ≜ arg maxn∈[N ] {x(n) + d(n)} and Imin ≜ arg minn∈[N ] {x(n) + d(n)}. Then the subdifferential of the non-smooth part is   ∂ max(x(n) + d(n)) − min(x(n) + d(n)) n

n

= conv{ei : i ∈ Imax } − conv{ej : j ∈ Imin }, where ei is the standard basis vector with the ith component being 1 and 0 for all other components, and conv represents convex hull (see [32], Ch. 3). Any subgradient ζ ∈ ∂ (maxn (x(n) + d(n)) − minn (x(n) + d(n))) satisfies X X ζ= αi ei − βj e j i∈Imax

P

P

j∈Imin

with i∈Imax αi = j∈Imin βj = 1 and αi , βj ≥ 0; ∀i, j. Using the orthogonality of the standard basis, we have

14

2

∥ζ∥ =

X i∈Imax

αi2 +

X

βj2 ≤ 2

(29)

j∈Imin

In addition, since cn (·) is differentiable and continuous on R+ , it follows that over any closed and bounded interval [0, τmax ], the derivative c′n (x) is bounded. Hence, for any finite x(n) ≥ 0 and x(n) + d(n) ∈ [0, τmax ], there exists a constant Ln ≥ 0 such that c′n (x(n) + d(n)) ≤ Ln ,

∀n ∈ [N ].

This follows from the Extreme Value Theorem, since c′n (·), being continuous on a closed and bounded domain, must attain a finite maximum. Define L ≜ maxn Ln , we have the gradient from the smooth component satisfying 2

w

X

c′n (x(n) + d(n)) · en

≤ w2

n∈[N ] 2

X n∈[N ] 2

≤ w NL

L2n (30)

Combining (29) and (30), using the inequality ∥a + b∥2 ≤ 2∥a∥2 + 2∥b∥2 , taking expectation give the desired results: h i 2 E ∥f ′ (x; d)∥ ≤ 2 · E[∥ζ∥2 ] + 2N w2 L2 ≤ 4 + 2N w2 L2

(31)

R EFERENCES [1] C.-Y. Huang, C.-H. Hsu, Y.-C. Chang, and K.-T. Chen, “Gaminganywhere: An open cloud gaming system,” in Proceedings of the 4th ACM multimedia systems conference, 2013, pp. 36–47. [2] B. Ens, J. Lanir, A. Tang, S. Bateman, G. Lee, T. Piumsomboon, and M. Billinghurst, “Revisiting collaboration through mixed reality: The evolution of groupware,” International Journal of Human-Computer Studies, vol. 131, pp. 81–98, 2019. [3] J. Li, Z. Li, R. Lu, K. Xiao, S. Li, J. Chen, J. Yang, C. Zong, A. Chen, Q. Wu et al., “Livenet: a low-latency video transport network for largescale live streaming,” in Proceedings of the ACM SIGCOMM 2022 Conference, 2022, pp. 812–825. [4] P. Jia, X. Wang, and X. Shen, “Passive network synchronization based on concurrent observations in industrial iot systems,” IEEE Internet of Things Journal, vol. 8, no. 18, pp. 14 028–14 038, 2021. [5] D. L. Mills, “Internet time synchronization: the network time protocol,” IEEE Transactions on communications, vol. 39, no. 10, pp. 1482–1493, 2002. [6] A. Garg, A. Yadav, A. Sikora, and A. S. Sairam, “Wireless precision time protocol,” IEEE Communications Letters, vol. 22, no. 4, pp. 812–815, 2017. [7] S. T. Watt, S. Achanta, H. Abubakari, E. Sagen, Z. Korkmaz, and H. Ahmed, “Understanding and applying precision time protocol,” in 2015 Saudi Arabia Smart Grid (SASG). IEEE, 2015, pp. 1–7. [8] G. K. Illahi, T. V. Gemert, M. Siekkinen, E. Masala, A. Oulasvirta, and A. Ylä-Jääski, “Cloud gaming with foveated video encoding,” ACM Transactions on Multimedia Computing, Communications, and Applications (TOMM), vol. 16, no. 1, pp. 1–24, 2020. [9] A. Ali Almazroi and M. Ngadi, “Packet priority scheduling for data delivery based on multipath routing in wireless sensor network,” in Computer Networks and Inventive Communication Technologies: Proceedings of Third ICCNCT 2020. Springer, 2021, pp. 59–81. [10] L. Gao, M. Tang, H. Pang, J. Huang, and L. Sun, “Multi-user cooperative mobile video streaming: Performance analysis and online mechanism design,” IEEE Transactions on Mobile Computing, vol. 18, no. 2, pp. 376–389, 2018. [11] J. Chen, F. Qian, and B. Li, “Enhancing quality of experience for collaborative virtual reality with commodity mobile devices,” in 2022 IEEE 42nd International Conference on Distributed Computing Systems (ICDCS). IEEE, 2022, pp. 1018–1028.

[12] T. Huang, C. Zhou, R.-X. Zhang, C. Wu, and L. Sun, “Buffer awareness neural adaptive video streaming for avoiding extra buffer consumption,” in IEEE INFOCOM 2023-IEEE Conference on Computer Communications. IEEE, 2023, pp. 1–10. [13] A. A. Simiscuka, T. M. Markande, and G.-M. Muntean, “Real-virtual world device synchronization in a cloud-enabled social virtual reality iot network,” IEEE Access, vol. 7, pp. 106 588–106 599, 2019. [14] F. G. Hamza-Lup and J. P. Rolland, “Adaptive scene synchronization for virtual and mixed reality environments,” in Proceedings of the IEEE Virtual Reality 2004, 2004, p. 99. [15] M. Schnierle and S. Röck, “Latency and sampling compensation in mixed-reality-in-the-loop simulations of production systems,” Production Engineering, vol. 17, no. 3, pp. 341–353, 2023. [16] J.-P. Stauffert, F. Niebling, and M. E. Latoschik, “Latency and cybersickness: Impact, causes, and measures. a review,” Frontiers in Virtual Reality, vol. 1, p. 582204, 2020. [17] Z. Li, H. Melvin, R. Bruzgiene, P. Pocta, L. Skorin-Kapov, and A. Zgank, “Lag compensation for first-person shooter games in cloud gaming,” in Autonomous Control for a Reliable Internet of Services: Methods, Models, Approaches, Techniques, Algorithms, and Tools. Springer International Publishing Cham, 2018, pp. 104–127. [18] S. Kassir, G. de Veciana, N. Wang, X. Wang, and P. Palacharla, “Joint update rate adaptation in multiplayer cloud-edge gaming services: Spatial geometry and performance tradeoffs,” in Proceedings of the Twentysecond International Symposium on Theory, Algorithmic Foundations, and Protocol Design for Mobile Networks and Mobile Computing, 2021, pp. 191–200. [19] J. Park, P. Popovski, and O. Simeone, “Minimizing latency to support vr social interactions over wireless cellular systems via bandwidth allocation,” IEEE Wireless Communications Letters, vol. 7, no. 5, pp. 776–779, 2018. [20] J.-L. Ferrant, M. Gilson, S. Jobert, M. Mayer, M. Ouellette, L. Montini, S. Rodrigues, and S. Ruffini, “Synchronous ethernet: A method to transport synchronization,” IEEE Communications Magazine, vol. 46, no. 9, pp. 126–134, 2008. [21] L. Jiang and J. Walrand, “Stable and utility-maximizing scheduling for stochastic processing networks,” in 2009 47th Annual Allerton Conference on Communication, Control, and Computing (Allerton). IEEE, 2009, pp. 1111–1119. [22] B. Li, Z. Shi, and A. Eryilmaz, “Efficient scheduling for synchronized demands in stochastic networks,” in 2018 16th International Symposium on Modeling and Optimization in Mobile, Ad Hoc, and Wireless Networks (WiOpt). IEEE, 2018, pp. 1–8. [23] H. H. Yang, Z. Liu, T. Q. Quek, and H. V. Poor, “Scheduling policies for federated learning in wireless networks,” IEEE transactions on communications, vol. 68, no. 1, pp. 317–333, 2019. [24] I. Kadota, A. Sinha, E. Uysal-Biyikoglu, R. Singh, and E. Modiano, “Scheduling policies for minimizing age of information in broadcast wireless networks,” IEEE/ACM Transactions on Networking, vol. 26, no. 6, pp. 2637–2650, 2018. [25] C. Joo and A. Eryilmaz, “Wireless scheduling for information freshness and synchrony: Drift-based design and heavy-traffic analysis,” IEEE/ACM transactions on networking, vol. 26, no. 6, pp. 2556–2568, 2018. [26] X. Zhou, I. Koprulu, and A. Eryilmaz, “Exploring the tradeoff between age of information and synchronization over broadcast channels,” in 2023 21st International Symposium on Modeling and Optimization in Mobile, Ad Hoc, and Wireless Networks (WiOpt). IEEE, 2023, pp. 302–309. [27] ——, “Novel drift-based design and analysis for synchronized and fresh communication over broadcast channels,” in IEEE INFOCOM 2025IEEE Conference on Computer Communications. IEEE, 2025, pp. 1– 10. [28] G. Xiong, X. Qin, B. Li, R. Singh, and J. Li, “Index-aware reinforcement learning for adaptive video streaming at the wireless edge,” in Proceedings of the Twenty-Third International Symposium on Theory, Algorithmic Foundations, and Protocol Design for Mobile Networks and Mobile Computing, 2022, pp. 81–90. [29] C.-H. Tsai and C.-C. Wang, “Distribution-oblivious online algorithms for age-of-information penalty minimization,” IEEE/ACM Transactions on Networking, vol. 31, no. 4, pp. 1779–1794, 2023. [30] R. T. Rockafellar, “Monotone operators and the proximal point algorithm,” SIAM journal on control and optimization, vol. 14, no. 5, pp. 877–898, 1976. [31] H. Asi and J. C. Duchi, “Stochastic (approximate) proximal point methods: Convergence, optimality, and adaptivity,” SIAM Journal on Optimization, vol. 29, no. 3, pp. 2257–2290, 2019.

15

[32] A. Beck, First-order methods in optimization. SIAM, 2017. [33] D. P. Bertsekas, “Incremental proximal methods for large scale convex optimization,” Mathematical programming, vol. 129, no. 2, pp. 163–195, 2011. [34] K.-C. Toh, M. J. Todd, and R. H. Tütüncü, “SDPT3—a MATLAB software package for semidefinite programming, version 1.3,” Optimization methods and software, vol. 11, no. 1-4, pp. 545–581, 1999. [35] Y. Ouyang, Y. Chen, G. Lan, and E. Pasiliao Jr, “An accelerated linearized alternating direction method of multipliers,” SIAM Journal on Imaging Sciences, vol. 8, no. 1, pp. 644–681, 2015. [36] X. Wang, X. Wu, Y. Sun, A. Eryilmaz, and B. Li, “Optimal realtime synchronized scheduling for collaborative content delivery,” in IEEE INFOCOM 2025-IEEE Conference on Computer Communications. IEEE, 2025, pp. 1–10. [37] M. Schmidt, N. Roux, and F. Bach, “Convergence rates of inexact proximal-gradient methods for convex optimization,” Advances in neural information processing systems, vol. 24, 2011. [38] J. O. Royset and R. J.-B. Wets, An optimization primer. Springer, 2022. [39] R. Zhu, B. Liu, D. Niu, Z. Li, and H. V. Zhao, “Network latency estimation for personal devices: A matrix completion approach,” IEEE/ACM Transactions on Networking, vol. 25, no. 2, pp. 724–737, 2016. [40] Z. Dong, J. Chen, and B. Li, “Collaborative mixed-reality-based firefighter training,” in IEEE INFOCOM 2023-IEEE Conference on Computer Communications Workshops (INFOCOM WKSHPS). IEEE, 2023, pp. 1–2. [41] S. Gualandi and G. Toscani, “Call center service times are lognormal: a fokker–planck description,” Mathematical Models and Methods in Applied Sciences, vol. 28, no. 08, pp. 1513–1527, 2018. [42] G. Zhou and M. Maas, “Learning on distributed traces for data center storage systems,” Proceedings of Machine Learning and Systems, vol. 3, pp. 350–364, 2021. [43] S. Kim, R. Pasupathy, and S. G. Henderson, “A guide to sample average approximation,” Handbook of simulation optimization, pp. 207–243, 2015.

Related documents

• Clock-Free Stochastic Scheduling for Real-Time Synchronized Content Delivery#1326010
• Models for HTTP-Adaptive-Streaming-Aware Content Distribution Network Interconnection (CDNI)#501806
• Multi-Cloud Data Synchronization Using Kafka Stream Processing Varun Kumar Tambi#113130
• Empirical Foundations for Energy-Efficient Distributed Streaming Infrastructure#370874
• HTTP Live Streaming#399332