---
title: 'DAUR Algorithm: Blockchain Metaverse Optimization'
url: https://www.emergentmind.com/topics/daur-algorithm
type: topic
---

# DAUR Algorithm: Blockchain Metaverse Optimization

Searching arXiv for the specified DAUR papers and closely related versions to ground the article in the cited literature.
The **DAUR algorithm**—**DPE-Aware User Association and Resource Allocation**—is a joint optimization framework for **blockchain-enabled Metaverse wireless communication systems** that seeks to maximize **data processing efficiency (DPE)**, defined as processed data bits divided by the sum of delay and energy consumption. It is formulated for systems in which mobile or VR users partially process tasks locally and partially offload them to edge Metaverse servers that also execute blockchain functions such as block generation, propagation, and validation. In this setting, DAUR addresses the coupled allocation of communication and computation resources, user–server association, and task partitioning under resource constraints and blockchain-induced overheads. The principal formulations and algorithmic structure are presented in "Data Processing Efficiency Aware User Association and Resource Allocation in Blockchain Enabled Metaverse over Wireless Communications" [2411.16083] and its later version "Enhancing Data Processing Efficiency in Blockchain Enabled Metaverse over Wireless Communications" [2507.04657].

## 1. Problem setting and performance objective

DAUR is designed for a **blockchain-enabled Metaverse over wireless** architecture comprising a set of users $\mathcal{N}=\{1,\dots,N\}$ and a set of Metaverse servers $\mathcal{M}=\{1,\dots,M\}$. Each user has a computation-intensive NFT or Metaverse task of size $d_n$ bits. A task can be split between local execution and server-side execution: the locally processed portion is $(1-\varphi_n)d_n$, while the offloaded portion is $\varphi_n d_n$, where $\varphi_n\in[0,1]$ is the offloading ratio [2411.16083].

The servers are modeled as joint **MEC/Metaverse nodes and blockchain participants**. They receive user data via wireless FDMA uplink, allocate CPU to offloaded Metaverse processing, and also perform blockchain-related operations associated with the processed data. These blockchain operations include **block generation**, **block propagation**, and **validation**, and they introduce additional delay and CPU consumption beyond the standard uplink-plus-edge-computing pipeline [2507.04657].

The central metric is **Data Processing Efficiency (DPE)**:
\[
\text{DPE} = \frac{\text{processed data bits}}{\text{delay} + \text{energy}}.
\]
The denominator is modeled more precisely as a weighted sum of delay and energy, with weights $\omega_t$ and $\omega_e$. On the user side, the cost is
\[
\text{cost}^{(u)}_n = \omega_t T^{(up)}_n + \omega_e E^{(up)}_n,
\]
and on the server side,
\[
\begin{aligned}
\text{cost}^{(s)}_{n,m}
&= \omega_t \bigl( T^{(ut)}_{n,m} + T^{(sp)}_{n,m} + T^{(sg)}_{n,m} + T^{(bp)}_{n,m} + T^{(sv)}_{n,m} \bigr) \\
&\quad + \omega_e \bigl( E^{(ut)}_{n,m} + E^{(sp)}_{n,m} + E^{(sg)}_{n,m} \bigr).
\end{aligned}
\]
The overall objective is a **sum of DPE ratios** across local and offloaded processing terms, weighted by user- and pair-specific preference coefficients $c_n$ and $c_{n,m}$ [2411.16083].

This formulation treats throughput, latency, and energy as a unified optimization target. The papers explicitly motivate this by noting that immersive Metaverse applications require low latency, mobile devices have limited battery and CPU, and blockchain functionality introduces extra computation and propagation delay [2507.04657].

## 2. System model and resource-coupling structure

The user side is parameterized by task size $d_n$, maximum CPU capacity $f_n$, and maximum transmit power $p_n$. Local CPU usage is controlled by $\psi_n\in[0,1]$, so the CPU assigned to local processing is $\psi_n f_n$. The corresponding local processing delay and energy are
\[
T^{(up)}_n = \frac{(1-\varphi_n)d_n\eta_n}{\psi_n f_n},
\qquad
E^{(up)}_n = \kappa_n (1-\varphi_n)d_n\eta_n (\psi_n f_n)^2.
\]
Here $\eta_n$ denotes CPU cycles per bit and $\kappa_n$ is the effective switched capacitance [2411.16083].

Wireless transmission uses **FDMA**, so no inter-user interference is assumed. If $\phi_{n,m}\in[0,1]$ is the fraction of server $m$'s bandwidth $b_m$ allocated to user $n$, and $\rho_n\in[0,1]$ is the fraction of the maximum user power $p_n$, then the uplink rate is
\[
r_{n,m} = \phi_{n,m} b_m \log_2\Bigl(1 + \frac{g_{n,m}\rho_n p_n}{\sigma^2 \phi_{n,m} b_m}\Bigr),
\]
subject to
\[
\sum_{n\in\mathcal{N}} x_{n,m}\phi_{n,m}\le 1,\quad \forall m.
\]
The transmission delay and energy for offloaded bits are
\[
T^{(ut)}_{n,m} = \frac{x_{n,m}\varphi_n d_n}{r_{n,m}},
\qquad
E^{(ut)}_{n,m} = \frac{x_{n,m}\rho_n p_n \varphi_n d_n}{r_{n,m}}.
\]
The association variable $x_{n,m}\in\{0,1\}$ satisfies $\sum_m x_{n,m}=1$, so each user is associated with exactly one server [2507.04657].

At the server side, each node $m$ has CPU capacity $f_m$ and total wireless bandwidth $b_m$. A fraction $\zeta_{n,m}\in[0,1]$ of server $m$'s CPU is assigned to user $n$, with
\[
\sum_n x_{n,m}\zeta_{n,m}\le 1,\quad \forall m.
\]
This allocation is further split by $\gamma_{n,m}\in(0,1)$ into a Metaverse data-processing share $\gamma_{n,m}\zeta_{n,m} f_m$ and a blockchain share $(1-\gamma_{n,m})\zeta_{n,m} f_m$. The server-side data-processing and block-generation terms are
\[
T^{(sp)}_{n,m} = \frac{x_{n,m}\varphi_n d_n \eta_m}{\gamma_{n,m}\zeta_{n,m} f_m},
\]
\[
E^{(sp)}_{n,m} = \kappa_m x_{n,m}\varphi_n d_n\eta_m (\gamma_{n,m}\zeta_{n,m} f_m)^2,
\]
\[
T^{(sg)}_{n,m} = \frac{x_{n,m}\varphi_n d_n \omega_b \eta_m}{(1-\gamma_{n,m})\zeta_{n,m} f_m},
\]
\[
E^{(sg)}_{n,m} = \kappa_m x_{n,m}\varphi_n d_n\eta_m \omega_b [(1-\gamma_{n,m})\zeta_{n,m}f_m]^2.
\]
Blockchain propagation and validation are represented by
\[
T^{(bp)}_{n,m} = \frac{S_b}{R_m},
\qquad
T^{(sv)}_{n,m} = \max_{m'\in \mathcal{M}\setminus\{m\}} \frac{\eta_v}{(1-\gamma_{n,m'})\zeta_{n,m'} f_{m'}}.
\]
The server interconnection rate is $R_m := \min_{m'\neq m} R_{m,m'}$ [2411.16083].

These definitions create the structural coupling that motivates DAUR. Server selection, offloading, uplink allocation, user power, local CPU usage, server CPU slicing, and blockchain processing shares are all interdependent. A server with strong radio conditions but high CPU load may degrade DPE, and conversely a lightly loaded server may be unattractive if its channel is poor or if propagation and validation overhead dominate [2507.04657].

## 3. Original optimization problem and sources of nonconvexity

The original optimization problem, denoted $\mathbb{P}_1$, maximizes the sum of local and offloaded DPE ratios over the decision variables
\[
\bm{x},\bm{\varphi},\bm{\gamma},\bm{\phi},\bm{\rho},\bm{\zeta},\bm{\psi}.
\]
Its objective is
\[
\begin{aligned}
\mathbb{P}_1:\quad \max_{\bm{x},\bm{\varphi},\bm{\gamma},\bm{\phi},\bm{\rho},\bm{\zeta},\bm{\psi}}
&\sum_{n\in\mathcal{N}} \frac{c_n(1-\varphi_n)d_n}{\text{cost}^{(u)}_n} \\
&+ \sum_{n\in\mathcal{N}}\sum_{m\in\mathcal{M}} \frac{c_{n,m}x_{n,m}\varphi_n d_n}{\text{cost}^{(s)}_{n,m}}.
\end{aligned}
\]
The constraint set includes one-server-per-user association, offloading bounds, wireless bandwidth constraints, server CPU allocation constraints, and user power/CPU usage bounds [2411.16083].

The papers identify several distinct sources of difficulty. First, the objective is a **sum of ratios**, which is nonconvex. Second, the denominator terms are nonlinear in the optimization variables and include quadratic CPU-energy expressions. Third, the uplink rate
\[
r_{n,m} = \phi_{n,m} b_m \log_2\Bigl(1 + \frac{g_{n,m}\rho_n p_n}{\sigma^2 \phi_{n,m} b_m}\Bigr)
\]
is itself nonconvex in $(\rho_n,\phi_{n,m})$. Fourth, the association variables are binary, and products such as $x_{n,m}\varphi_n$ and $x_{n,m}\zeta_{n,m}$ create a mixed-integer nonlinear structure. The resulting problem is described as **highly nonconvex and NP-hard** [2507.04657].

A common misconception would be to interpret DAUR as merely a resource allocator for an edge network with a blockchain label attached. The model used in the cited works explicitly includes blockchain-specific block generation, propagation, and validation delays and CPU costs in the server-side denominator of DPE. The algorithm is therefore constructed around a cost function that differs materially from standard MEC formulations [2411.16083].

## 4. Transformations underlying DAUR

DAUR proceeds by converting $\mathbb{P}_1$ into a sequence of problems that are tractable under alternating optimization. The first step introduces auxiliary variables $\vartheta_n^{(u)}$, $\vartheta_{n,m}^{(s)}$, $T_n^{(u)}$, and $T_{n,m}^{(s)}$ to convert ratio terms and delay expressions into inequality-constrained forms, producing an equivalent summation problem $\mathbb{P}_2$ [2507.04657].

The second step introduces Lagrange multiplier-type parameters $\alpha_n^{(u)}$ and $\alpha_{n,m}^{(s)}$, yielding problem $\mathbb{P}_3$ with objective
\[
\sum_n \alpha^{(u)}_n \big[c_n(1-\varphi_n)d_n - \vartheta^{(u)}_n \text{cost}^{(u)}_n\big]
+ \sum_{n,m}\alpha^{(s)}_{n,m} \big[c_{n,m}x_{n,m}\varphi_n d_n - \vartheta^{(s)}_{n,m} \text{cost}^{(s)}_{n,m}\big].
\]
At a KKT point,
\[
\alpha^{(u)}_n = \frac{1}{\text{cost}^{(u)}_n},\qquad
\vartheta^{(u)}_n = \frac{c_n(1-\varphi_n)d_n}{\text{cost}^{(u)}_n},
\]
with analogous expressions on the server side. The papers state that this recovers the original ratios and establishes equivalence to $\mathbb{P}_1$ at KKT points [2411.16083].

DAUR then partitions the variables into two blocks:

- **Block 1**: $\{\bm{x},\bm{\varphi},\bm{\gamma}\}$
- **Block 2**: $\{\bm{\phi},\bm{\rho},\bm{\zeta},\bm{\psi}\}$

For **Block 2**, the troublesome term $\frac{\rho_n p_n \varphi_n d_n}{r_{n,m}}$ is handled by introducing an auxiliary variable $\upsilon^{(s)}_{n,m}$ and applying a **quadratic transform** or related fractional-programming device, rewriting the term in a form that is concave in the resource-allocation variables when $\upsilon^{(s)}_{n,m}$ is fixed. This yields Problem $\mathbb{P}_5$, which is solved by an inner loop alternating between optimization over $\{\bm{\phi},\bm{\rho},\bm{\zeta},\bm{\psi},\bm{T}\}$ and updating $\bm{\upsilon}^{(s)}$ through a closed-form relation [2507.04657].

For **Block 1**, the authors use an analytical result that under $\omega_b=1$ the optimal CPU partition ratio is
\[
\gamma_{n,m}^\star = \frac{1}{2},
\]
which removes $\gamma_{n,m}$ from subsequent optimization. The remaining terms are converted into a **QCQP** through variable stacking into a vector $\bm{Q}$. This QCQP is then lifted to an **SDR** by defining a PSD matrix
\[
\bm{S} = (\bm{Q}^\top,1)^\top (\bm{Q}^\top,1),
\]
so quadratic forms become trace terms. In the journal-style presentation [2507.04657], the rank-one requirement on $\bm{S}$ is addressed through a **difference-of-convex (DC)** penalty
\[
\varpi(\text{Tr}(\bm{S}) - \|\bm{S}\|_2),
\]
with linearization of the spectral norm term around the previous iterate. In the earlier version [2411.16083], the SDR solution is followed by a projection of the relaxed association variables to a feasible discrete assignment using the **Hungarian algorithm**.

This sequence of transformations is the distinguishing algorithmic content of DAUR. It combines sum-of-ratios reformulation, alternating optimization, fractional programming, QCQP/SDR lifting, and either DC-based rank-one enforcement or SDR-plus-rounding, depending on the version considered [2411.16083; 2507.04657].

## 5. Algorithmic procedure

DAUR is presented as an outer iterative scheme with two inner subprocedures. The inputs include channel gains, CPU capacities, power limits, bandwidths, blockchain parameters, weights $\omega_t,\omega_e$, preference parameters $c_n,c_{n,m}$, and convergence tolerances $\epsilon_1,\epsilon_2,\epsilon_3$ [2507.04657].

Initialization sets
\[
\varphi_n^{(0)}=0.5,\quad
\phi_{n,m}^{(0)}=\frac{1}{N},\quad
\rho_n^{(0)}=1,\quad
\zeta_{n,m}^{(0)}=\frac{1}{N},\quad
\psi_n^{(0)}=1,\quad
\gamma_{n,m}=0.5,
\]
with an initial association matrix $\bm{x}^{(0)}$ chosen as a simple mapping such as round-robin. The initial auxiliary variables $\bm{\alpha}^{(0)}$ and $\bm{\vartheta}^{(0)}$ are then computed using their closed-form KKT relationships [2507.04657].

The outer loop proceeds as follows.

First, the algorithm runs the **resource-allocation FP loop** for fixed association and offloading decisions. At FP iteration $j$, it solves the concave problem $\mathbb{P}_5$ for $\bm{\phi}^{(i,j+1)},\bm{\rho}^{(i,j+1)},\bm{\zeta}^{(i,j+1)},\bm{\psi}^{(i,j+1)},\bm{T}^{(i,j+1)}$ using fixed $\bm{\upsilon}^{(i,j)}$, then updates $\bm{\upsilon}^{(i,j+1)}$ via
\[
\upsilon^{(s)}_{n,m} = [2x_{n,m}\rho_n p_n\varphi_n d_n r_{n,m}]^{-1}
\]
in the later exposition [2507.04657], or equivalently through the stated closed-form update in the earlier formulation [2411.16083]. The loop terminates when the relative improvement in the $\mathbb{P}_5$ objective is below $\epsilon_1$.

Second, the algorithm runs the **association/offloading optimization step** for fixed communication and compute allocations. With $\gamma_{n,m}=1/2$, the problem is turned into a QCQP and then relaxed to an SDR. In [2507.04657], the relaxed solution is iteratively refined through the DC penalty method to approximately satisfy rank one, after which a rank-one approximation of $\bm{x}$ is extracted and rounded to a binary association satisfying $\sum_m x_{n,m}=1$. The paper reports comparison among several rounding approaches—Hungarian, randomized, secondary discrete problem, and greedy—and states that **rank‑1 approximation** yields the best DPE with moderate computation. In [2411.16083], the continuous assignment is projected with the **Hungarian algorithm** to obtain a one-server-per-user discrete solution.

After both blocks have been updated, DAUR refreshes $\bm{\alpha}$ and $\bm{\vartheta}$ using the KKT-based closed forms and checks the outer stopping rule:
\[
\frac{V_{\mathbb{P}_3}(\text{new solution})}{V_{\mathbb{P}_3}(\text{previous solution})}-1 \le \epsilon_3.
\]
The final output is
\[
\bm{x}^\star,\bm{\varphi}^\star,\bm{\phi}^\star,\bm{\rho}^\star,\bm{\zeta}^\star,\bm{\psi}^\star.
\]
Both versions describe the outcome as a **stationary point** of the transformed problem, with correspondence to the original DPE maximization through the reformulation and KKT relations [2411.16083; 2507.04657].

## 6. Complexity, convergence, and numerical behavior

The reported worst-case complexity for the FP block is
\[
\mathcal{O}\bigl((N^{3.5}+M^{3.5}+N^{3.5}M^{3.5})\log(1/\epsilon_1)\bigr),
\]
and the QCQP/SDR block has a similar order with accuracy parameter $\epsilon_2$. The association reconstruction step is reported as either **Hungarian algorithm** or **rank-1 approximation via SVD**, with complexity $\mathcal{O}(N^3M^3)$. With $\mathcal{I}$ outer iterations, the total complexity is given as
\[
\mathcal{I}\times\mathcal{O}\bigl((N^{3.5}+M^{3.5}+N^{3.5}M^{3.5})\log(1/\epsilon_3)\bigr)
\]
in the later presentation [2507.04657].

The convergence claims are local rather than global. The cited works state that the individual transformation steps preserve equivalence at KKT points or yield tight relaxations; that the Block 2 subproblem is concave for fixed auxiliary variables; and that the DC procedure converges to a critical or stationary point of the penalized rank-one problem. The overall algorithm is therefore described as converging to a **stationary point** rather than a global optimum [2507.04657].

The numerical setup includes a circular cell of radius $1000$ m, random user and server placement, path loss $128.1+37.6\log_{10}(d_{n,m})$, Rayleigh fading, noise PSD $\sigma^2=-134$ dBm, server bandwidth $b_m=10$ MHz, user maximum power $p_n=0.2$ W, user CPU $f_n=1$ GHz, server CPU $f_m=20$ GHz, $\eta_n=\eta_m=279.62$, $\eta_v=737.5$, $\kappa_n=\kappa_m=10^{-27}$, task sizes between $500$ KB and $2000$ KB, block size $S_b=8$ MB, wired rate $R_m=15$ Mbps, $\omega_b=1$, and balanced weights $\omega_t=\omega_e=0.5$ [2507.04657].

The papers compare DAUR against four baselines: **RUCAA**, **GUCAA**, **AAUCO**, and **GUCRO**. Reported DPE values for the default $N=10,M=2$ case differ slightly between the two versions:

| Method | Reported DPE in [2411.16083] | Reported DPE in [2507.04657] |
|---|---:|---:|
| RUCAA | 80.78 | 80.78 |
| GUCAA | 80.38 | 80.38 |
| AAUCO | 81.87 | 83.25 |
| GUCRO | 84.82 | 84.82 |
| DAUR | 86.48 | 87.87 |

The later version explicitly attributes the difference to a refined SDP/DC approach, stating that it improves DPE and reduces QCQP iterations relative to the conference version [2507.04657].

Across sensitivity studies, DPE increases with server bandwidth, server CPU, user CPU, and user power, while DAUR remains the best-performing method among those compared. The reported delay–energy weight studies and preference-weight studies show that DPE is sensitive to the normalization induced by $\omega_t,\omega_e$ and scales with the preference coefficients $c_n,c_{n,m}$. This suggests that the absolute magnitude of DPE should be interpreted together with the chosen weighting and scaling parameters, not in isolation [2411.16083].

## 7. Assumptions, limitations, and interpretation

The stated assumptions are strong and largely centralized. DAUR presumes a controller with access to global or system-wide information such as user locations, channel gains, CPU capacities, and other resource states. Channel conditions and task arrivals are treated as static or quasi-static over the optimization horizon. The wireless model uses FDMA with no inter-user interference. The blockchain model is simplified to single-hop server interconnection with propagation and validation delays aggregated at a coarse level; detailed consensus behavior such as PoW, PoS, or leader-election dynamics is not modeled [2411.16083].

These assumptions delimit the scope of the algorithm. The cited works explicitly note several limitations: centralized optimization may create signaling burden and privacy concerns; computational complexity grows rapidly with system size; SDR and rounding or DC-based approximate rank-one recovery do not furnish global optimality; and time-varying channels, stochastic arrivals, mobility, and richer blockchain semantics are excluded [2507.04657].

The papers also identify extensions including **decentralized or distributed DAUR**, **dynamic or online DAUR**, richer blockchain modeling, utility-aware DPE formulations, learning-based policy approximation, and tighter polynomial-optimization refinements [2507.04657]. This suggests a broader interpretation of DAUR not as a single immutable solver, but as a methodological template for jointly optimizing offloading, association, and blockchain-aware resource allocation under DPE-style objectives.

Within the cited literature, DAUR is therefore best understood as a structured response to a very specific optimization problem: maximizing a bits-per-weighted-delay-and-energy objective in a blockchain-enabled Metaverse edge network where communication, computation, and blockchain overhead are explicitly coupled. Its technical significance lies in the way it decomposes a mixed-integer sum-of-ratios program into tractable subproblems through auxiliary-variable reformulation, alternating optimization, fractional programming, and semidefinite methods [2411.16083; 2507.04657].

Source: https://www.emergentmind.com/topics/daur-algorithm