<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Publishing DTD v1.1 20151215//EN" "http://jats.nlm.nih.gov/publishing/1.1/JATS-journalpublishing1.dtd">
<article xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:mml="http://www.w3.org/1998/Math/MathML" xml:lang="en" article-type="research-article" dtd-version="1.1">
<front>
<journal-meta>
<journal-id journal-id-type="pmc">CMC</journal-id>
<journal-id journal-id-type="nlm-ta">CMC</journal-id>
<journal-id journal-id-type="publisher-id">CMC</journal-id>
<journal-title-group>
<journal-title>Computers, Materials &#x0026; Continua</journal-title>
</journal-title-group>
<issn pub-type="epub">1546-2226</issn>
<issn pub-type="ppub">1546-2218</issn>
<publisher>
<publisher-name>Tech Science Press</publisher-name>
<publisher-loc>USA</publisher-loc>
</publisher>
</journal-meta>
<article-meta>
<article-id pub-id-type="publisher-id">72505</article-id>
<article-id pub-id-type="doi">10.32604/cmc.2026.072505</article-id>
<article-categories>
<subj-group subj-group-type="heading">
<subject>Article</subject>
</subj-group>
</article-categories>
<title-group>
<article-title>Heterogeneous Computing Power Scheduling Method Based on Distributed Deep Reinforcement Learning in Cloud-Edge-End Environments</article-title>
<alt-title alt-title-type="left-running-head">Heterogeneous Computing Power Scheduling Method Based on Distributed Deep Reinforcement Learning in Cloud-Edge-End Environments</alt-title>
<alt-title alt-title-type="right-running-head">Heterogeneous Computing Power Scheduling Method Based on Distributed Deep Reinforcement Learning in Cloud-Edge-End Environments</alt-title>
</title-group>
<contrib-group>
<contrib id="author-1" contrib-type="author">
<name name-style="western"><surname>Mao</surname><given-names>Jinwei</given-names></name><xref ref-type="aff" rid="aff-1">1</xref><xref ref-type="aff" rid="aff-2">2</xref></contrib>
<contrib id="author-2" contrib-type="author" corresp="yes">
<name name-style="western"><surname>Luo</surname><given-names>Wang</given-names></name><xref ref-type="aff" rid="aff-1">1</xref><xref ref-type="aff" rid="aff-2">2</xref><email>luowang@sgepri.sgcc.com.cn</email></contrib>
<contrib id="author-3" contrib-type="author">
<name name-style="western"><surname>Xu</surname><given-names>Jiangtao</given-names></name><xref ref-type="aff" rid="aff-3">3</xref></contrib>
<contrib id="author-4" contrib-type="author">
<name name-style="western"><surname>Zhu</surname><given-names>Daohua</given-names></name><xref ref-type="aff" rid="aff-3">3</xref></contrib>
<contrib id="author-5" contrib-type="author">
<name name-style="western"><surname>Liang</surname><given-names>Wei</given-names></name><xref ref-type="aff" rid="aff-3">3</xref></contrib>
<contrib id="author-6" contrib-type="author">
<name name-style="western"><surname>Huang</surname><given-names>Zhechen</given-names></name><xref ref-type="aff" rid="aff-3">3</xref></contrib>
<contrib id="author-7" contrib-type="author">
<name name-style="western"><surname>Feng</surname><given-names>Bao</given-names></name><xref ref-type="aff" rid="aff-1">1</xref><xref ref-type="aff" rid="aff-2">2</xref></contrib>
<contrib id="author-8" contrib-type="author">
<name name-style="western"><surname>Yang</surname><given-names>Shuang</given-names></name><xref ref-type="aff" rid="aff-1">1</xref><xref ref-type="aff" rid="aff-2">2</xref></contrib>
<aff id="aff-1"><label>1</label><institution>State Grid Electric Power Research Institute Co., Ltd.</institution>, <addr-line>Nanjing</addr-line>, <country>China</country></aff>
<aff id="aff-2"><label>2</label><institution>Nanjing Nari Information &#x0026; Communication Technology Co., Ltd.</institution>, <addr-line>Nanjing</addr-line>, <country>China</country></aff>
<aff id="aff-3"><label>3</label><institution>State Grid Jiangsu Electric Power Co., Ltd. Research Institute</institution>, <addr-line>Nanjing</addr-line>, <country>China</country></aff>
</contrib-group>
<author-notes>
<corresp id="cor1"><label>&#x002A;</label>Corresponding Author: Wang Luo. Email: <email>luowang@sgepri.sgcc.com.cn</email></corresp>
</author-notes>
<pub-date date-type="collection" publication-format="electronic">
<year>2026</year>
</pub-date>
<pub-date date-type="pub" publication-format="electronic">
<day>12</day><month>3</month><year>2026</year>
</pub-date>
<volume>87</volume>
<issue>2</issue>
<elocation-id>85</elocation-id>
<history>
<date date-type="received">
<day>28</day>
<month>08</month>
<year>2025</year>
</date>
<date date-type="accepted">
<day>15</day>
<month>12</month>
<year>2025</year>
</date>
</history>
<permissions>
<copyright-statement>&#x00A9; 2026 The Authors. Published by Tech Science Press.</copyright-statement>
<copyright-year>2026</copyright-year>
<copyright-holder>The Authors</copyright-holder>
<license xlink:href="https://creativecommons.org/licenses/by/4.0/">
<license-p>This work is licensed under a <ext-link ext-link-type="uri" xlink:type="simple" xlink:href="https://creativecommons.org/licenses/by/4.0/">Creative Commons Attribution 4.0 International License</ext-link>, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.</license-p>
</license>
</permissions>
<self-uri content-type="pdf" xlink:href="TSP_CMC_72505.pdf"></self-uri>
<abstract>
<p>With the rapid development of power Internet of Things (IoT) scenarios such as smart factories and smart homes, numerous intelligent terminal devices and real-time interactive applications impose higher demands on computing latency and resource supply efficiency. Multi-access edge computing technology deploys cloud computing capabilities at the network edge; constructs distributed computing nodes and multi-access systems and offers infrastructure support for services with low latency and high reliability. Existing research relies on a strong assumption that the environmental state is fully observable and fails to thoroughly consider the continuous time-varying features of edge server load fluctuations, leading to insufficient adaptability of the model in a heterogeneous dynamic environment. Thus, this paper establishes a framework for end-edge collaborative task offloading based on a partially observable Markov decision-making process (POMDP) and proposes a method for end-edge collaborative task offloading in heterogeneous scenarios. It achieves time-series modeling of the historical load characteristics of edge servers and endows the agent with the ability to be aware of the load in dynamic environmental states. Moreover, by dynamically assessing the exploration value of historical trajectories in the central trajectory pool and adjusting the sample weight distribution, directional exploration and strategy optimization of high-value trajectories are realized. Experimental results indicate that the proposed method exhibits distinct advantages compared with existing methods in terms of average delay and task failure rate and also verifies the method&#x2019;s robustness in a dynamic environment.</p>
</abstract>
<kwd-group kwd-group-type="author">
<kwd>Edge computing</kwd>
<kwd>end-edge collaboration</kwd>
<kwd>heterogeneous computing power scheduling</kwd>
<kwd>resource allocation</kwd>
</kwd-group>
<funding-group>
<award-group id="awg1">
<funding-source>State Grid Corporation Science and Technology Project</funding-source>
<award-id>5700-202318596A-3-2-ZN</award-id>
</award-group>
</funding-group>
</article-meta>
</front>
<body>
<sec id="s1">
<label>1</label>
<title>Introduction</title>
<p>With the rapid advancement of next-generation information technologies, exemplified by applications like smart factories, smart homes, and the Internet of Vehicles, the number of terminal devices worldwide has grown exponentially [<xref ref-type="bibr" rid="ref-1">1</xref>]. According to International Data Corporation, the number of global Internet of Things (IoT) device connections is projected to exceed 41 billion by 2027 [<xref ref-type="bibr" rid="ref-2">2</xref>]. This explosive growth in device scale spurs complex and diverse network access requirements: industrial robots on production floors enable real-time control via ultra-reliable low-latency communication (URLLC); smart home appliances rely on Wi-Fi to construct high-density IoT networks; and autonomous vehicles on urban roads require integration of cellular networks and roadside units for collaborative perception [<xref ref-type="bibr" rid="ref-3">3</xref>]. The data deluge from massive terminal devices presents additional challenges to the existing cloud computing paradigm. Although the cloud computing model offers powerful centralized processing capabilities, its inherent geographical distribution causes significant increases in transmission latency, failing to adequately support real-time-sensitive applications [<xref ref-type="bibr" rid="ref-4">4</xref>]. To address these issues, multi-access edge computing (MEC) has emerged as a computing paradigm that complements traditional cloud computing models [<xref ref-type="bibr" rid="ref-5">5</xref>]. MEC&#x2019;s core concept is to offload computing tasks from terminal devices to the network edge via diverse access technologies, enabling flexible computing power scheduling to meet the low-latency requirements for compute-intensive applications in multi-access scenarios (e.g., smart factories, smart homes) [<xref ref-type="bibr" rid="ref-6">6</xref>]. It distributes data processing across edge servers [<xref ref-type="bibr" rid="ref-7">7</xref>], allowing users to compute near data sources via multiple access methods, thus reducing transmission latency and accelerating computation. By distributing computing resources at the network edge, MEC is better able to adapt to diverse service requirements and reduces the risk of network outages [<xref ref-type="bibr" rid="ref-8">8</xref>].</p>
<p>While MEC exhibits significant development potential, it faces substantial challenges in practical applications, with heterogeneous computing power scheduling being the most prominent [<xref ref-type="bibr" rid="ref-9">9</xref>]. In smart scenarios, massive data generated by terminal devices no longer needs to be uploaded to the cloud for processing-reducing the core network&#x2019;s transmission burden but imposing higher demands on the resource management of edge nodes [<xref ref-type="bibr" rid="ref-10">10</xref>]. MEC nodes have limited resources yet serve a large number of terminal devices [<xref ref-type="bibr" rid="ref-11">11</xref>]; tasks must be distributed and scheduled based on their type and scale to prevent excessive loads on specific edge nodes from degrading system performance and user experience.</p>
<p>Significant progress has been achieved in optimizing heterogeneous computing power scheduling in MEC environments, with related studies continuously refining scheduling algorithms via deep reinforcement learning (DRL) and other methods [<xref ref-type="bibr" rid="ref-12">12</xref>]. As a specialized machine learning paradigm, DRL models systems based on Markov decision processes (MDPs) [<xref ref-type="bibr" rid="ref-13">13</xref>], enabling algorithms to adjust decisions based on environmental feedback during continuous trial-and-error-exhibiting strong performance in decision-making tasks. In MEC scenarios, DRL algorithms can dynamically adjust heterogeneous computing power scheduling strategies based on real-time edge node load, task urgency, and other key factors to achieve efficient resource utilization [<xref ref-type="bibr" rid="ref-14">14</xref>].</p>
<p>However, with the continuous emergence of diverse smart devices and the increasing number of terminal devices, edge networks exhibit highly dynamic environments, where edge server status (e.g., load) changes continuously over time. Against this backdrop, existing research has limitations: most algorithms assume that edge server load status can be fully acquired and updated in real time-an assumption hard to realize in practice due to monitoring overhead and privacy protection constraints. Thus, this paper leverages DRL to investigate heterogeneous computing power scheduling in MEC environments, aiming to optimize scheduling efficiency and service continuity while improving the quality of service (QoS).</p>
</sec>
<sec id="s2">
<label>2</label>
<title>Related Work</title>
<p>As the core technical support of the MEC system, the optimization level of the heterogeneous computing power scheduling strategy directly determines the quality of system services [<xref ref-type="bibr" rid="ref-15">15</xref>]. The heterogeneous computing power scheduling strategy not only needs to comprehensively consider multi-dimensional parameters such as the real-time load status of edge servers, network transmission quality, and task computing latency, but also needs to achieve a fine balance between resource utilization, cost-effectiveness, and service quality. Heterogeneous computing power scheduling enables edge servers and users to focus on their respective core businesses, thereby maximizing resource utilization, reducing costs, and enhancing overall service performance [<xref ref-type="bibr" rid="ref-16">16</xref>].</p>
<p>In recent years, machine learning techniques have shown significant advantages in the field of load optimization for complex systems. Especially in the edge computing scenario, the task offloading decision faces a highly dynamic and heterogeneous complex system environment, involving the contradiction between multi-dimensional resource constraints (of terminal devices, communication links, and edge nodes) and real-time requirements, which poses a modeling bottleneck for meta-heuristic algorithms. In this context, DRL can simultaneously model the relationships among network bandwidth fluctuations, server load, and task priority by constructing an end-to-end &#x201C;state-action-reward&#x201D; decision-making optimization framework, and its online learning characteristics provide a new technical path for adaptive task offloading in complex edge environments.</p>
<p>Zhang et al. [<xref ref-type="bibr" rid="ref-9">9</xref>] proposed a heterogeneous task collaborative offloading scheme for satellite edge computing, which effectively reduces satellite energy consumption and improves task processing efficiency through a ground-satellite-cloud multi-layer architecture and dynamic threshold strategy. Gao et al. [<xref ref-type="bibr" rid="ref-17">17</xref>] proposed a DRL-based algorithm with continuous convex approximation for hybrid UAV-assisted systems, optimizing service assignment, task segmentation, UAV trajectories, resources, and transmission power to reduce energy consumption. Cai et al. [<xref ref-type="bibr" rid="ref-18">18</xref>] designed a framework based on the Double Deep <italic>Q</italic>-Network (DDQN), along with a resource tree model and multi-granular task decomposition, for cloud-edge-device networks, aiming to optimize task decomposition, hierarchical scheduling, and maximize latency-energy utility. Chen et al. [<xref ref-type="bibr" rid="ref-19">19</xref>] developed an online convolutional DRL algorithm for Non-Orthogonal Multiple Access (NOMA) enabled edge networks, decoupling the minimization of system computing completion time into duration and resource allocation sub-problems. Fan et al. [<xref ref-type="bibr" rid="ref-20">20</xref>] presented a dual-delay deep deterministic policy gradient algorithm for in-vehicle edge computing, using road side unit (RSU) collaboration to optimize task offloading and resource allocation, cutting down delay and energy use. Guo et al. [<xref ref-type="bibr" rid="ref-21">21</xref>] put forward a fuzzy trust-enhanced, DRL-driven scheme for vehicle-mounted edge networks, optimizing offloading delay and task processing credibility. Li et al. [<xref ref-type="bibr" rid="ref-22">22</xref>] built a pre-determined multi-agent DRL offloading mechanism for resource-constrained edges to maximize user experience quality. Li et al. [<xref ref-type="bibr" rid="ref-23">23</xref>] proposed a Lyapunov- and multi-agent deep deterministic policy gradient-based two-stage offloading architecture for distributed environments, minimizing subsystem delay through joint initial and RSU peer-to-peer offloading while considering RSU energy constraints. Lin et al. [<xref ref-type="bibr" rid="ref-24">24</xref>] formalized decentralized edge task offloading as partially observable Markov decision-making process (POMDP), leveraging heuristic logs to warm-up and fine-tune a DRL model, enhancing task success and solving cold-start issues. Liu et al. [<xref ref-type="bibr" rid="ref-25">25</xref>] constructed a two-time-scale multi-dimensional resource optimization model with a dual-actor deep deterministic strategy gradient for edge networks, reducing long-term delay and cache costs. Liu et al. [<xref ref-type="bibr" rid="ref-26">26</xref>] proposed a predictive Deep <italic>Q</italic>-Network (DQN) for resource allocation and computation offloading (PQ-RACO) algorithm and a multi-agent DQN for resource allocation and computation offloading (MQ-RACO) algorithm for the dynamic edge networks, which optimize offloading decisions and power allocation via agent behavior prediction and explicit reward design to maximize computing rates.</p>
<p>When applying DRL to construct a task offloading model, the existing research fails to effectively model the dynamic characteristics in large-scale terminal device scenarios:</p>
<p>(1) When the number of terminal devices surges, the load fluctuation of edge servers, the instantaneous change of network link state, and the heterogeneity of computing resources will lead to the high dynamic time variation of the system, which significantly reduces the stability of the state transition probability in the Markov Decision Process (MDP) based framework and makes it challenging to ensure the strategy convergence.</p>
<p>(2) The state space dimensional explosion and the complexity of action space combination caused by massive device access have forced the algorithm to frequently retrain the model and update the policy parameters, which not only causes the exponential increase of computing overhead, but also aggravates the system&#x2019;s dynamic imbalance due to the real-time response lag. The over-reliance on the dynamic Markov assumption and the scalability defect of the high-dimensional state-action space seriously restrict the practical value of the algorithm in ultra-large-scale edge computing scenarios.</p>
</sec>
<sec id="s3">
<label>3</label>
<title>System Model</title>
<p>This section abstracts the MEC system into three layers, as illustrated in <xref ref-type="fig" rid="fig-1">Fig. 1</xref>. The first layer is a third-party trusted authority, geographically remote from terminal devices, which primarily stores task offloading-related terminal device information. The second layer comprises edge nodes, including edge servers, base stations, and other edge network access points, where edge servers are equipped with sufficient computing resources; base stations are responsible for direct communication with terminal devices within their coverage area, handling wireless signal transmission and reception; and edge network access points integrate fixed-network-connected devices into the edge network. The third layer consists of a large number of terminal devices-typically resource-constrained devices enabled by the Industrial IoT and smart city initiatives. As shown in the figure, devices in the MEC environment include IIoT terminal devices and mobile robots connected via 5G, smart home devices connected via Wi-Fi access points, environmental monitoring sensors in smart cities connected via wired networks, and other smart devices using fixed broadband or Wi-Fi.</p>
<fig id="fig-1">
<label>Figure 1</label>
<caption>
<title>An overall cloud-edge-end collaboration task offloading scenario.</title>
</caption>
<graphic mimetype="image" mime-subtype="tif" xlink:href="CMC_72505-fig-1.tif"/>
</fig>
<p>This section focuses on a MEC environment involving a set of edge servers denoted as <inline-formula id="ieqn-1"><mml:math id="mml-ieqn-1"><mml:mi>E</mml:mi><mml:mo>=</mml:mo><mml:mo fence="false" stretchy="false">{</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mn>2</mml:mn><mml:mo>,</mml:mo><mml:mo>&#x22EF;</mml:mo><mml:mo>,</mml:mo><mml:mi>e</mml:mi><mml:mo fence="false" stretchy="false">}</mml:mo></mml:math></inline-formula> and a set of terminal devices denoted as <inline-formula id="ieqn-2"><mml:math id="mml-ieqn-2"><mml:mi>D</mml:mi><mml:mo>=</mml:mo><mml:mo fence="false" stretchy="false">{</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mn>2</mml:mn><mml:mo>,</mml:mo><mml:mo>&#x22EF;</mml:mo><mml:mo>,</mml:mo><mml:mi>d</mml:mi><mml:mo fence="false" stretchy="false">}</mml:mo></mml:math></inline-formula>. It specifically addresses task offloading over a set of time slots <inline-formula id="ieqn-3"><mml:math id="mml-ieqn-3"><mml:mi>T</mml:mi><mml:mo>=</mml:mo><mml:mo fence="false" stretchy="false">{</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mo>&#x22EF;</mml:mo><mml:mo>,</mml:mo><mml:mi>t</mml:mi><mml:mo fence="false" stretchy="false">}</mml:mo></mml:math></inline-formula>, where each time slot has a short duration <inline-formula id="ieqn-4"><mml:math id="mml-ieqn-4"><mml:mi>&#x03B4;</mml:mi></mml:math></inline-formula> (in seconds).</p>
<sec id="s3_1">
<label>3.1</label>
<title>Task Model</title>
<p>Assume a new task arrives at a terminal device at the start of a time slot. Let <inline-formula id="ieqn-5"><mml:math id="mml-ieqn-5"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> denote the unique index of the task arriving at the <inline-formula id="ieqn-6"><mml:math id="mml-ieqn-6"><mml:mi>d</mml:mi></mml:math></inline-formula>-th terminal device during time slot <inline-formula id="ieqn-7"><mml:math id="mml-ieqn-7"><mml:mi>t</mml:mi></mml:math></inline-formula>. For generality, <inline-formula id="ieqn-8"><mml:math id="mml-ieqn-8"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> if no new task arrives at terminal <inline-formula id="ieqn-9"><mml:math id="mml-ieqn-9"><mml:mi>d</mml:mi></mml:math></inline-formula> in that time slot.</p>
<p>Let <inline-formula id="ieqn-10"><mml:math id="mml-ieqn-10"><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> denote the data size (in bits) of newly arrived task <inline-formula id="ieqn-11"><mml:math id="mml-ieqn-11"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, with <inline-formula id="ieqn-12"><mml:math id="mml-ieqn-12"><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> if no new task arrives at terminal <inline-formula id="ieqn-13"><mml:math id="mml-ieqn-13"><mml:mi>d</mml:mi></mml:math></inline-formula>. Tasks have distinct processing densities <inline-formula id="ieqn-14"><mml:math id="mml-ieqn-14"><mml:msub><mml:mi>&#x03C1;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula> (CPU cycles per bit). Each task also has a latency constraint <inline-formula id="ieqn-15"><mml:math id="mml-ieqn-15"><mml:msub><mml:mi>&#x03C4;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula> (in time slots): task <inline-formula id="ieqn-16"><mml:math id="mml-ieqn-16"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> is discarded if not fully processed by the end of time slot <inline-formula id="ieqn-17"><mml:math id="mml-ieqn-17"><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:msub><mml:mi>&#x03C4;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn></mml:math></inline-formula>.</p>
</sec>
<sec id="s3_2">
<label>3.2</label>
<title>Transmission Model</title>
<p>Edge servers use non-overlapping frequency bands, eliminating uplink interference between them. Let <inline-formula id="ieqn-18"><mml:math id="mml-ieqn-18"><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msub><mml:mi>h</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:msup><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mn>2</mml:mn></mml:msup></mml:math></inline-formula> represent the channel gain from terminal <inline-formula id="ieqn-19"><mml:math id="mml-ieqn-19"><mml:mi>d</mml:mi></mml:math></inline-formula> to edge server <inline-formula id="ieqn-20"><mml:math id="mml-ieqn-20"><mml:mi>e</mml:mi></mml:math></inline-formula>, and <inline-formula id="ieqn-21"><mml:math id="mml-ieqn-21"><mml:msub><mml:mi>p</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula> denote terminal <inline-formula id="ieqn-22"><mml:math id="mml-ieqn-22"><mml:mi>d</mml:mi></mml:math></inline-formula>&#x2019;s transmission power when communicating with edge server <inline-formula id="ieqn-23"><mml:math id="mml-ieqn-23"><mml:mi>e</mml:mi></mml:math></inline-formula>.</p>
<p>The transmission rate from terminal <inline-formula id="ieqn-24"><mml:math id="mml-ieqn-24"><mml:mi>d</mml:mi></mml:math></inline-formula> to edge server <inline-formula id="ieqn-25"><mml:math id="mml-ieqn-25"><mml:mi>e</mml:mi></mml:math></inline-formula> is <inline-formula id="ieqn-26"><mml:math id="mml-ieqn-26"><mml:msubsup><mml:mi>O</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup></mml:math></inline-formula>, given by:
<disp-formula id="eqn-1"><label>(1)</label><mml:math id="mml-eqn-1" display="block"><mml:msubsup><mml:mi>O</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo>=</mml:mo><mml:mi>B</mml:mi><mml:msub><mml:mi>log</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo>&#x2061;</mml:mo><mml:mrow><mml:mo>(</mml:mo><mml:mn>1</mml:mn><mml:mo>+</mml:mo><mml:mfrac><mml:mrow><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msub><mml:mi>h</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:msup><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mn>2</mml:mn></mml:msup><mml:msub><mml:mi>p</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub></mml:mrow><mml:msup><mml:mi>&#x03C3;</mml:mi><mml:mn>2</mml:mn></mml:msup></mml:mfrac><mml:mo>)</mml:mo></mml:mrow><mml:mo>,</mml:mo><mml:mspace width="1em" /><mml:mi>d</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mi>D</mml:mi><mml:mo>,</mml:mo><mml:mspace width="thinmathspace" /><mml:mi>e</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mi>E</mml:mi></mml:math></disp-formula>where <italic>B</italic> is the channel bandwidth and <inline-formula id="ieqn-27"><mml:math id="mml-ieqn-27"><mml:msup><mml:mi>&#x03C3;</mml:mi><mml:mn>2</mml:mn></mml:msup></mml:math></inline-formula> is the channel noise power.</p>
<p>At the start of a time slot, if the local computing capacity of terminal <inline-formula id="ieqn-28"><mml:math id="mml-ieqn-28"><mml:mi>d</mml:mi></mml:math></inline-formula> is insufficient for task <inline-formula id="ieqn-29"><mml:math id="mml-ieqn-29"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, <inline-formula id="ieqn-30"><mml:math id="mml-ieqn-30"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> denotes the time slot when the task is transmitted (to an edge server) or discarded (if offloading fails). If the task is processed locally or no task arrives, <inline-formula id="ieqn-31"><mml:math id="mml-ieqn-31"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> (with <inline-formula id="ieqn-32"><mml:math id="mml-ieqn-32"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mn>0</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula>).</p>
<p>Let <inline-formula id="ieqn-33"><mml:math id="mml-ieqn-33"><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (in time slots) represent the waiting time for transmission of task <inline-formula id="ieqn-34"><mml:math id="mml-ieqn-34"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, determined by prior transmission slots <inline-formula id="ieqn-35"><mml:math id="mml-ieqn-35"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (where <inline-formula id="ieqn-36"><mml:math id="mml-ieqn-36"><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>&#x003C;</mml:mo><mml:mi>t</mml:mi></mml:math></inline-formula>) as:
<disp-formula id="eqn-2"><label>(2)</label><mml:math id="mml-eqn-2" display="block"><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mo movablelimits="true" form="prefix">max</mml:mo><mml:mrow><mml:mo>{</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">sup</mml:mo><mml:mrow><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>&#x2208;</mml:mo><mml:mo fence="false" stretchy="false">{</mml:mo><mml:mn>0</mml:mn><mml:mo>,</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mo>&#x2026;</mml:mo><mml:mo>,</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo fence="false" stretchy="false">}</mml:mo></mml:mrow></mml:munder><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mspace width="thinmathspace" /><mml:mn>0</mml:mn><mml:mo>}</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>If task <inline-formula id="ieqn-37"><mml:math id="mml-ieqn-37"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> starts waiting for transmission in a time slot, <inline-formula id="ieqn-38"><mml:math id="mml-ieqn-38"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (the time slot when transmission completes or the task is discarded) is calculated as:
<disp-formula id="eqn-3"><label>(3)</label><mml:math id="mml-eqn-3" display="block"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mo movablelimits="true" form="prefix">min</mml:mo><mml:mrow><mml:mo>{</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>+</mml:mo><mml:mrow><mml:mo>&#x230A;</mml:mo><mml:munder><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:mi>e</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mi>E</mml:mi></mml:mrow></mml:munder><mml:mfrac><mml:mrow><mml:msub><mml:mi>y</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:mrow><mml:mrow><mml:mi>&#x03B4;</mml:mi><mml:msubsup><mml:mi>O</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup></mml:mrow></mml:mfrac><mml:mo>&#x230B;</mml:mo></mml:mrow><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mspace width="thinmathspace" /><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:msub><mml:mi>&#x03C4;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo>}</mml:mo></mml:mrow></mml:math></disp-formula>where <inline-formula id="ieqn-39"><mml:math id="mml-ieqn-39"><mml:msub><mml:mi>y</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>1</mml:mn></mml:math></inline-formula> indicates that task <inline-formula id="ieqn-40"><mml:math id="mml-ieqn-40"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> is offloaded to edge server <inline-formula id="ieqn-41"><mml:math id="mml-ieqn-41"><mml:mi>e</mml:mi></mml:math></inline-formula>, and <inline-formula id="ieqn-42"><mml:math id="mml-ieqn-42"><mml:msub><mml:mi>y</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> otherwise.</p>
</sec>
<sec id="s3_3">
<label>3.3</label>
<title>Computational Models</title>
<p>When a new task <inline-formula id="ieqn-43"><mml:math id="mml-ieqn-43"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> arrives at terminal <inline-formula id="ieqn-44"><mml:math id="mml-ieqn-44"><mml:mi>d</mml:mi></mml:math></inline-formula> in a time slot, the terminal must decide whether to process the task locally or offload it to an edge server.</p>
<p>The indicator <inline-formula id="ieqn-45"><mml:math id="mml-ieqn-45"><mml:msub><mml:mi>x</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> specifies whether task <inline-formula id="ieqn-46"><mml:math id="mml-ieqn-46"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> is processed locally (<inline-formula id="ieqn-47"><mml:math id="mml-ieqn-47"><mml:msub><mml:mi>x</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>1</mml:mn></mml:math></inline-formula>) or offloaded to the edge (<inline-formula id="ieqn-48"><mml:math id="mml-ieqn-48"><mml:msub><mml:mi>x</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula>). Here, <inline-formula id="ieqn-49"><mml:math id="mml-ieqn-49"><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:msub><mml:mi>x</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> represents the data volume processed locally, and <inline-formula id="ieqn-50"><mml:math id="mml-ieqn-50"><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">(</mml:mo><mml:mn>1</mml:mn><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>x</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> represents the data volume transmitted to edge servers.</p>
<p>If task <inline-formula id="ieqn-51"><mml:math id="mml-ieqn-51"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> is offloaded to edge server <inline-formula id="ieqn-52"><mml:math id="mml-ieqn-52"><mml:mi>e</mml:mi></mml:math></inline-formula>, <inline-formula id="ieqn-53"><mml:math id="mml-ieqn-53"><mml:msub><mml:mi>y</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>1</mml:mn></mml:math></inline-formula> (0 otherwise). Each task can only be offloaded to one edge server, so:
<disp-formula id="eqn-4"><label>(4)</label><mml:math id="mml-eqn-4" display="block"><mml:munder><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:mi>e</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mi>E</mml:mi></mml:mrow></mml:munder><mml:msub><mml:mi>y</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mrow><mml:mo>{</mml:mo><mml:mtable columnalign="left left" rowspacing=".2em" columnspacing="1em" displaystyle="false"><mml:mtr><mml:mtd><mml:mn>1</mml:mn></mml:mtd><mml:mtd><mml:mrow><mml:mtext>if&#xA0;</mml:mtext></mml:mrow><mml:msub><mml:mi>x</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn><mml:mo>,</mml:mo></mml:mtd></mml:mtr><mml:mtr><mml:mtd><mml:mn>0</mml:mn></mml:mtd><mml:mtd><mml:mrow><mml:mtext>if&#xA0;</mml:mtext></mml:mrow><mml:msub><mml:mi>x</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2260;</mml:mo><mml:mn>0.</mml:mn></mml:mtd></mml:mtr></mml:mtable><mml:mo fence="true" stretchy="true" symmetric="true"></mml:mo></mml:mrow></mml:math></disp-formula></p>
<sec id="s3_3_1">
<label>3.3.1</label>
<title>Local Computing</title>
<p>Let <inline-formula id="ieqn-54"><mml:math id="mml-ieqn-54"><mml:msub><mml:mi>f</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula> denote the computing capacity of terminal <inline-formula id="ieqn-55"><mml:math id="mml-ieqn-55"><mml:mi>d</mml:mi></mml:math></inline-formula>. For time slot <inline-formula id="ieqn-56"><mml:math id="mml-ieqn-56"><mml:mi>t</mml:mi></mml:math></inline-formula>, <inline-formula id="ieqn-57"><mml:math id="mml-ieqn-57"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> denotes the time slot when task <inline-formula id="ieqn-58"><mml:math id="mml-ieqn-58"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> is processed locally or discarded; <inline-formula id="ieqn-59"><mml:math id="mml-ieqn-59"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> if the task is not processed locally (e.g., <inline-formula id="ieqn-60"><mml:math id="mml-ieqn-60"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula>).</p>
<p>Let <inline-formula id="ieqn-61"><mml:math id="mml-ieqn-61"><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> represent the waiting time for local processing of the task <inline-formula id="ieqn-62"><mml:math id="mml-ieqn-62"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, determined by prior local processing slots <inline-formula id="ieqn-63"><mml:math id="mml-ieqn-63"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (where <inline-formula id="ieqn-64"><mml:math id="mml-ieqn-64"><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>&#x003C;</mml:mo><mml:mi>t</mml:mi></mml:math></inline-formula>) as:
<disp-formula id="eqn-5"><label>(5)</label><mml:math id="mml-eqn-5" display="block"><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mo movablelimits="true" form="prefix">max</mml:mo><mml:mrow><mml:mo>{</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">sup</mml:mo><mml:mrow><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>&#x2208;</mml:mo><mml:mo fence="false" stretchy="false">{</mml:mo><mml:mn>0</mml:mn><mml:mo>,</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mo>&#x2026;</mml:mo><mml:mo>,</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo fence="false" stretchy="false">}</mml:mo></mml:mrow></mml:munder><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mspace width="thinmathspace" /><mml:mn>0</mml:mn><mml:mo>}</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>If task <inline-formula id="ieqn-65"><mml:math id="mml-ieqn-65"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> starts waiting for local processing in a time slot, <inline-formula id="ieqn-66"><mml:math id="mml-ieqn-66"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (the time slot when processing completes or the task is discarded) is:
<disp-formula id="eqn-6"><label>(6)</label><mml:math id="mml-eqn-6" display="block"><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mo movablelimits="true" form="prefix">min</mml:mo><mml:mrow><mml:mo>{</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>+</mml:mo><mml:mrow><mml:mo>&#x230A;</mml:mo><mml:mfrac><mml:mrow><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:msub><mml:mi>&#x03C1;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:mrow><mml:mrow><mml:mi>&#x03B4;</mml:mi><mml:msub><mml:mi>f</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:mfrac><mml:mo>&#x230B;</mml:mo></mml:mrow><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mspace width="thinmathspace" /><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:msub><mml:mi>&#x03C4;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo>}</mml:mo></mml:mrow></mml:math></disp-formula></p>
</sec>
<sec id="s3_3_2">
<label>3.3.2</label>
<title>Task Offloading</title>
<p>Each edge server <inline-formula id="ieqn-67"><mml:math id="mml-ieqn-67"><mml:mi>e</mml:mi></mml:math></inline-formula> maintains a computation queue for each terminal <inline-formula id="ieqn-68"><mml:math id="mml-ieqn-68"><mml:mi>d</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mi>D</mml:mi></mml:math></inline-formula>. Let <inline-formula id="ieqn-69"><mml:math id="mml-ieqn-69"><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> be the unique index of the task from <inline-formula id="ieqn-70"><mml:math id="mml-ieqn-70"><mml:mi>d</mml:mi></mml:math></inline-formula> added to <inline-formula id="ieqn-71"><mml:math id="mml-ieqn-71"><mml:mi>e</mml:mi></mml:math></inline-formula>&#x2019;s queue at the start of time slot <inline-formula id="ieqn-72"><mml:math id="mml-ieqn-72"><mml:mi>t</mml:mi></mml:math></inline-formula> (<inline-formula id="ieqn-73"><mml:math id="mml-ieqn-73"><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> if no such task exists). Let <inline-formula id="ieqn-74"><mml:math id="mml-ieqn-74"><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (in bits) be the task&#x2019;s data size (<inline-formula id="ieqn-75"><mml:math id="mml-ieqn-75"><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> if no task arrives).</p>
<p>Edge server computation queues follow First-In-First-Out (FIFO). Let <inline-formula id="ieqn-76"><mml:math id="mml-ieqn-76"><mml:msub><mml:mi>q</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (in bits) be the length of the queue of <inline-formula id="ieqn-77"><mml:math id="mml-ieqn-77"><mml:mi>d</mml:mi></mml:math></inline-formula> in <inline-formula id="ieqn-78"><mml:math id="mml-ieqn-78"><mml:mi>e</mml:mi></mml:math></inline-formula> at the end of time slot <inline-formula id="ieqn-79"><mml:math id="mml-ieqn-79"><mml:mi>t</mml:mi></mml:math></inline-formula>. Let <inline-formula id="ieqn-80"><mml:math id="mml-ieqn-80"><mml:msub><mml:mi>q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> denote the set of non-empty queues in <inline-formula id="ieqn-81"><mml:math id="mml-ieqn-81"><mml:mi>e</mml:mi></mml:math></inline-formula> at time slot <inline-formula id="ieqn-82"><mml:math id="mml-ieqn-82"><mml:mi>t</mml:mi></mml:math></inline-formula>:
<disp-formula id="eqn-7"><label>(7)</label><mml:math id="mml-eqn-7" display="block"><mml:msub><mml:mi>q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mrow><mml:mo>{</mml:mo><mml:mi>d</mml:mi><mml:mo>&#x2223;</mml:mo><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x003E;</mml:mo><mml:mn>0</mml:mn><mml:mo>&#x2228;</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x003E;</mml:mo><mml:mn>0</mml:mn><mml:mo>}</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>Let <inline-formula id="ieqn-83"><mml:math id="mml-ieqn-83"><mml:msub><mml:mi>Q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msub><mml:mi>q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:math></inline-formula> be the count of non-empty queues in <inline-formula id="ieqn-84"><mml:math id="mml-ieqn-84"><mml:mi>e</mml:mi></mml:math></inline-formula> in time slot <inline-formula id="ieqn-85"><mml:math id="mml-ieqn-85"><mml:mi>t</mml:mi></mml:math></inline-formula>.</p>
<p>Let <inline-formula id="ieqn-86"><mml:math id="mml-ieqn-86"><mml:msub><mml:mi>f</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:math></inline-formula> (in CPU cycles per second) be computing capacity of edge server <inline-formula id="ieqn-87"><mml:math id="mml-ieqn-87"><mml:mi>e</mml:mi></mml:math></inline-formula>. Let <inline-formula id="ieqn-88"><mml:math id="mml-ieqn-88"><mml:mi>d</mml:mi><mml:mi>r</mml:mi><mml:mi>o</mml:mi><mml:msub><mml:mi>p</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (in bits) be the data dropped from <inline-formula id="ieqn-89"><mml:math id="mml-ieqn-89"><mml:mi>d</mml:mi></mml:math></inline-formula>&#x2019;s queue on <inline-formula id="ieqn-90"><mml:math id="mml-ieqn-90"><mml:mi>e</mml:mi></mml:math></inline-formula> at the end of the time slot <inline-formula id="ieqn-91"><mml:math id="mml-ieqn-91"><mml:mi>t</mml:mi></mml:math></inline-formula>. The queue length <inline-formula id="ieqn-92"><mml:math id="mml-ieqn-92"><mml:msub><mml:mi>q</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> updates as:
<disp-formula id="eqn-8"><label>(8)</label><mml:math id="mml-eqn-8" display="block"><mml:msub><mml:mi>q</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mrow><mml:mo>{</mml:mo><mml:mtable columnalign="left left" rowspacing=".2em" columnspacing="1em" displaystyle="false"><mml:mtr><mml:mtd><mml:mrow><mml:mo>(</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo>+</mml:mo><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>)</mml:mo></mml:mrow><mml:mo>&#x2212;</mml:mo><mml:mstyle displaystyle="true" scriptlevel="0"><mml:mfrac><mml:mrow><mml:msub><mml:mi>f</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mi>&#x03B4;</mml:mi></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C1;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:msub><mml:mi>Q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:mrow></mml:mfrac></mml:mstyle><mml:mrow><mml:mo>(</mml:mo><mml:mrow><mml:mrow><mml:mn mathvariant="double-struck">1</mml:mn></mml:mrow></mml:mrow><mml:mo stretchy="false">(</mml:mo><mml:mi>d</mml:mi><mml:mo>&#x2208;</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mi>d</mml:mi><mml:mi>r</mml:mi><mml:mi>o</mml:mi><mml:msub><mml:mi>p</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>)</mml:mo></mml:mrow><mml:mo>,</mml:mo></mml:mtd><mml:mtd><mml:mrow><mml:mrow><mml:mn mathvariant="double-struck">1</mml:mn></mml:mrow></mml:mrow><mml:mo stretchy="false">(</mml:mo><mml:mi>d</mml:mi><mml:mo>&#x2208;</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mi>d</mml:mi><mml:mi>r</mml:mi><mml:mi>o</mml:mi><mml:msub><mml:mi>p</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2265;</mml:mo><mml:mn>0</mml:mn><mml:mo>,</mml:mo></mml:mtd></mml:mtr><mml:mtr><mml:mtd><mml:mn>0</mml:mn><mml:mo>,</mml:mo></mml:mtd><mml:mtd><mml:mrow><mml:mrow><mml:mn mathvariant="double-struck">1</mml:mn></mml:mrow></mml:mrow><mml:mo stretchy="false">(</mml:mo><mml:mi>d</mml:mi><mml:mo>&#x2208;</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mi>d</mml:mi><mml:mi>r</mml:mi><mml:mi>o</mml:mi><mml:msub><mml:mi>p</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x003C;</mml:mo><mml:mn>0</mml:mn><mml:mo>,</mml:mo></mml:mtd></mml:mtr></mml:mtable><mml:mo fence="true" stretchy="true" symmetric="true"></mml:mo></mml:mrow></mml:math></disp-formula>where <inline-formula id="ieqn-93"><mml:math id="mml-ieqn-93"><mml:mrow><mml:mrow><mml:mn mathvariant="double-struck">1</mml:mn></mml:mrow></mml:mrow><mml:mo stretchy="false">(</mml:mo><mml:mo>&#x22C5;</mml:mo><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> is the indicator function (1 if the condition holds, 0 otherwise).</p>
<p>For a terminal task <inline-formula id="ieqn-94"><mml:math id="mml-ieqn-94"><mml:mi>d</mml:mi></mml:math></inline-formula> added to edge server <inline-formula id="ieqn-95"><mml:math id="mml-ieqn-95"><mml:mi>e</mml:mi></mml:math></inline-formula>&#x2019;s queue at the start of the time slot <inline-formula id="ieqn-96"><mml:math id="mml-ieqn-96"><mml:mi>t</mml:mi></mml:math></inline-formula>, <inline-formula id="ieqn-97"><mml:math id="mml-ieqn-97"><mml:msubsup><mml:mi>T</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> denotes the time slot when the task is processed or discarded; <inline-formula id="ieqn-98"><mml:math id="mml-ieqn-98"><mml:msubsup><mml:mi>T</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> if <inline-formula id="ieqn-99"><mml:math id="mml-ieqn-99"><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula>.</p>
<p>Let <inline-formula id="ieqn-100"><mml:math id="mml-ieqn-100"><mml:msubsup><mml:mrow><mml:mover><mml:mi>T</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> denote the time slot when processing starts:
<disp-formula id="eqn-9"><label>(9)</label><mml:math id="mml-eqn-9" display="block"><mml:msubsup><mml:mrow><mml:mover><mml:mi>T</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mo movablelimits="true" form="prefix">max</mml:mo><mml:mrow><mml:mo>{</mml:mo><mml:mi>t</mml:mi><mml:mo>,</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">sup</mml:mo><mml:mrow><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>&#x2208;</mml:mo><mml:mo fence="false" stretchy="false">{</mml:mo><mml:mn>0</mml:mn><mml:mo>,</mml:mo><mml:mn>1</mml:mn><mml:mo>,</mml:mo><mml:mo>&#x2026;</mml:mo><mml:mo>,</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo fence="false" stretchy="false">}</mml:mo></mml:mrow></mml:munder><mml:msubsup><mml:mi>T</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo>}</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>The task size <inline-formula id="ieqn-101"><mml:math id="mml-ieqn-101"><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> satisfies: it is not larger than the total processing capacity of edge server <inline-formula id="ieqn-102"><mml:math id="mml-ieqn-102"><mml:mi>e</mml:mi></mml:math></inline-formula> from <inline-formula id="ieqn-103"><mml:math id="mml-ieqn-103"><mml:msubsup><mml:mrow><mml:mover><mml:mi>T</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> to <inline-formula id="ieqn-104"><mml:math id="mml-ieqn-104"><mml:msubsup><mml:mi>T</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, but greater than the total capacity from <inline-formula id="ieqn-105"><mml:math id="mml-ieqn-105"><mml:msubsup><mml:mrow><mml:mover><mml:mi>T</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> to <inline-formula id="ieqn-106"><mml:math id="mml-ieqn-106"><mml:msubsup><mml:mi>T</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn></mml:math></inline-formula>. Formally:
<disp-formula id="eqn-10"><label>(10)</label><mml:math id="mml-eqn-10" display="block"><mml:munderover><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>=</mml:mo><mml:msubsup><mml:mrow><mml:mover><mml:mi>T</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:mrow><mml:mrow><mml:msubsup><mml:mi>T</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:mrow></mml:munderover><mml:mfrac><mml:mrow><mml:mi>&#x03B4;</mml:mi><mml:msub><mml:mi>f</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C1;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:msub><mml:mi>Q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo></mml:mrow></mml:mfrac><mml:mrow><mml:mn mathvariant="double-struck">1</mml:mn></mml:mrow><mml:mo stretchy="false">(</mml:mo><mml:mi>d</mml:mi><mml:mo>&#x2208;</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2265;</mml:mo><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></disp-formula>
<disp-formula id="eqn-11"><label>(11)</label><mml:math id="mml-eqn-11" display="block"><mml:munderover><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>=</mml:mo><mml:msubsup><mml:mrow><mml:mover><mml:mi>T</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:mrow><mml:mrow><mml:msubsup><mml:mi>T</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn></mml:mrow></mml:munderover><mml:mfrac><mml:mrow><mml:mi>&#x03B4;</mml:mi><mml:msub><mml:mi>f</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C1;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:msub><mml:mi>Q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo></mml:mrow></mml:mfrac><mml:mrow><mml:mn mathvariant="double-struck">1</mml:mn></mml:mrow><mml:mo stretchy="false">(</mml:mo><mml:mi>d</mml:mi><mml:mo>&#x2208;</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x003C;</mml:mo><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></disp-formula></p>
</sec>
<sec id="s3_3_3">
<label>3.3.3</label>
<title>Task Computation Latency</title>
<p>Task computation latency is defined as the sum of waiting time and processing time. Let <inline-formula id="ieqn-107"><mml:math id="mml-ieqn-107"><mml:mi>d</mml:mi><mml:mi>e</mml:mi><mml:mi>l</mml:mi><mml:mi>a</mml:mi><mml:msub><mml:mi>y</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (in time slots) denote the latency of the task <inline-formula id="ieqn-108"><mml:math id="mml-ieqn-108"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>.</p>
<p>If processed locally:
<disp-formula id="eqn-12"><label>(12)</label><mml:math id="mml-eqn-12" display="block"><mml:mi>d</mml:mi><mml:mi>e</mml:mi><mml:mi>l</mml:mi><mml:mi>a</mml:mi><mml:msub><mml:mi>y</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:msubsup><mml:mi>T</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn></mml:math></disp-formula></p>
<p>If offloaded to an edge server:
<disp-formula id="eqn-13"><label>(13)</label><mml:math id="mml-eqn-13" display="block"><mml:mi>d</mml:mi><mml:mi>e</mml:mi><mml:mi>l</mml:mi><mml:mi>a</mml:mi><mml:msub><mml:mi>y</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:munder><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:mi>e</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mi>E</mml:mi></mml:mrow></mml:munder><mml:munderover><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>=</mml:mo><mml:mi>t</mml:mi></mml:mrow><mml:mi>T</mml:mi></mml:munderover><mml:mrow><mml:mn mathvariant="double-struck">1</mml:mn></mml:mrow><mml:mrow><mml:mo>(</mml:mo><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>)</mml:mo></mml:mrow><mml:msubsup><mml:mi>T</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>t</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn></mml:math></disp-formula></p>
</sec>
</sec>
<sec id="s3_4">
<label>3.4</label>
<title>Problem Definition</title>
<p>The optimization objective is to minimize the task computation latency: given the current system state, determine the optimal edge server for offloading such that task <inline-formula id="ieqn-109"><mml:math id="mml-ieqn-109"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>&#x2019;s latency <inline-formula id="ieqn-110"><mml:math id="mml-ieqn-110"><mml:mi>d</mml:mi><mml:mi>e</mml:mi><mml:mi>l</mml:mi><mml:mi>a</mml:mi><mml:msub><mml:mi>y</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> satisfies <inline-formula id="ieqn-111"><mml:math id="mml-ieqn-111"><mml:mi>d</mml:mi><mml:mi>e</mml:mi><mml:mi>l</mml:mi><mml:mi>a</mml:mi><mml:msub><mml:mi>y</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2264;</mml:mo><mml:msub><mml:mi>&#x03C4;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula>.</p>
<p>The MEC environment exhibits continuous time-varying characteristics, and traditional algorithms lack scalability in large-scale dynamic scenarios. Thus, we employ DRL to address this problem. Formally, the terminal device policy is a mapping from system states to actions, denoted as <inline-formula id="ieqn-112"><mml:math id="mml-ieqn-112"><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo>:</mml:mo><mml:mrow><mml:mi>&#x1D4AE;</mml:mi></mml:mrow><mml:mo stretchy="false">&#x2192;</mml:mo><mml:mrow><mml:mi>&#x1D49C;</mml:mi></mml:mrow></mml:math></inline-formula>. Defining task computation latency as the offloading cost, minimizing this cost corresponds to minimizing latency. Let <inline-formula id="ieqn-113"><mml:math id="mml-ieqn-113"><mml:mi>&#x03B3;</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mo stretchy="false">(</mml:mo><mml:mn>0</mml:mn><mml:mo>,</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">]</mml:mo></mml:math></inline-formula> be the discount factor (weighting future costs). The goal is to find each terminal&#x2019;s optimal policy to minimize the expected long-term latency:
<disp-formula id="eqn-14"><label>(14)</label><mml:math id="mml-eqn-14" display="block"><mml:msubsup><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi><mml:mo>&#x2217;</mml:mo></mml:msubsup><mml:mo>=</mml:mo><mml:mi>arg</mml:mi><mml:mo>&#x2061;</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">min</mml:mo><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:munder><mml:mrow><mml:mi mathvariant="double-struck">E</mml:mi></mml:mrow><mml:mrow><mml:mo>[</mml:mo><mml:munder><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:mi>t</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mi>T</mml:mi></mml:mrow></mml:munder><mml:msup><mml:mi>&#x03B3;</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn></mml:mrow></mml:msup><mml:mi>d</mml:mi><mml:mi>e</mml:mi><mml:mi>l</mml:mi><mml:mi>a</mml:mi><mml:msub><mml:mi>y</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2223;</mml:mo><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo>]</mml:mo></mml:mrow></mml:math></disp-formula></p>
</sec>
</sec>
<sec id="s4">
<label>4</label>
<title>Heterogeneous Computing Power Scheduling Methods</title>
<p>The MEC environment is dynamically changing, and the load uncertainty of numerous terminal devices and edge servers renders traditional single-agent reinforcement learning ineffective for task offloading decision-making, even failing to converge in extreme cases. Thus, this section proposes a multi-agent reinforcement learning algorithm, centralized replay buffer-based deep recurrent <italic>Q</italic>-network (CRB-DRQN), enabling terminal devices and edge servers to make offloading decisions that satisfy the requirements of delay-sensitive tasks under unknown load conditions. <xref ref-type="fig" rid="fig-2">Fig. 2</xref> illustrates the overall execution process of the algorithm, involving three types of actors: a third-party trusted authority responsible for the collection and storage of experience, edge servers for network training and task computation, and terminal devices with offloading decision capabilities. The system architecture adopts a fusion mode that enables cloud-based training and edge-based execution, laying a theoretical foundation for large-scale deployment. A single edge server manages multiple terminal devices. Edge servers are responsible for training neural networks but do not directly participate in task offloading decision-making. Instead, offloading decisions are determined and executed by terminal devices. Compared with centralized algorithms, when edge servers have sufficient computing resources, the proposed architecture can support a larger number of terminal devices. When the number of terminal devices is enormous, the computing capacity can be linearly expanded by increasing the number of edge servers.</p>
<fig id="fig-2">
<label>Figure 2</label>
<caption>
<title>The overall execution process of CRB-DRQN.</title>
</caption>
<graphic mimetype="image" mime-subtype="tif" xlink:href="CMC_72505-fig-2.tif"/>
</fig>
<p>To reduce the impact of changes in the MEC environment on agent training, this section uses an ensemble of all agents&#x2019; experience trajectories to train the neural network of each agent. However, the agent&#x2019;s experience trajectory contains private data such as task information. Therefore, this section builds a third-party trusted authority in the cloud. Each agent uploads its own experience trajectory to the third-party trusted authority, which is responsible for integrating the experience trajectories to form a global experience trajectory, storing it in the central trajectory pool, and then training the corresponding neural network.</p>
<p>When a new task arrives, the terminal device requests the neural network weights of the Evaluation <italic>Q</italic>-network from the corresponding edge server. Based on the offloading decision generated by the neural network, the terminal device offloads the task to the designated edge server, and the edge server returns the task&#x2019;s calculation result to the terminal device. The terminal device collects experience samples and stores them in the experience replay buffer. When the number of experience samples stored in the experience replay buffer reaches a preset threshold, they form an experience trajectory. The terminal device then uploads this experience trajectory to the central trajectory pool of the third-party trusted authority, which integrates all uploaded experience trajectories. The edge server adopts similarity-based sampling to extract experience trajectories from the central trajectory pool, uses them to train the agent, and updates the network parameters accordingly.</p>
<sec id="s4_1">
<label>4.1</label>
<title>POMDP Build</title>
<sec id="s4_1_1">
<label>4.1.1</label>
<title>Status</title>
<p>This section assumes each edge server broadcasts its number of non-empty computation queues at the end of each time slot. The matrix <inline-formula id="ieqn-114"><mml:math id="mml-ieqn-114"><mml:mi>L</mml:mi><mml:mi>o</mml:mi><mml:mi>a</mml:mi><mml:mi>d</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> represents each edge server&#x2019;s historical load levels over the previous <italic>C</italic> time slots. Let <inline-formula id="ieqn-115"><mml:math id="mml-ieqn-115"><mml:msub><mml:mi>Q</mml:mi><mml:mi>j</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> denote the load level of edge server <inline-formula id="ieqn-116"><mml:math id="mml-ieqn-116"><mml:mi>j</mml:mi></mml:math></inline-formula> at time <inline-formula id="ieqn-117"><mml:math id="mml-ieqn-117"><mml:mi>t</mml:mi></mml:math></inline-formula>; <inline-formula id="ieqn-118"><mml:math id="mml-ieqn-118"><mml:mi>L</mml:mi><mml:mi>o</mml:mi><mml:mi>a</mml:mi><mml:mi>d</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> is a <inline-formula id="ieqn-119"><mml:math id="mml-ieqn-119"><mml:mi>C</mml:mi><mml:mo>&#x00D7;</mml:mo><mml:mi>E</mml:mi></mml:math></inline-formula> matrix with elements defined as:
<disp-formula id="eqn-15"><label>(15)</label><mml:math id="mml-eqn-15" display="block"><mml:msub><mml:mrow><mml:mo>{</mml:mo><mml:mi>L</mml:mi><mml:mi>o</mml:mi><mml:mi>a</mml:mi><mml:mi>d</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>}</mml:mo></mml:mrow><mml:mrow><mml:mi>i</mml:mi><mml:mo>,</mml:mo><mml:mi>j</mml:mi></mml:mrow></mml:msub><mml:mo>=</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mi>j</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mi>C</mml:mi><mml:mo>+</mml:mo><mml:mi>i</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo></mml:math></disp-formula></p>
<p>At the beginning of time slot <inline-formula id="ieqn-120"><mml:math id="mml-ieqn-120"><mml:mi>t</mml:mi></mml:math></inline-formula>, the terminal device <inline-formula id="ieqn-121"><mml:math id="mml-ieqn-121"><mml:mi>d</mml:mi></mml:math></inline-formula> observes the state:
<disp-formula id="eqn-16"><label>(16)</label><mml:math id="mml-eqn-16" display="block"><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mrow><mml:mo>(</mml:mo><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:mi>L</mml:mi><mml:mi>o</mml:mi><mml:mi>a</mml:mi><mml:mi>d</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>)</mml:mo></mml:mrow></mml:math></disp-formula></p>
</sec>
<sec id="s4_1_2">
<label>4.1.2</label>
<title>Action</title>
<p>At the start of time slot <inline-formula id="ieqn-122"><mml:math id="mml-ieqn-122"><mml:mi>t</mml:mi></mml:math></inline-formula>, if a new task arrives at terminal device <inline-formula id="ieqn-123"><mml:math id="mml-ieqn-123"><mml:mi>d</mml:mi></mml:math></inline-formula>, <inline-formula id="ieqn-124"><mml:math id="mml-ieqn-124"><mml:mi>d</mml:mi></mml:math></inline-formula> selects an action for this task. The action of terminal device <inline-formula id="ieqn-125"><mml:math id="mml-ieqn-125"><mml:mi>d</mml:mi></mml:math></inline-formula> in time slot <inline-formula id="ieqn-126"><mml:math id="mml-ieqn-126"><mml:mi>t</mml:mi></mml:math></inline-formula> is denoted as:
<disp-formula id="eqn-17"><label>(17)</label><mml:math id="mml-eqn-17" display="block"><mml:msub><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mrow><mml:mo>(</mml:mo><mml:msub><mml:mi>x</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>y</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>)</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>Let <inline-formula id="ieqn-127"><mml:math id="mml-ieqn-127"><mml:mi>S</mml:mi><mml:mi>p</mml:mi><mml:mi>a</mml:mi><mml:mi>c</mml:mi><mml:mi>e</mml:mi></mml:math></inline-formula> denote the action space, where <inline-formula id="ieqn-128"><mml:math id="mml-ieqn-128"><mml:mi>S</mml:mi><mml:mi>p</mml:mi><mml:mi>a</mml:mi><mml:mi>c</mml:mi><mml:mi>e</mml:mi><mml:mo>=</mml:mo><mml:mo fence="false" stretchy="false">{</mml:mo><mml:mn>0</mml:mn><mml:mo>,</mml:mo><mml:mn>1</mml:mn><mml:msup><mml:mo fence="false" stretchy="false">}</mml:mo><mml:mrow><mml:mn>1</mml:mn><mml:mo>+</mml:mo><mml:mi>E</mml:mi></mml:mrow></mml:msup></mml:math></inline-formula>.</p>
</sec>
<sec id="s4_1_3">
<label>4.1.3</label>
<title>Rewards</title>
<p>This section uses negative rewards associated with task delays. If task <inline-formula id="ieqn-129"><mml:math id="mml-ieqn-129"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> has been processed, the reward is:
<disp-formula id="eqn-18"><label>(18)</label><mml:math id="mml-eqn-18" display="block"><mml:msub><mml:mi>R</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mi>d</mml:mi><mml:mi>e</mml:mi><mml:mi>l</mml:mi><mml:mi>a</mml:mi><mml:msub><mml:mi>y</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mrow><mml:mo>(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>)</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>On the other hand, if task <inline-formula id="ieqn-130"><mml:math id="mml-ieqn-130"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> has been discarded, then:
<disp-formula id="eqn-19"><label>(19)</label><mml:math id="mml-eqn-19" display="block"><mml:msub><mml:mi>R</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mi>C</mml:mi><mml:mi>o</mml:mi><mml:mi>n</mml:mi><mml:mi>s</mml:mi><mml:mi>t</mml:mi></mml:math></disp-formula>where <inline-formula id="ieqn-131"><mml:math id="mml-ieqn-131"><mml:mi>C</mml:mi><mml:mi>o</mml:mi><mml:mi>n</mml:mi><mml:mi>s</mml:mi><mml:mi>t</mml:mi><mml:mo>&#x003C;</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> is a negative constant.</p>
</sec>
</sec>
<sec id="s4_2">
<label>4.2</label>
<title>Neural Network Structure</title>
<p>As shown in <xref ref-type="fig" rid="fig-2">Fig. 2</xref>, the Target and Evaluation <italic>Q</italic>-networks share the same structure on edge servers. The Target <italic>Q</italic>-network stabilizes learning and computes target <italic>Q</italic>-values; the Evaluation <italic>Q</italic>-network handles policy evaluation and parameter updates.</p>
<p>The Evaluation <italic>Q</italic>-network calculates <italic>Q</italic>-values for all actions from the current state and selects the highest-value action for execution. This guides the agent&#x2019;s decision-making, enabling near-optimal action selection, interaction with the environment, and gradual learning of the optimal policy.</p>
<p>The structure of the Evaluation <italic>Q</italic>-network on terminal devices matches that on edge servers. The core goal of the neural network is to map each state to a set of <italic>Q</italic>-values corresponding to possible actions. This mapping process involves the collaborative work of multiple network layers.</p>
<p>State information is passed through the input layer to the neural network. The state information includes <inline-formula id="ieqn-132"><mml:math id="mml-ieqn-132"><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:mi>L</mml:mi><mml:mi>o</mml:mi><mml:mi>a</mml:mi><mml:mi>d</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, where <inline-formula id="ieqn-133"><mml:math id="mml-ieqn-133"><mml:msub><mml:mi>&#x03B7;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mrow><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>m</mml:mi><mml:mi>p</mml:mi></mml:mrow></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msubsup><mml:mi>&#x03BC;</mml:mi><mml:mi>d</mml:mi><mml:mrow><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:mrow></mml:msubsup><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>q</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> are passed to the fully connected layer, and <inline-formula id="ieqn-134"><mml:math id="mml-ieqn-134"><mml:mrow><mml:mi>L</mml:mi><mml:mi>o</mml:mi><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:mrow><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> (for edge server load level prediction) is passed to the long short-term memory (LSTM) layer.</p>
<p>The LSTM layer learns the dynamics of edge server load levels and predicts near-future load levels using a LSTM unit. Hidden neurons in the LSTM are sequentially connected to matrix rows to track sequence changes (e.g., load level variations between time slots). Outputs from the last LSTM cell (indicating future load dynamics) are passed to the fully connected layer as <inline-formula id="ieqn-135"><mml:math id="mml-ieqn-135"><mml:mi>L</mml:mi><mml:mi>o</mml:mi><mml:mi>a</mml:mi><mml:mi>d</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:msub><mml:mo stretchy="false">)</mml:mo><mml:mi>c</mml:mi></mml:msub></mml:math></inline-formula>. Two such layers use ReLU-activated neurons, with connections between anterior/posterior layers for information transmission.</p>
<p>The Advantage-Value layer includes Advantage Network (A fully connected network learning action advantage values <inline-formula id="ieqn-136"><mml:math id="mml-ieqn-136"><mml:mi>A</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo>;</mml:mo><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>a</mml:mi></mml:msub><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, where <inline-formula id="ieqn-137"><mml:math id="mml-ieqn-137"><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>a</mml:mi></mml:msub></mml:math></inline-formula> denotes network weights) and Value Network (A fully connected network learning state values <inline-formula id="ieqn-138"><mml:math id="mml-ieqn-138"><mml:mi>V</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>;</mml:mo><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>v</mml:mi></mml:msub><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, where <inline-formula id="ieqn-139"><mml:math id="mml-ieqn-139"><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>v</mml:mi></mml:msub></mml:math></inline-formula> denotes network weights).</p>
<p>These values are computed through neural network layers (input <inline-formula id="ieqn-140"><mml:math id="mml-ieqn-140"><mml:mo stretchy="false">&#x2192;</mml:mo></mml:math></inline-formula> Advantage-Value) and trained on the edge server. The output layer calculates the <italic>Q</italic>-value of state-action pairs via:
<disp-formula id="eqn-20"><label>(20)</label><mml:math id="mml-eqn-20" display="block"><mml:mi>Q</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mi>V</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>;</mml:mo><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>v</mml:mi></mml:msub><mml:mo stretchy="false">)</mml:mo><mml:mo>+</mml:mo><mml:mrow><mml:mo>[</mml:mo><mml:mi>A</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo>;</mml:mo><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>a</mml:mi></mml:msub><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:mfrac><mml:mn>1</mml:mn><mml:mrow><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>S</mml:mi><mml:mi>p</mml:mi><mml:mi>a</mml:mi><mml:mi>c</mml:mi><mml:mi>e</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:mrow></mml:mfrac><mml:munder><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>&#x2208;</mml:mo><mml:mi>S</mml:mi><mml:mi>p</mml:mi><mml:mi>a</mml:mi><mml:mi>c</mml:mi><mml:mi>e</mml:mi></mml:mrow></mml:munder><mml:mi>A</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>;</mml:mo><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>a</mml:mi></mml:msub><mml:mo stretchy="false">)</mml:mo><mml:mo>]</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>Here, the second term adjusts the advantage value relative to the average advantage of all actions in the state.</p>
</sec>
<sec id="s4_3">
<label>4.3</label>
<title>Familiarity Trajectory Sampling</title>
<sec id="s4_3_1">
<label>4.3.1</label>
<title>Trajectory</title>
<p>This section defines an experience sample obtained by the terminal device at time <inline-formula id="ieqn-141"><mml:math id="mml-ieqn-141"><mml:mi>t</mml:mi></mml:math></inline-formula> as: <inline-formula id="ieqn-142"><mml:math id="mml-ieqn-142"><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>r</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>. This tuple includes: Current state <inline-formula id="ieqn-143"><mml:math id="mml-ieqn-143"><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, Action <inline-formula id="ieqn-144"><mml:math id="mml-ieqn-144"><mml:msub><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> taken,Reward <inline-formula id="ieqn-145"><mml:math id="mml-ieqn-145"><mml:msub><mml:mi>r</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> received, Next state <inline-formula id="ieqn-146"><mml:math id="mml-ieqn-146"><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>. It is stored in the replay buffer local to the terminal device.</p>
<p>Traditional DQN stores single-step experiences in a replay buffer. This section proposes a familiarity trajectory sampling algorithm that uses temporal sequences of multiple experiences as the agent&#x2019;s trajectory. When a terminal device stores an experience sample, it shares the trajectory starting at time <inline-formula id="ieqn-147"><mml:math id="mml-ieqn-147"><mml:mi>t</mml:mi></mml:math></inline-formula> to a central trajectory pool (managed by a third-party entity). A trajectory is defined as:
<disp-formula id="eqn-21"><label>(21)</label><mml:math id="mml-eqn-21" display="block"><mml:mi>T</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mo>=</mml:mo><mml:mrow><mml:mo>{</mml:mo><mml:mtable columnalign="right left right left right left right left right left right left" rowspacing="3pt" columnspacing="0em 2em 0em 2em 0em 2em 0em 2em 0em 2em 0em" displaystyle="true"><mml:mtr><mml:mtd /><mml:mtd><mml:mi></mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>r</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo></mml:mtd></mml:mtr><mml:mtr><mml:mtd /><mml:mtd><mml:mi></mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>r</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>2</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo></mml:mtd></mml:mtr><mml:mtr><mml:mtd /><mml:mtd><mml:mi></mml:mi><mml:mo>&#x22EE;</mml:mo></mml:mtd></mml:mtr><mml:mtr><mml:mtd /><mml:mtd><mml:mi></mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mi>n</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mi>n</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>r</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mi>n</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mi>n</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo></mml:mtd></mml:mtr></mml:mtable><mml:mo>}</mml:mo></mml:mrow></mml:math></disp-formula>where <inline-formula id="ieqn-148"><mml:math id="mml-ieqn-148"><mml:mi>n</mml:mi></mml:math></inline-formula> is the number of multi-step experiences (a constant).</p>
<p>Let <inline-formula id="ieqn-149"><mml:math id="mml-ieqn-149"><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mo>=</mml:mo><mml:mo fence="false" stretchy="false">{</mml:mo><mml:mi>T</mml:mi><mml:mi>r</mml:mi><mml:msub><mml:mi>a</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo>,</mml:mo><mml:mi>T</mml:mi><mml:mi>r</mml:mi><mml:msub><mml:mi>a</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo>,</mml:mo><mml:mo>&#x2026;</mml:mo><mml:mo fence="false" stretchy="false">}</mml:mo></mml:math></inline-formula> denote the set of all trajectories in the central pool. The central pool organizes trajectories uploaded by terminal devices into a replay buffer, from which edge servers sample during training. The size of <inline-formula id="ieqn-150"><mml:math id="mml-ieqn-150"><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow></mml:math></inline-formula> is denoted <inline-formula id="ieqn-151"><mml:math id="mml-ieqn-151"><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:math></inline-formula>.</p>
</sec>
<sec id="s4_3_2">
<label>4.3.2</label>
<title>Familiarity Trajectory Sampling</title>
<p>Based on prior random sampling methods, this section proposes a familiarity trajectory sampling strategy. The core idea is: trajectories with fewer historical samples should have a higher re-sampling probability. Define <inline-formula id="ieqn-152"><mml:math id="mml-ieqn-152"><mml:msub><mml:mi>N</mml:mi><mml:mi>i</mml:mi></mml:msub></mml:math></inline-formula> as the familiarity of trajectory <inline-formula id="ieqn-153"><mml:math id="mml-ieqn-153"><mml:mi>T</mml:mi><mml:mi>r</mml:mi><mml:msub><mml:mi>a</mml:mi><mml:mi>i</mml:mi></mml:msub></mml:math></inline-formula> (increases with each sampling). As <inline-formula id="ieqn-154"><mml:math id="mml-ieqn-154"><mml:msub><mml:mi>N</mml:mi><mml:mi>i</mml:mi></mml:msub></mml:math></inline-formula> grows, the probability of re-sampling decreases.</p>
<p>The sampling probability of trajectory <inline-formula id="ieqn-155"><mml:math id="mml-ieqn-155"><mml:mi>T</mml:mi><mml:mi>r</mml:mi><mml:msub><mml:mi>a</mml:mi><mml:mi>i</mml:mi></mml:msub></mml:math></inline-formula> is:
<disp-formula id="eqn-22"><label>(22)</label><mml:math id="mml-eqn-22" display="block"><mml:mi>P</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>i</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mfrac><mml:msup><mml:mrow><mml:mo>(</mml:mo><mml:mfrac><mml:mrow><mml:mi>ln</mml:mi><mml:mo>&#x2061;</mml:mo><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>N</mml:mi><mml:mi>i</mml:mi></mml:msub><mml:mo stretchy="false">)</mml:mo></mml:mrow><mml:msub><mml:mi>N</mml:mi><mml:mi>i</mml:mi></mml:msub></mml:mfrac><mml:mo>)</mml:mo></mml:mrow><mml:mrow><mml:mfrac><mml:mi>&#x03B1;</mml:mi><mml:mn>2</mml:mn></mml:mfrac></mml:mrow></mml:msup><mml:mrow><mml:munderover><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:mi>p</mml:mi><mml:mo>=</mml:mo><mml:mn>1</mml:mn></mml:mrow><mml:mrow><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:mrow></mml:munderover><mml:msup><mml:mrow><mml:mo>(</mml:mo><mml:mfrac><mml:mrow><mml:mi>ln</mml:mi><mml:mo>&#x2061;</mml:mo><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>N</mml:mi><mml:mi>p</mml:mi></mml:msub><mml:mo stretchy="false">)</mml:mo></mml:mrow><mml:msub><mml:mi>N</mml:mi><mml:mi>p</mml:mi></mml:msub></mml:mfrac><mml:mo>)</mml:mo></mml:mrow><mml:mrow><mml:mfrac><mml:mi>&#x03B1;</mml:mi><mml:mn>2</mml:mn></mml:mfrac></mml:mrow></mml:msup></mml:mrow></mml:mfrac></mml:math></disp-formula>where <inline-formula id="ieqn-156"><mml:math id="mml-ieqn-156"><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:math></inline-formula> denotes the number of trajectories in the central pool, <inline-formula id="ieqn-157"><mml:math id="mml-ieqn-157"><mml:mi>&#x03B1;</mml:mi></mml:math></inline-formula> is a hyperparameter that balances the importance of priority, <inline-formula id="ieqn-158"><mml:math id="mml-ieqn-158"><mml:msub><mml:mi>N</mml:mi><mml:mi>i</mml:mi></mml:msub></mml:math></inline-formula> represents the familiarity (sampling count) of <inline-formula id="ieqn-159"><mml:math id="mml-ieqn-159"><mml:mi>T</mml:mi><mml:mi>r</mml:mi><mml:msub><mml:mi>a</mml:mi><mml:mi>i</mml:mi></mml:msub></mml:math></inline-formula>, and <inline-formula id="ieqn-160"><mml:math id="mml-ieqn-160"><mml:mi>P</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>i</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> is the sampling probability of <inline-formula id="ieqn-161"><mml:math id="mml-ieqn-161"><mml:mi>T</mml:mi><mml:mi>r</mml:mi><mml:msub><mml:mi>a</mml:mi><mml:mi>i</mml:mi></mml:msub></mml:math></inline-formula>.</p>
</sec>
</sec>
<sec id="s4_4">
<label>4.4</label>
<title>Task Offloading Algorithm</title>
<p>First, initialize the Target <italic>Q</italic>-network, Evaluation <italic>Q</italic>-network, and counter <inline-formula id="ieqn-162"><mml:math id="mml-ieqn-162"><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>u</mml:mi><mml:mi>n</mml:mi><mml:msub><mml:mi>t</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:math></inline-formula> of the edge server <inline-formula id="ieqn-163"><mml:math id="mml-ieqn-163"><mml:mi>e</mml:mi></mml:math></inline-formula>; for the terminal device <inline-formula id="ieqn-164"><mml:math id="mml-ieqn-164"><mml:mi>d</mml:mi></mml:math></inline-formula>, initialize its initial state <inline-formula id="ieqn-165"><mml:math id="mml-ieqn-165"><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> and trajectory counter <inline-formula id="ieqn-166"><mml:math id="mml-ieqn-166"><mml:msub><mml:mi>n</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula>, and download the network weights <inline-formula id="ieqn-167"><mml:math id="mml-ieqn-167"><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula> of the Evaluation <italic>Q</italic>-network corresponding to the edge server <inline-formula id="ieqn-168"><mml:math id="mml-ieqn-168"><mml:mi>e</mml:mi></mml:math></inline-formula>. When the time slot <inline-formula id="ieqn-169"><mml:math id="mml-ieqn-169"><mml:mi>t</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mi>T</mml:mi></mml:math></inline-formula> starts, if a new task <inline-formula id="ieqn-170"><mml:math id="mml-ieqn-170"><mml:msub><mml:mi>I</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> arrives at the terminal device <inline-formula id="ieqn-171"><mml:math id="mml-ieqn-171"><mml:mi>d</mml:mi></mml:math></inline-formula>, the terminal device <inline-formula id="ieqn-172"><mml:math id="mml-ieqn-172"><mml:mi>d</mml:mi></mml:math></inline-formula> will select an action <inline-formula id="ieqn-173"><mml:math id="mml-ieqn-173"><mml:msub><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> according to the <inline-formula id="ieqn-174"><mml:math id="mml-ieqn-174"><mml:mo>&#x03B5;</mml:mo></mml:math></inline-formula>-greedy strategy and observe the state information <inline-formula id="ieqn-175"><mml:math id="mml-ieqn-175"><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> of the next time slot <inline-formula id="ieqn-176"><mml:math id="mml-ieqn-176"><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn></mml:math></inline-formula>. Meanwhile, it judges according to the trajectory storage condition: if the trajectory counter <inline-formula id="ieqn-177"><mml:math id="mml-ieqn-177"><mml:msub><mml:mi>n</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula> satisfies <inline-formula id="ieqn-178"><mml:math id="mml-ieqn-178"><mml:msub><mml:mi>n</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mspace width="0.667em" /><mml:mi>mod</mml:mi><mml:mspace width="thinmathspace" /><mml:mspace width="thinmathspace" /><mml:mi>n</mml:mi><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula> (where <inline-formula id="ieqn-179"><mml:math id="mml-ieqn-179"><mml:mi>n</mml:mi></mml:math></inline-formula> is the trajectory length), the current trajectory batch <inline-formula id="ieqn-180"><mml:math id="mml-ieqn-180"><mml:mi>T</mml:mi><mml:mi>r</mml:mi><mml:msub><mml:mi>a</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>i</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula> is sent to the third-party trusted authority and the trajectory index <inline-formula id="ieqn-181"><mml:math id="mml-ieqn-181"><mml:mi>i</mml:mi></mml:math></inline-formula> is incremented; otherwise, the state transition experience <inline-formula id="ieqn-182"><mml:math id="mml-ieqn-182"><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>a</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>r</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>,</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> is appended to the local trajectory and the trajectory counter <inline-formula id="ieqn-183"><mml:math id="mml-ieqn-183"><mml:msub><mml:mi>n</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula> is updated. In addition, if the current time slot <inline-formula id="ieqn-184"><mml:math id="mml-ieqn-184"><mml:mi>t</mml:mi></mml:math></inline-formula> meets the periodic network weight download condition (<inline-formula id="ieqn-185"><mml:math id="mml-ieqn-185"><mml:mrow><mml:mtext>mod</mml:mtext></mml:mrow><mml:mtext>&#x00A0;</mml:mtext><mml:mo stretchy="false">(</mml:mo><mml:mi>t</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi><mml:mi>a</mml:mi><mml:mi>g</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>==</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula>), the terminal device <inline-formula id="ieqn-186"><mml:math id="mml-ieqn-186"><mml:mi>d</mml:mi></mml:math></inline-formula> will download the updated Evaluation <italic>Q</italic>-network weights <inline-formula id="ieqn-187"><mml:math id="mml-ieqn-187"><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:math></inline-formula> from the associated edge server <inline-formula id="ieqn-188"><mml:math id="mml-ieqn-188"><mml:mi>e</mml:mi></mml:math></inline-formula>. As shown in <xref ref-type="fig" rid="fig-3">Fig. 3a</xref> and Algorithm 1.</p>
<fig id="fig-3">
<label>Figure 3</label>
<caption>
<title>Flowchart of the CRB-DRQN Algorithm. Figure (<bold>a</bold>) illustrates the execution flow of the CRB-DRQN algorithm on terminal devices. Figure (<bold>b</bold>) illustrates the execution flow of the CRB-DRQN algorithm on edge devices.</title>
</caption>
<graphic mimetype="image" mime-subtype="tif" xlink:href="CMC_72505-fig-3.tif"/>
</fig>
<p>Meanwhile, the edge server <inline-formula id="ieqn-189"><mml:math id="mml-ieqn-189"><mml:mi>e</mml:mi></mml:math></inline-formula> extracts the trajectory set <italic>I</italic> from the central trajectory pool based on the familiarity sampling mechanism, updates the familiarity of each trajectory. For each experience sample <inline-formula id="ieqn-190"><mml:math id="mml-ieqn-190"><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula> (the <inline-formula id="ieqn-191"><mml:math id="mml-ieqn-191"><mml:mi>k</mml:mi></mml:math></inline-formula>-th experience sample of the <inline-formula id="ieqn-192"><mml:math id="mml-ieqn-192"><mml:mi>j</mml:mi></mml:math></inline-formula>-th trajectory in the trajectory set <italic>I</italic>) in each trajectory <inline-formula id="ieqn-193"><mml:math id="mml-ieqn-193"><mml:mi>T</mml:mi><mml:mi>r</mml:mi><mml:msub><mml:mi>a</mml:mi><mml:mi>j</mml:mi></mml:msub><mml:mo>&#x2208;</mml:mo><mml:mi>I</mml:mi></mml:math></inline-formula>, the target <italic>Q</italic>-value <inline-formula id="ieqn-194"><mml:math id="mml-ieqn-194"><mml:msubsup><mml:mrow><mml:mover><mml:mi>Q</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>e</mml:mi><mml:mo>,</mml:mo><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub></mml:mrow><mml:mrow><mml:mi>T</mml:mi><mml:mi>a</mml:mi><mml:mi>r</mml:mi><mml:mi>g</mml:mi><mml:mi>e</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup></mml:math></inline-formula> is calculated using <xref ref-type="disp-formula" rid="eqn-23">Eq. (23)</xref>. As shown in <xref ref-type="fig" rid="fig-3">Fig. 3b</xref> and Algorithm 2.
<disp-formula id="eqn-23"><label>(23)</label><mml:math id="mml-eqn-23" display="block"><mml:msubsup><mml:mrow><mml:mover><mml:mi>Q</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>e</mml:mi><mml:mo>,</mml:mo><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub></mml:mrow><mml:mrow><mml:mi>T</mml:mi><mml:mi>a</mml:mi><mml:mi>r</mml:mi><mml:mi>g</mml:mi><mml:mi>e</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup><mml:mo>=</mml:mo><mml:msub><mml:mi>R</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub><mml:mo>+</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:msub><mml:mi>Q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mrow><mml:mo>(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn></mml:mrow></mml:msub><mml:mo>,</mml:mo><mml:msubsup><mml:mi>a</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow><mml:mrow><mml:mi>N</mml:mi><mml:mi>e</mml:mi><mml:mi>x</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup><mml:mo>,</mml:mo><mml:msubsup><mml:mi>&#x03B8;</mml:mi><mml:mi>e</mml:mi><mml:mo>&#x2212;</mml:mo></mml:msubsup><mml:mo>)</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>The target <italic>Q</italic>-value <inline-formula id="ieqn-195"><mml:math id="mml-ieqn-195"><mml:msubsup><mml:mrow><mml:mover><mml:mi>Q</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>n</mml:mi><mml:mo>,</mml:mo><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub></mml:mrow><mml:mrow><mml:mi>T</mml:mi><mml:mi>a</mml:mi><mml:mi>r</mml:mi><mml:mi>g</mml:mi><mml:mi>e</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup></mml:math></inline-formula> reveals the expected long-term reward of the action <inline-formula id="ieqn-196"><mml:math id="mml-ieqn-196"><mml:msubsup><mml:mi>a</mml:mi><mml:mrow><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub></mml:mrow><mml:mrow><mml:mi>N</mml:mi><mml:mi>e</mml:mi><mml:mi>x</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup></mml:math></inline-formula> given the state <inline-formula id="ieqn-197"><mml:math id="mml-ieqn-197"><mml:msub><mml:mi>s</mml:mi><mml:mrow><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn></mml:mrow></mml:msub></mml:mrow></mml:msub></mml:math></inline-formula>, i.e., the sum of the reward in the experience sample <inline-formula id="ieqn-198"><mml:math id="mml-ieqn-198"><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula> and the <italic>Q</italic>-value of the action that may be selected under the given conditions. Among them, <inline-formula id="ieqn-199"><mml:math id="mml-ieqn-199"><mml:msubsup><mml:mi>a</mml:mi><mml:mrow><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub></mml:mrow><mml:mrow><mml:mi>N</mml:mi><mml:mi>e</mml:mi><mml:mi>x</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup></mml:math></inline-formula> can be calculated using <xref ref-type="disp-formula" rid="eqn-24">Eq. (24)</xref>.
<disp-formula id="eqn-24"><label>(24)</label><mml:math id="mml-eqn-24" display="block"><mml:msubsup><mml:mi>a</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow><mml:mrow><mml:mi>N</mml:mi><mml:mi>e</mml:mi><mml:mi>x</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup><mml:mo>=</mml:mo><mml:mi>arg</mml:mi><mml:mo>&#x2061;</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">min</mml:mo><mml:mrow><mml:mi>a</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mi>S</mml:mi><mml:mi>p</mml:mi><mml:mi>a</mml:mi><mml:mi>c</mml:mi><mml:mi>e</mml:mi></mml:mrow></mml:munder><mml:msub><mml:mi>Q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mrow><mml:mo>(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn></mml:mrow></mml:msub><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo>,</mml:mo><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo>)</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>Subsequently, the gradient descent method is used to minimize the loss function <inline-formula id="ieqn-200"><mml:math id="mml-ieqn-200"><mml:mi>L</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo>,</mml:mo><mml:msubsup><mml:mrow><mml:mover><mml:mi>Q</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mi>e</mml:mi><mml:mrow><mml:mi>T</mml:mi><mml:mi>a</mml:mi><mml:mi>r</mml:mi><mml:mi>g</mml:mi><mml:mi>e</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> and update the Evaluation <italic>Q</italic>-network parameters <inline-formula id="ieqn-201"><mml:math id="mml-ieqn-201"><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:math></inline-formula> via <xref ref-type="disp-formula" rid="eqn-25">Eq. (25)</xref>, while incrementing its training counter <inline-formula id="ieqn-202"><mml:math id="mml-ieqn-202"><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>u</mml:mi><mml:mi>n</mml:mi><mml:msub><mml:mi>t</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:math></inline-formula>. When <inline-formula id="ieqn-203"><mml:math id="mml-ieqn-203"><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>u</mml:mi><mml:mi>n</mml:mi><mml:msub><mml:mi>t</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:math></inline-formula> satisfies <inline-formula id="ieqn-204"><mml:math id="mml-ieqn-204"><mml:mi>c</mml:mi><mml:mi>o</mml:mi><mml:mi>u</mml:mi><mml:mi>n</mml:mi><mml:msub><mml:mi>t</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mspace width="0.667em" /><mml:mi>mod</mml:mi><mml:mspace width="thinmathspace" /><mml:mspace width="thinmathspace" /><mml:mi>u</mml:mi><mml:mi>p</mml:mi><mml:mi>d</mml:mi><mml:mi>a</mml:mi><mml:mi>t</mml:mi><mml:mi>e</mml:mi><mml:mo>==</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula>, the edge server synchronizes the Evaluation <italic>Q</italic>-network parameters <inline-formula id="ieqn-205"><mml:math id="mml-ieqn-205"><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:math></inline-formula> to the Target <italic>Q</italic>-network parameters <inline-formula id="ieqn-206"><mml:math id="mml-ieqn-206"><mml:msubsup><mml:mi>&#x03B8;</mml:mi><mml:mi>e</mml:mi><mml:mo>&#x2212;</mml:mo></mml:msubsup></mml:math></inline-formula>, completing the delayed update of the network parameters.
<disp-formula id="eqn-25"><label>(25)</label><mml:math id="mml-eqn-25" display="block"><mml:mi>L</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo>,</mml:mo><mml:msubsup><mml:mrow><mml:mover><mml:mi>Q</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mi>e</mml:mi><mml:mrow><mml:mi>T</mml:mi><mml:mi>a</mml:mi><mml:mi>r</mml:mi><mml:mi>g</mml:mi><mml:mi>e</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mfrac><mml:mn>1</mml:mn><mml:mrow><mml:mi>n</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>I</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:mrow></mml:mfrac><mml:munder><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub><mml:mo>&#x2208;</mml:mo><mml:mi>I</mml:mi></mml:mrow></mml:munder><mml:msup><mml:mrow><mml:mo>(</mml:mo><mml:msubsup><mml:mrow><mml:mover><mml:mi>Q</mml:mi><mml:mo stretchy="false">&#x005E;</mml:mo></mml:mover></mml:mrow><mml:mrow><mml:mi>e</mml:mi><mml:mo>,</mml:mo><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub></mml:mrow><mml:mrow><mml:mi>T</mml:mi><mml:mi>a</mml:mi><mml:mi>r</mml:mi><mml:mi>g</mml:mi><mml:mi>e</mml:mi><mml:mi>t</mml:mi></mml:mrow></mml:msubsup><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mrow><mml:mo>(</mml:mo><mml:msub><mml:mi>s</mml:mi><mml:mrow><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn></mml:mrow></mml:msub></mml:mrow></mml:msub><mml:mo>,</mml:mo><mml:msub><mml:mi>a</mml:mi><mml:mrow><mml:msub><mml:mi>I</mml:mi><mml:mrow><mml:mi>j</mml:mi><mml:mo>,</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub></mml:mrow></mml:msub><mml:mo>,</mml:mo><mml:msub><mml:mi>&#x03B8;</mml:mi><mml:mi>e</mml:mi></mml:msub><mml:mo>)</mml:mo></mml:mrow><mml:mo>)</mml:mo></mml:mrow><mml:mn>2</mml:mn></mml:msup></mml:math></disp-formula></p>
<fig id="fig-7">
<graphic mimetype="image" mime-subtype="tif" xlink:href="CMC_72505-fig-7.tif"/>
</fig>
<p>The time complexity of this algorithm is <inline-formula id="ieqn-224"><mml:math id="mml-ieqn-224"><mml:mi>O</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>T</mml:mi><mml:mo>&#x00D7;</mml:mo><mml:mo stretchy="false">(</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>D</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo>+</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>E</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo>&#x00D7;</mml:mo><mml:mi>I</mml:mi><mml:mo>&#x00D7;</mml:mo><mml:mi>K</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, where <italic>T</italic> denotes the total number of time steps, |<italic>D</italic>| and |<italic>E</italic>| represent the number of terminal devices and edge servers, respectively, <italic>I</italic> is the number of trajectories sampled in a single iteration, and <italic>K</italic> denotes the number of experience samples per trajectory. Its core consists of an initialization phase and a time-step main loop: The initialization requires traversing all edge servers <inline-formula id="ieqn-225"><mml:math id="mml-ieqn-225"><mml:mi>O</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>E</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> and terminal devices <inline-formula id="ieqn-226"><mml:math id="mml-ieqn-226"><mml:mi>O</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>D</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> to complete network parameter loading; in the main loop, each time step involves processing task action selection and trajectory recording for all terminal devices <inline-formula id="ieqn-227"><mml:math id="mml-ieqn-227"><mml:mi>O</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>D</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, as well as trajectory sampling and experience calculation <inline-formula id="ieqn-228"><mml:math id="mml-ieqn-228"><mml:mi>O</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>I</mml:mi><mml:mo>&#x00D7;</mml:mo><mml:mi>K</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula> for all edge servers <inline-formula id="ieqn-229"><mml:math id="mml-ieqn-229"><mml:mi>O</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>E</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>. The space complexity is <inline-formula id="ieqn-230"><mml:math id="mml-ieqn-230"><mml:mi>O</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>E</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo>+</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mi>D</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, which stems from the independent storage of <italic>Q</italic>-network parameters and counters by edge servers and terminal devices, with no dependence on task scale. The algorithm enables parallel processing of terminal devices and edge servers, reducing synchronization overhead and adapting to the asynchronous decision-making requirements of end-edge collaboration.</p>
<fig id="fig-8">
<graphic mimetype="image" mime-subtype="tif" xlink:href="CMC_72505-fig-8.tif"/>
</fig>
</sec>
<sec id="s4_5">
<label>4.5</label>
<title>Convergence Analysis</title>
<p>Based on the theory of Bellman operator, this section conducts a rigorous theoretical analysis on the convergence of the CRB-DRQN algorithm in the heterogeneous cloud-edge-end environment. By transforming the POMDP into a belief MDP, defining the corresponding Bellman operator and proving its contractivity, the convergence characteristics of the algorithm are finally derived based on the Banach fixed-point theorem.</p>
<p>Let the true state of the system be <inline-formula id="ieqn-243"><mml:math id="mml-ieqn-243"><mml:mi>s</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mrow><mml:mi>&#x1D4AE;</mml:mi></mml:mrow></mml:math></inline-formula>, the observation sequence of terminal device <inline-formula id="ieqn-244"><mml:math id="mml-ieqn-244"><mml:mi>d</mml:mi></mml:math></inline-formula> at time slot <inline-formula id="ieqn-245"><mml:math id="mml-ieqn-245"><mml:mi>t</mml:mi></mml:math></inline-formula> be <inline-formula id="ieqn-246"><mml:math id="mml-ieqn-246"><mml:msub><mml:mi>o</mml:mi><mml:mrow><mml:mn>1</mml:mn><mml:mo>:</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula>, and the action sequence be <inline-formula id="ieqn-247"><mml:math id="mml-ieqn-247"><mml:msub><mml:mi>a</mml:mi><mml:mrow><mml:mn>1</mml:mn><mml:mo>:</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn></mml:mrow></mml:msub></mml:math></inline-formula>. The belief state <inline-formula id="ieqn-248"><mml:math id="mml-ieqn-248"><mml:mi>b</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mrow><mml:mi>&#x0212C;</mml:mi></mml:mrow></mml:math></inline-formula> is defined as the probability distribution of the true state:
<disp-formula id="eqn-26"><label>(26)</label><mml:math id="mml-eqn-26" display="block"><mml:mi>b</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>s</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:mrow><mml:mi mathvariant="double-struck">P</mml:mi></mml:mrow><mml:mo stretchy="false">(</mml:mo><mml:mi>s</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msub><mml:mi>o</mml:mi><mml:mrow><mml:mn>1</mml:mn><mml:mo>:</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub><mml:mo>,</mml:mo><mml:msub><mml:mi>a</mml:mi><mml:mrow><mml:mn>1</mml:mn><mml:mo>:</mml:mo><mml:mi>t</mml:mi><mml:mo>&#x2212;</mml:mo><mml:mn>1</mml:mn></mml:mrow></mml:msub><mml:mo stretchy="false">)</mml:mo></mml:math></disp-formula></p>
<p>The belief state space <inline-formula id="ieqn-249"><mml:math id="mml-ieqn-249"><mml:mrow><mml:mi>&#x0212C;</mml:mi></mml:mrow></mml:math></inline-formula> is the set of all possible probability distributions. Based on the belief state, a belief MDP can be constructed as a 5-tuple <inline-formula id="ieqn-250"><mml:math id="mml-ieqn-250"><mml:mo stretchy="false">(</mml:mo><mml:mrow><mml:mi>&#x0212C;</mml:mi></mml:mrow><mml:mo>,</mml:mo><mml:msub><mml:mrow><mml:mi>&#x1D49C;</mml:mi></mml:mrow><mml:mi>d</mml:mi></mml:msub><mml:mo>,</mml:mo><mml:msub><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mi>b</mml:mi></mml:msub><mml:mo>,</mml:mo><mml:msub><mml:mrow><mml:mi>&#x211B;</mml:mi></mml:mrow><mml:mi>b</mml:mi></mml:msub><mml:mo>,</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:mo stretchy="false">)</mml:mo></mml:math></inline-formula>, where <inline-formula id="ieqn-251"><mml:math id="mml-ieqn-251"><mml:msub><mml:mrow><mml:mi>&#x1D49C;</mml:mi></mml:mrow><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula> denotes the action space, <inline-formula id="ieqn-252"><mml:math id="mml-ieqn-252"><mml:msub><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mi>b</mml:mi></mml:msub></mml:math></inline-formula> is the state transition function, <inline-formula id="ieqn-253"><mml:math id="mml-ieqn-253"><mml:msub><mml:mrow><mml:mi>&#x211B;</mml:mi></mml:mrow><mml:mi>b</mml:mi></mml:msub></mml:math></inline-formula> represents the reward function, and discount factor <inline-formula id="ieqn-254"><mml:math id="mml-ieqn-254"><mml:mi>&#x03B3;</mml:mi></mml:math></inline-formula> is 0.9.</p>
<p>Under the framework of belief MDP, the policy of terminal device <inline-formula id="ieqn-255"><mml:math id="mml-ieqn-255"><mml:mi>d</mml:mi></mml:math></inline-formula> is defined as <inline-formula id="ieqn-256"><mml:math id="mml-ieqn-256"><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mrow><mml:mo>:</mml:mo></mml:mrow><mml:mrow><mml:mi>&#x0212C;</mml:mi></mml:mrow><mml:mo stretchy="false">&#x2192;</mml:mo><mml:msub><mml:mrow><mml:mi>&#x1D49C;</mml:mi></mml:mrow><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula>. The state-value function and action-value function corresponding to policy <inline-formula id="ieqn-257"><mml:math id="mml-ieqn-257"><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula> are respectively given by:
<disp-formula id="eqn-27"><label>(27)</label><mml:math id="mml-eqn-27" display="block"><mml:msup><mml:mi>V</mml:mi><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:msub><mml:mrow><mml:mi mathvariant="double-struck">E</mml:mi></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msub><mml:mrow><mml:mo>[</mml:mo><mml:munderover><mml:mo>&#x2211;</mml:mo><mml:mrow><mml:mi>k</mml:mi><mml:mo>=</mml:mo><mml:mn>0</mml:mn></mml:mrow><mml:mi mathvariant="normal">&#x221E;</mml:mi></mml:munderover><mml:msup><mml:mi>&#x03B3;</mml:mi><mml:mi>k</mml:mi></mml:msup><mml:msub><mml:mi>r</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mi>k</mml:mi></mml:mrow></mml:msub><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msub><mml:mi>b</mml:mi><mml:mi>t</mml:mi></mml:msub><mml:mo>=</mml:mo><mml:mi>b</mml:mi><mml:mo>]</mml:mo></mml:mrow></mml:math></disp-formula>
<disp-formula id="eqn-28"><label>(28)</label><mml:math id="mml-eqn-28" display="block"><mml:msup><mml:mi>Q</mml:mi><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:msub><mml:mrow><mml:mi mathvariant="double-struck">E</mml:mi></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msub><mml:mo stretchy="false">[</mml:mo><mml:msub><mml:mi>r</mml:mi><mml:mi>t</mml:mi></mml:msub><mml:mo>+</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:msup><mml:mi>V</mml:mi><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:mo stretchy="false">(</mml:mo><mml:msub><mml:mi>b</mml:mi><mml:mrow><mml:mi>t</mml:mi><mml:mo>+</mml:mo><mml:mn>1</mml:mn></mml:mrow></mml:msub><mml:mo stretchy="false">)</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msub><mml:mi>b</mml:mi><mml:mi>t</mml:mi></mml:msub><mml:mo>=</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:msub><mml:mi>a</mml:mi><mml:mi>t</mml:mi></mml:msub><mml:mo>=</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">]</mml:mo></mml:math></disp-formula></p>
<p>For the double <italic>Q</italic>-network architecture of the CRB-DRQN algorithm, define the Bellman expectation operator for the Evaluation <italic>Q</italic>-network as:
<disp-formula id="eqn-29"><label>(29)</label><mml:math id="mml-eqn-29" display="block"><mml:msup><mml:mi>T</mml:mi><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:mi>Q</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:msub><mml:mrow><mml:mi>&#x211B;</mml:mi></mml:mrow><mml:mi>b</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>+</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:msub><mml:mrow><mml:mi mathvariant="double-struck">E</mml:mi></mml:mrow><mml:mrow><mml:msup><mml:mi>o</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>&#x223C;</mml:mo><mml:msub><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mi>b</mml:mi></mml:msub></mml:mrow></mml:msub><mml:mo stretchy="false">[</mml:mo><mml:mi>Q</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">]</mml:mo></mml:math></disp-formula></p>
<p>Define the Bellman optimality operator for the Target <italic>Q</italic>-network as follows:
<disp-formula id="eqn-30"><label>(30)</label><mml:math id="mml-eqn-30" display="block"><mml:msup><mml:mi>T</mml:mi><mml:mo>&#x2217;</mml:mo></mml:msup><mml:mi>Q</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>=</mml:mo><mml:msub><mml:mrow><mml:mi>&#x211B;</mml:mi></mml:mrow><mml:mi>b</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>+</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:msub><mml:mrow><mml:mi mathvariant="double-struck">E</mml:mi></mml:mrow><mml:mrow><mml:msup><mml:mi>o</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>&#x223C;</mml:mo><mml:msub><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mi>b</mml:mi></mml:msub></mml:mrow></mml:msub><mml:mrow><mml:mo>[</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">max</mml:mo><mml:mrow><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>&#x2208;</mml:mo><mml:msub><mml:mrow><mml:mi>&#x1D49C;</mml:mi></mml:mrow><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:munder><mml:mi>Q</mml:mi><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo>]</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p>To prove the convergence of the algorithm, it is necessary to verify that the aforementioned Bellman operator is a contraction mapping. Define the action-value function space <italic>Q</italic> as the set of all bounded functions, and its infinity norm is given by:
<disp-formula id="eqn-31"><label>(31)</label><mml:math id="mml-eqn-31" display="block"><mml:mo stretchy="false">&#x2225;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:msub><mml:mo>&#x2225;</mml:mo><mml:mi mathvariant="normal">&#x221E;</mml:mi></mml:msub><mml:mo>=</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">max</mml:mo><mml:mrow><mml:mi>b</mml:mi><mml:mo>&#x2208;</mml:mo><mml:mrow><mml:mi>&#x0212C;</mml:mi></mml:mrow><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo>&#x2208;</mml:mo><mml:msub><mml:mrow><mml:mi>&#x1D49C;</mml:mi></mml:mrow><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:munder><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:math></disp-formula></p>
<p><bold>Theorem 1:</bold> <italic>The Bellman expectation operator</italic> <inline-formula id="ieqn-258"><mml:math id="mml-ieqn-258"><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup></mml:math></inline-formula> <italic>is a</italic> <inline-formula id="ieqn-259"><mml:math id="mml-ieqn-259"><mml:mi>&#x03B3;</mml:mi></mml:math></inline-formula><italic>-contraction mapping</italic>.</p>
<p><bold>Proof:</bold> For any <inline-formula id="ieqn-260"><mml:math id="mml-ieqn-260"><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo>,</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo>&#x2208;</mml:mo><mml:mrow><mml:mi>&#x1D4AC;</mml:mi></mml:mrow></mml:math></inline-formula>, the following holds:
<disp-formula id="eqn-32"><label>(32)</label><mml:math id="mml-eqn-32" display="block"><mml:mtable columnalign="right left right left right left right left right left right left" rowspacing="3pt" columnspacing="0em 2em 0em 2em 0em 2em 0em 2em 0em 2em 0em" displaystyle="true"><mml:mtr><mml:mtd><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:mtd><mml:mtd><mml:mi></mml:mi><mml:mo>=</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mrow><mml:mi mathvariant="double-struck">E</mml:mi></mml:mrow><mml:mo stretchy="false">[</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">]</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:mtd></mml:mtr><mml:mtr><mml:mtd /><mml:mtd><mml:mi></mml:mi><mml:mo>&#x2264;</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:mrow><mml:mi mathvariant="double-struck">E</mml:mi></mml:mrow><mml:mo stretchy="false">[</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo stretchy="false">)</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo stretchy="false">]</mml:mo></mml:mtd></mml:mtr><mml:mtr><mml:mtd /><mml:mtd><mml:mi></mml:mi><mml:mo>&#x2264;</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:mo>&#x2225;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:msub><mml:mo stretchy="false">&#x2225;</mml:mo><mml:mi mathvariant="normal">&#x221E;</mml:mi></mml:msub></mml:mtd></mml:mtr></mml:mtable></mml:math></disp-formula></p>
<p>Taking the supremum yields <inline-formula id="ieqn-261"><mml:math id="mml-ieqn-261"><mml:mo stretchy="false">&#x2225;</mml:mo><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo>&#x2212;</mml:mo><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:msub><mml:mo>&#x2225;</mml:mo><mml:mi mathvariant="normal">&#x221E;</mml:mi></mml:msub><mml:mo>&#x2264;</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:mo>&#x2225;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:msub><mml:mo stretchy="false">&#x2225;</mml:mo><mml:mi mathvariant="normal">&#x221E;</mml:mi></mml:msub></mml:math></inline-formula>, and the proof is completed.&#x2002;&#x2002;&#x2002;&#x25A1;</p>
<p><bold>Theorem 2:</bold> <italic>The Bellman optimality operator</italic> <inline-formula id="ieqn-262"><mml:math id="mml-ieqn-262"><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mo>&#x2217;</mml:mo></mml:msup></mml:math></inline-formula> <italic>is a</italic> <inline-formula id="ieqn-263"><mml:math id="mml-ieqn-263"><mml:mi>&#x03B3;</mml:mi></mml:math></inline-formula><italic>-contraction mapping</italic>.</p>
<p><bold>Proof:</bold> For any <inline-formula id="ieqn-264"><mml:math id="mml-ieqn-264"><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo>,</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo>&#x2208;</mml:mo><mml:mrow><mml:mi>&#x1D4AC;</mml:mi></mml:mrow></mml:math></inline-formula>, the following holds:
<disp-formula id="eqn-33"><label>(33)</label><mml:math id="mml-eqn-33" display="block"><mml:mtable columnalign="right left right left right left right left right left right left" rowspacing="3pt" columnspacing="0em 2em 0em 2em 0em 2em 0em 2em 0em 2em 0em" displaystyle="true"><mml:mtr><mml:mtd><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mo>&#x2217;</mml:mo></mml:msup><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mo>&#x2217;</mml:mo></mml:msup><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:mi>b</mml:mi><mml:mo>,</mml:mo><mml:mi>a</mml:mi><mml:mo stretchy="false">)</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow></mml:mtd><mml:mtd><mml:mi></mml:mi><mml:mo>=</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:mrow><mml:mo>|</mml:mo><mml:mrow><mml:mi mathvariant="double-struck">E</mml:mi></mml:mrow><mml:mrow><mml:mo>[</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">max</mml:mo><mml:mrow><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup></mml:mrow></mml:munder><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">max</mml:mo><mml:mrow><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup></mml:mrow></mml:munder><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo>]</mml:mo></mml:mrow><mml:mo>]</mml:mo></mml:mrow></mml:mtd></mml:mtr><mml:mtr><mml:mtd /><mml:mtd><mml:mi></mml:mi><mml:mo>&#x2264;</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:mrow><mml:mi mathvariant="double-struck">E</mml:mi></mml:mrow><mml:mrow><mml:mo>[</mml:mo><mml:munder><mml:mo movablelimits="true" form="prefix">max</mml:mo><mml:mrow><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup></mml:mrow></mml:munder><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:mo stretchy="false">(</mml:mo><mml:msup><mml:mi>b</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:msup><mml:mi>a</mml:mi><mml:mrow><mml:mi mathvariant="normal">&#x2032;</mml:mi></mml:mrow></mml:msup><mml:mo stretchy="false">)</mml:mo><mml:mrow><mml:mo stretchy="false">|</mml:mo></mml:mrow><mml:mo>]</mml:mo></mml:mrow></mml:mtd></mml:mtr><mml:mtr><mml:mtd /><mml:mtd><mml:mi></mml:mi><mml:mo>&#x2264;</mml:mo><mml:mi>&#x03B3;</mml:mi><mml:mo>&#x2225;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>1</mml:mn></mml:msub><mml:mo>&#x2212;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>2</mml:mn></mml:msub><mml:msub><mml:mo stretchy="false">&#x2225;</mml:mo><mml:mi mathvariant="normal">&#x221E;</mml:mi></mml:msub></mml:mtd></mml:mtr></mml:mtable></mml:math></disp-formula></p>
<p>Thus, <inline-formula id="ieqn-265"><mml:math id="mml-ieqn-265"><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mo>&#x2217;</mml:mo></mml:msup></mml:math></inline-formula> is also a <inline-formula id="ieqn-266"><mml:math id="mml-ieqn-266"><mml:mi>&#x03B3;</mml:mi></mml:math></inline-formula>-contraction mapping.</p>
<p>According to the Banach fixed-point theorem, a contraction mapping has a unique fixed point in a complete metric space. Therefore, the Bellman expectation operator <inline-formula id="ieqn-267"><mml:math id="mml-ieqn-267"><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup></mml:math></inline-formula> and the optimality operator <inline-formula id="ieqn-268"><mml:math id="mml-ieqn-268"><mml:msup><mml:mrow><mml:mi>&#x1D4AF;</mml:mi></mml:mrow><mml:mo>&#x2217;</mml:mo></mml:msup></mml:math></inline-formula> have unique fixed points <inline-formula id="ieqn-269"><mml:math id="mml-ieqn-269"><mml:msup><mml:mi>Q</mml:mi><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup></mml:math></inline-formula> and <inline-formula id="ieqn-270"><mml:math id="mml-ieqn-270"><mml:msup><mml:mi>Q</mml:mi><mml:mo>&#x2217;</mml:mo></mml:msup></mml:math></inline-formula>, respectively, which satisfy:
<disp-formula id="eqn-34"><label>(34)</label><mml:math id="mml-eqn-34" display="block"><mml:msup><mml:mi>T</mml:mi><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:msup><mml:mi>Q</mml:mi><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:mo>=</mml:mo><mml:msup><mml:mi>Q</mml:mi><mml:mrow><mml:msub><mml:mi>&#x03C0;</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:mrow></mml:msup><mml:mo>,</mml:mo><mml:mspace width="1em" /><mml:msup><mml:mi>T</mml:mi><mml:mo>&#x2217;</mml:mo></mml:msup><mml:msup><mml:mi>Q</mml:mi><mml:mo>&#x2217;</mml:mo></mml:msup><mml:mo>=</mml:mo><mml:msup><mml:mi>Q</mml:mi><mml:mo>&#x2217;</mml:mo></mml:msup></mml:math></disp-formula></p>
<p>Let the <italic>Q</italic>-function at the <inline-formula id="ieqn-271"><mml:math id="mml-ieqn-271"><mml:mi>k</mml:mi></mml:math></inline-formula>-th iteration be <inline-formula id="ieqn-272"><mml:math id="mml-ieqn-272"><mml:msub><mml:mi>Q</mml:mi><mml:mi>k</mml:mi></mml:msub></mml:math></inline-formula>, then the iteration error satisfies:
<disp-formula id="eqn-35"><label>(35)</label><mml:math id="mml-eqn-35" display="block"><mml:mo stretchy="false">&#x2225;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mi>k</mml:mi></mml:msub><mml:mo>&#x2212;</mml:mo><mml:msup><mml:mi>Q</mml:mi><mml:mo>&#x2217;</mml:mo></mml:msup><mml:msub><mml:mo>&#x2225;</mml:mo><mml:mi mathvariant="normal">&#x221E;</mml:mi></mml:msub><mml:mo>&#x2264;</mml:mo><mml:msup><mml:mi>&#x03B3;</mml:mi><mml:mi>k</mml:mi></mml:msup><mml:mo>&#x2225;</mml:mo><mml:msub><mml:mi>Q</mml:mi><mml:mn>0</mml:mn></mml:msub><mml:mo>&#x2212;</mml:mo><mml:msup><mml:mi>Q</mml:mi><mml:mo>&#x2217;</mml:mo></mml:msup><mml:msub><mml:mo>&#x2225;</mml:mo><mml:mi mathvariant="normal">&#x221E;</mml:mi></mml:msub><mml:mo>+</mml:mo><mml:mfrac><mml:mo>&#x03B5;</mml:mo><mml:mrow><mml:mn>1</mml:mn><mml:mo>&#x2212;</mml:mo><mml:mi>&#x03B3;</mml:mi></mml:mrow></mml:mfrac></mml:math></disp-formula>where <inline-formula id="ieqn-273"><mml:math id="mml-ieqn-273"><mml:mo>&#x03B5;</mml:mo></mml:math></inline-formula> denotes the function approximation error. As <inline-formula id="ieqn-274"><mml:math id="mml-ieqn-274"><mml:mi>k</mml:mi><mml:mo stretchy="false">&#x2192;</mml:mo><mml:mi mathvariant="normal">&#x221E;</mml:mi></mml:math></inline-formula>, <inline-formula id="ieqn-275"><mml:math id="mml-ieqn-275"><mml:msup><mml:mi>&#x03B3;</mml:mi><mml:mi>k</mml:mi></mml:msup><mml:mo stretchy="false">&#x2192;</mml:mo><mml:mn>0</mml:mn></mml:math></inline-formula>, and the algorithm converges.&#x2002;&#x2002;&#x2002;&#x2003;&#x25A1;</p>
</sec>
<sec id="s4_6">
<label>4.6</label>
<title>Discussion on Practical Issues</title>
<p>First, in the task offloading problem, traditional methods often rely on global state information, resulting in high communication costs. This paper adopts a partially observable modeling approach, enabling terminal devices to make decisions based solely on local observations. This design reduces the frequency of state transmission.</p>
<p>Second, the terminal devices in this study only need to obtain minimal local state information, reducing the risk of privacy leakage from the source.</p>
<p>Finally, the system architecture of this paper adopts a &#x201C;centralized training-distributed execution&#x201D; mode, which provides a theoretical basis for large-scale deployment. This modular design allows the system to linearly expand its processing capacity by adding edge nodes.</p>
</sec>
</sec>
<sec id="s5">
<label>5</label>
<title>Performance Evaluation</title>
<p>This section details the experimental setup and results of the algorithm proposed in this section in a simulation environment. The evaluation metrics include average task delay, task failure rate under varying terminal device counts and task arrival rates, as well as the reward curve of each algorithm. Simulations are conducted on a desktop equipped with an AMD Ryzen 7 5700X 8-Core Processor, an NVIDIA GeForce RTX 3070Ti GPU, and 32 GB RAM.</p>
<sec id="s5_1">
<label>5.1</label>
<title>Experimental Parameter Settings</title>
<p>A simulation scenario with four edge servers is built. Specific parameters are in <xref ref-type="table" rid="table-1">Table 1</xref>. Neural network settings: batch size &#x003D; 4, learning rate &#x003D; 0.001, discount factor &#x003D; 0.9, random exploration probability decays from 1 to 0.01. The root mean square propagation (RMSPROP) optimizer is used. The configuration of experimental parameters is based on the typical characteristics of real-world edge computing environments and research requirements. First, the time slot duration <inline-formula id="ieqn-276"><mml:math id="mml-ieqn-276"><mml:mi>&#x03B4;</mml:mi></mml:math></inline-formula> is set to 100 milliseconds to match the fine-grained time unit for task scheduling in edge computing, thereby avoiding delay inaccuracies caused by excessive discretization. The CPU frequency of terminal devices (<inline-formula id="ieqn-277"><mml:math id="mml-ieqn-277"><mml:msub><mml:mi>f</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula> &#x003D; 2.5 GHz) and the frequency of edge servers (<inline-formula id="ieqn-278"><mml:math id="mml-ieqn-278"><mml:msub><mml:mi>f</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:math></inline-formula> &#x003D; 41.8 GHz) refer to the common configurations in [<xref ref-type="bibr" rid="ref-27">27</xref>], which reflects the heterogeneity of resources. The transmission rate <inline-formula id="ieqn-279"><mml:math id="mml-ieqn-279"><mml:msubsup><mml:mi>O</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup></mml:math></inline-formula> &#x003D; 14 Mbps corresponds to the bandwidth of a typical wireless network, while the processing density <inline-formula id="ieqn-280"><mml:math id="mml-ieqn-280"><mml:msub><mml:mi>&#x03C1;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula> &#x003D; 500 is determined based on the average number of CPU cycles required per unit of data, so as to balance the computational load. The delay constraint <inline-formula id="ieqn-281"><mml:math id="mml-ieqn-281"><mml:msub><mml:mi>&#x03C4;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula> &#x003D; 12 time slots is tailored for delay-sensitive applications, ensuring that tasks are completed within a reasonable time. Overall, the selection of parameters aims to simulate dynamic multi-access scenarios, verify the robustness of the algorithm under resource constraints, and provide a consistent benchmark for comparative experiments.</p>
<table-wrap id="table-1">
<label>Table 1</label>
<caption>
<title>Parameter settings.</title>
</caption>
<table>
<colgroup>
<col align="center"/>
<col align="center"/> </colgroup>
<thead>
<tr>
<th>Parameters</th>
<th>Value</th>
</tr>
</thead>
<tbody>
<tr>
<td><inline-formula id="ieqn-282"><mml:math id="mml-ieqn-282"><mml:mi>&#x03B4;</mml:mi></mml:math></inline-formula></td>
<td>100 ms</td>
</tr>
<tr>
<td><inline-formula id="ieqn-283"><mml:math id="mml-ieqn-283"><mml:msub><mml:mi>f</mml:mi><mml:mi>d</mml:mi></mml:msub></mml:math></inline-formula></td>
<td>2.5 GHz [<xref ref-type="bibr" rid="ref-27">27</xref>]</td>
</tr>
<tr>
<td><inline-formula id="ieqn-284"><mml:math id="mml-ieqn-284"><mml:msub><mml:mi>f</mml:mi><mml:mi>e</mml:mi></mml:msub></mml:math></inline-formula></td>
<td>41.8 GHz [<xref ref-type="bibr" rid="ref-27">27</xref>]</td>
</tr>
<tr>
<td><inline-formula id="ieqn-285"><mml:math id="mml-ieqn-285"><mml:msubsup><mml:mi>O</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>e</mml:mi></mml:mrow><mml:mrow><mml:mi>t</mml:mi><mml:mi>r</mml:mi><mml:mi>a</mml:mi><mml:mi>n</mml:mi></mml:mrow></mml:msubsup></mml:math></inline-formula></td>
<td>14 Mbps</td>
</tr>
<tr>
<td><inline-formula id="ieqn-286"><mml:math id="mml-ieqn-286"><mml:msub><mml:mi>&#x03C1;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula></td>
<td>500</td>
</tr>
<tr>
<td><inline-formula id="ieqn-287"><mml:math id="mml-ieqn-287"><mml:msub><mml:mi>&#x03C4;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula></td>
<td>12 time slots</td>
</tr>
<tr>
<td><inline-formula id="ieqn-288"><mml:math id="mml-ieqn-288"><mml:mi>n</mml:mi></mml:math></inline-formula></td>
<td>4</td>
</tr>
<tr>
<td><inline-formula id="ieqn-289"><mml:math id="mml-ieqn-289"><mml:mi>C</mml:mi><mml:mi>o</mml:mi><mml:mi>n</mml:mi><mml:mi>s</mml:mi><mml:mi>t</mml:mi></mml:math></inline-formula></td>
<td><inline-formula id="ieqn-290"><mml:math id="mml-ieqn-290"><mml:mo>&#x2212;</mml:mo><mml:mn>3</mml:mn><mml:msub><mml:mi>&#x03C4;</mml:mi><mml:mrow><mml:mi>d</mml:mi><mml:mo>,</mml:mo><mml:mi>t</mml:mi></mml:mrow></mml:msub></mml:math></inline-formula></td>
</tr>
</tbody>
</table>
</table-wrap>
</sec>
<sec id="s5_2">
<label>5.2</label>
<title>Introduction to Experimental Comparison Methods</title>
<p>The proposed task offloading algorithm (CRB-DRQN) is compared with the following benchmark algorithms:</p>
<p>(1) Decentralized algorithm: A decentralized actor-critic algorithm which contrasts with the centralized training/distributed execution framework of the proposed algorithm. Agents update networks independently using local observations, with no inter-agent information sharing.</p>
<p>(2) Local-Only strategy: Forces all agents to process computational tasks locally, omitting any offloading decision-making.</p>
<p>(3) <italic>Q</italic>-value Mixing (QMIX) algorithm [<xref ref-type="bibr" rid="ref-28">28</xref>]: A value-learning-based multi-agent reinforcement learning algorithm for solving cooperative task interaction/reward distribution challenges. It uses cross-entropy optimization for action selection, which is adapted to continuous action spaces. Implementation follows literature [<xref ref-type="bibr" rid="ref-29">29</xref>].</p>
<p>(4) Multi-Agent Proximal Policy Optimization (MAPPO) algorithm [<xref ref-type="bibr" rid="ref-30">30</xref>]: An actor-critic algorithm for multi-agent scenarios, optimized for continuous action spaces and massively parallel computing environments.</p>
<p>(5) Joint Optimal DRL Algorithm with Privacy Preservation (JODRL-PP) [<xref ref-type="bibr" rid="ref-5">5</xref>]: An actor-critic-based task offloading algorithm. It addresses incomplete multi-user information sharing via a third-party centralized training network, enabling effective offloading strategy learning.</p>
<p>(6) Multi-Tier offloading model [<xref ref-type="bibr" rid="ref-31">31</xref>] based on game theory principles. It addresses the limitations of edge server computational resources and inefficient resource allocation in vehicular networks by dividing the offloading process into two stages.</p>
</sec>
<sec id="s5_3">
<label>5.3</label>
<title>Evaluation of Experimental Results</title>
<sec id="s5_3_1">
<label>5.3.1</label>
<title>Convergence of the Algorithm</title>
<p><xref ref-type="fig" rid="fig-4">Fig. 4</xref> intuitively demonstrates the fast convergence property of the CRB-DRQN algorithm by comparing the average reward evolution curves of different algorithms. Experimental data show that the CRB-DRQN algorithm reaches steady-state convergence after approximately 170 training episodes, with the final average reward stabilizing in the &#x2212;0.5 range-significantly outperforming the other benchmark algorithms (e.g., the JODRL-PP algorithm requires 410 episodes to converge and exhibits reward jump phenomena). This efficient convergence stems from the core design of the algorithm: first, the Double DQN and Target network mechanism effectively suppress the overestimation of <italic>Q</italic>-values by decoupling action selection and value evaluation; second, the centralized training architecture integrates global experience trajectories through a third-party trusted authority, enabling agents to obtain an approximate global perspective in partially observable environments and avoiding policy oscillations caused by environmental non-stationarity in decentralized algorithms. In addition, the similarity-based trajectory sampling mechanism further optimizes exploration efficiency by dynamically adjusting the sampling probability of high-value experiences, promoting the smooth approximation of the <italic>Q</italic>-function to the optimal solution.</p>
<fig id="fig-4">
<label>Figure 4</label>
<caption>
<title>Average rewards of different algorithms and Convergence time of CRB-DRQN algorithm.</title>
</caption>
<graphic mimetype="image" mime-subtype="tif" xlink:href="CMC_72505-fig-4.tif"/>
</fig>
<p><xref ref-type="fig" rid="fig-4">Fig. 4</xref> also illustrates the variation trend of the convergence time of single agent under different terminal device scales, and its linear growth pattern verifies the algorithm&#x2019;s stability in dynamic scaling scenarios. When the CRB-DRQN algorithm faces the expansion of large-scale terminal devices and edge server clusters, its distributed execution architecture ensures system scalability through a three-layer mechanism. First, the &#x201C;centralized training-distributed execution&#x201D; framework enables terminal devices to make independent real-time decisions based on local observed states, while edge servers achieve dynamic allocation of computational loads through asynchronous training and parameter updates, effectively avoiding single-point bottlenecks. Specifically, when the number of terminal devices increases from 5 to 35, the convergence time only rises approximately linearly, indicating that the algorithm has strong robustness to scale expansion. When the algorithm is scaled to larger-scale scenarios, the computational pressure can be dispersed by adding edge nodes, and the processing capacity can be expanded linearly.</p>

</sec>
<sec id="s5_3_2">
<label>5.3.2</label>
<title>Comparison of Task Delay and Failure Rate under Different Terminal Device Scales</title>
<p><xref ref-type="fig" rid="fig-5">Fig. 5a</xref> shows the comparison results of the average latency of each algorithm task at different terminal device scales. Although the average latency of all algorithms is controlled within the latency constraints, it should be noted that this metric only counts successfully processed tasks and does not include discarded tasks due to insufficient resources. Except for the Local-Only algorithm, the average computing latency of the other algorithms increases monotonically with the expansion of the terminal device. Compute latency is related to the computing resources and load of the device. As the number of terminal devices increases, the number of tasks that each edge server needs to process increase, which directly leads to an increase in queue wait times, resulting in an increase in the average latency of computing. The CRB-DRQN algorithm maintains a low latency level under different terminal device scales. When the number of terminal devices is 5, the latency (0.50 s) is 46.8%, 15.3%, and 13.8% lower than that of the Decentralized algorithm (0.94 s), the MAPPO algorithm (0.59 s), and the JODRL-PP algorithm (0.58 s), respectively, slightly higher than the QMIX algorithm (0.48 s). It is worth noting that the latency gap between the JODRL-PP algorithm and the CRB-DRQN algorithm gradually decreases with the increase of device scale, and when the number of terminal devices reaches 25, the latency value of the two algorithms tends to be the same level (CRB-DRQN algorithm: 0.762 s, JODRL-PP algorithm: 0.767 s). This phenomenon can be attributed to the performance optimization of the CRB-DRQN algorithm through the following mechanisms: firstly, by improving the neural network, it has better load awareness ability in dynamically changing scenarios, and secondly, through the global experience sharing mechanism realized by the central trajectory pool, so that each agent can learn the optimal offloading strategy collaboratively, effectively reducing the local decision bias.</p>
<fig id="fig-5">
<label>Figure 5</label>
<caption>
<title>Task delay and failure rate under varying scales of terminal devices. Figure (<bold>a</bold>) shows the comparison results of the average latency of each algorithm task at different terminal device scales. Figure (<bold>b</bold>) presents how terminal device scale affects task failure rates.</title>
</caption>
<graphic mimetype="image" mime-subtype="tif" xlink:href="CMC_72505-fig-5.tif"/>
</fig>
<p><xref ref-type="fig" rid="fig-5">Fig. 5b</xref> presents how terminal device scale affects task failure rates. Experimental data indicate that at 25 devices, task failure rates diverge significantly: Local-Only fails to handle high concurrency due to limited local resources. The Decentralized and QMIX algorithms see linear failure rate growth with scale expansion, reaching 0.42 and 0.37 respectively at 25 devices. MAPPO shows a conservative strategy, with its failure rate stably within 0.24 <inline-formula id="ieqn-291"><mml:math id="mml-ieqn-291"><mml:mo>&#x00B1;</mml:mo></mml:math></inline-formula> 0.02. Conversely, JODRL-PP and Multi-tier offloading control the failure rate at 0.04 for 25 devices. The proposed CRB-DRQN algorithm achieves global state awareness via the central trajectory pool, stabilizing the final task failure rate at 0.017%&#x2013;57.5% lower than JODRL-PP and the Multi-tier offloading strategy. This validates the empirical playback mechanism&#x2019;s role in enhancing system reliability.</p>

</sec>
<sec id="s5_3_3">
<label>5.3.3</label>
<title>Comparison of Task Delay and Failure Rate under Different Task Scales</title>
<p>This section compares the convergence of the algorithm, the task delay and failure rate at different terminal device scales, and the task delay and failure rate at different task scales.</p>
<p><xref ref-type="fig" rid="fig-6">Fig. 6a</xref> presents the average latency across different task sizes. As the task arrival rate rises from 1.0 to 3.0 Mbps, all algorithms&#x2019; average latencies increase. At 1.0 Mbps, our CRB-DRQN algorithm (0.43 s) outperforms Decentralized (0.90 s), QMIX (0.53 s), and MAPPO (0.71 s), matching JODRL-PP (0.43 s) and Multi-tier offloading (0.42 s) but slightly higher than Local-Only (0.38 s). When the rate hits 3.0 Mbps, Local-Only latency spikes to 0.89 s (and keeps rising) due to terminal devices&#x2019; local computing resource constraints. Notably, Local-Only still outperforms Decentralized, QMIX, and MAPPO, whose longer waiting times create efficiency bottlenecks in their offloading strategies. CRB-DRQN maintains the lowest latency between 1.5&#x2013;2.5 Mbps. At 3.0 Mbps, its 0.73 s latency is marginally higher than JODRL-PP&#x2019;s 0.72 s and Multi-tier offloading 0.72 s, revealing CRB-DRQN&#x2019;s optimization boundary under high load.</p>
<fig id="fig-6">
<label>Figure 6</label>
<caption>
<title>Task delay and failure rate under varying task scales. Figure (<bold>a</bold>) presents the average latency across different task sizes. Figure (<bold>b</bold>) compares task failure rates under different task sizes.</title>
</caption>
<graphic mimetype="image" mime-subtype="tif" xlink:href="CMC_72505-fig-6.tif"/>
</fig>
<p><xref ref-type="fig" rid="fig-6">Fig. 6b</xref> compares task failure rates under different task sizes. Experimental data indicate that as task arrival rate rises from 1.0 to 3.0 Mbps, failure rates of the Decentralized and Local-Only algorithms soar from 0.18, 0.014 to 0.52, 0.37, respectively. The former suffers from environmental instability, hampering effective strategy execution; the latter is limited by insufficient local computing power to meet demands. The JODRL-PP, Multi-tier offloading, and CRB-DRQN algorithms exhibit strong reliability and robustness, with maximum failure rates of 0.052 (JODRL-PP, 3.0 Mbps), 0.051 (Multi-tier offloading, 3.0 Mbps) and 0.057 (CRB-DRQN, 3.0 Mbps). Within 1.0&#x2013;2.5 Mbps task arrival rate, CRB-DRQN outperforms others; yet at 3.0 Mbps, its failure rate (0.057) marginally exceeds JODRL-PP&#x2019;s 0.052 and Multi-tier offloading&#x2019;s 0.056. <xref ref-type="fig" rid="fig-6">Fig. 6</xref> suggests CRB-DRQN still has optimization potential under high load, possibly due to mismatches between neural network-perceived and actual load levels.</p>

</sec>
</sec>
</sec>
<sec id="s6">
<label>6</label>
<title>Conclusion</title>
<p>To address core challenges in MEC environments-including a large number of terminal devices and frequent dynamic changes in system states-this section proposes a end-edge collaborative task offloading method based on POMDP. A three-layer offloading framework encompassing edge computing resources, terminal devices, and third-party trusted authority is constructed to solve the policy mismatch problem caused by environmental dynamics in traditional algorithms. At the modeling level, a slotted transmission and computation model is innovatively introduced to quantify task processing delay and queue dynamics, and a partially observable state space is built based on edge server load history to reduce system information interaction overhead.</p>
<p>The proposed CRB-DRQN algorithm adopts a hybrid architecture of centralized experience sharing and distributed policy execution: through a central trajectory pool constructed by third-party trusted authority, it achieves safe integration and efficient reuse of cross-agent experience trajectories; a familiarity trajectory sampling mechanism is designed to optimize the distribution of training samples, effectively alleviating the policy lag problem of traditional experience replay mechanisms in dynamic environments; the neural network structure designed based on DDQN and LSTM enhances the prediction ability of edge server load fluctuations, enabling agents to make accurate offloading decisions under partially observable conditions.</p>
<p>Experimental results show that CRB-DRQN exhibits significant advantages in scenarios with expanded terminal device scales and dynamic changes in task loads, providing a new solution for task offloading in MEC environments and effectively improving system reliability and offloading efficiency.</p>
<p>In real-world environments, the dynamic changes of tasks and resources are often more frequent and complex. The performance of the algorithm can be evaluated in a demonstration system, thereby identifying and resolving more potential issues. Additionally, game theory can be combined with multi-agent reinforcement learning techniques to further explore the mechanism of strategic interaction among multiple devices.</p>
</sec>
</body>
<back>
<ack>
<p>Not applicable.</p>
</ack>
<sec>
<title>Funding Statement</title>
<p>This work was funded by the State Grid Corporation Science and Technology Project &#x201C;Research and Application of Key Technologies for Integrated Sensing and Computing for Intelligent Operation of Power Grid&#x201D;(Grant No. 5700-202318596A-3-2-ZN).</p>
</sec>
<sec>
<title>Author Contributions</title>
<p>The authors confirm contribution to the paper as follows: Conceptualization, Wang Luo and Bao Feng; methodology, Wang Luo and Jinwei Mao; software, Jinwei Mao, Shuang Yang, Daohua Zhu and Wei Liang; validation, Shuang Yang, Jiangtao Xu and Zhechen Huang; formal analysis, Jinwei Mao and Bao Feng; investigation, Shuang Yang and Jiangtao Xu; resources, Daohua Zhu and Wang Luo; data curation, Jiangtao Xu, Zhechen Huang and Wei Liang; writing&#x2014;original draft preparation, Jinwei Mao, Wang Luo, Shuang Yang, Daohua Zhu and Zhechen Huang; writing&#x2014;review and editing, Bao Feng, Jiangtao Xu, Zhechen Huang and Wei Liang; visualization, Jinwei Mao, Bao Feng, Zhechen Huang and Wei Liang; supervision, Wang Luo and Daohua Zhu; project administration, Wang Luo, Jiangtao Xu and Daohua Zhu; funding acquisition, Wang Luo and Daohua Zhu. All authors reviewed and approved the final version of the manuscript.</p>
</sec>
<sec sec-type="data-availability">
<title>Availability of Data and Materials</title>
<p>The data and materials are not publicly available.</p>
</sec>
<sec>
<title>Ethics Approval</title>
<p>Not applicable.</p>
</sec>
<sec sec-type="COI-statement">
<title>Conflicts of Interest</title>
<p>The authors declare no conflicts of interest.</p>
</sec>
<ref-list content-type="authoryear">
<title>References</title>
<ref id="ref-1"><label>[1]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Zhang</surname> <given-names>C</given-names></string-name>, <string-name><surname>Yang</surname> <given-names>J</given-names></string-name></person-group>. <article-title>Multi-tree genetic programming for adaptive dynamic fault-tolerant task scheduling of satellite edge computing</article-title>. <source>Future Gener Comput Syst</source>. <year>2026</year>;<volume>175</volume>:<fpage>108099</fpage>. doi:<pub-id pub-id-type="doi">10.1016/j.future.2025.108099</pub-id>.</mixed-citation></ref>
<ref id="ref-2"><label>[2]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Ranaweera</surname> <given-names>P</given-names></string-name>, <string-name><surname>Jurcut</surname> <given-names>AD</given-names></string-name>, <string-name><surname>Liyanage</surname> <given-names>M</given-names></string-name></person-group>. <article-title>Survey on multi-access edge computing security and privacy</article-title>. <source>IEEE Commun Surv Tutor</source>. <year>2021</year>;<volume>23</volume>(<issue>2</issue>):<fpage>1078</fpage>&#x2013;<lpage>124</lpage>. doi:<pub-id pub-id-type="doi">10.1109/comst.2021.3062546</pub-id>.</mixed-citation></ref>
<ref id="ref-3"><label>[3]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Tang</surname> <given-names>X</given-names></string-name>, <string-name><surname>Li</surname> <given-names>X</given-names></string-name>, <string-name><surname>Yu</surname> <given-names>R</given-names></string-name>, <string-name><surname>Wu</surname> <given-names>Y</given-names></string-name>, <string-name><surname>Ye</surname> <given-names>J</given-names></string-name>, <string-name><surname>Tang</surname> <given-names>F</given-names></string-name>, <etal>et al</etal></person-group>. <article-title>Digital-twin-assisted task assignment in multi-UAV systems: a deep reinforcement learning approach</article-title>. <source>IEEE Internet Things J</source>. <year>2023</year>;<volume>10</volume>(<issue>17</issue>):<fpage>15362</fpage>&#x2013;<lpage>75</lpage>. doi:<pub-id pub-id-type="doi">10.1109/jiot.2023.3263574</pub-id>.</mixed-citation></ref>
<ref id="ref-4"><label>[4]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Lou</surname> <given-names>J</given-names></string-name>, <string-name><surname>Tang</surname> <given-names>Z</given-names></string-name>, <string-name><surname>Jia</surname> <given-names>W</given-names></string-name>, <string-name><surname>Zhao</surname> <given-names>W</given-names></string-name>, <string-name><surname>Li</surname> <given-names>J</given-names></string-name></person-group>. <article-title>Startup-aware dependent task scheduling with bandwidth constraints in edge computing</article-title>. <source>IEEE Trans Mob Comput</source>. <year>2023</year>;<volume>23</volume>(<issue>2</issue>):<fpage>1586</fpage>&#x2013;<lpage>600</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tmc.2023.3238868</pub-id>.</mixed-citation></ref>
<ref id="ref-5"><label>[5]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Wu</surname> <given-names>G</given-names></string-name>, <string-name><surname>Chen</surname> <given-names>X</given-names></string-name>, <string-name><surname>Gao</surname> <given-names>Z</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>H</given-names></string-name>, <string-name><surname>Yu</surname> <given-names>S</given-names></string-name>, <string-name><surname>Shen</surname> <given-names>S</given-names></string-name></person-group>. <article-title>Privacy-preserving offloading scheme in multi-access mobile edge computing based on MADRL</article-title>. <source>J Parallel Distrib Comput</source>. <year>2024</year>;<volume>183</volume>:<fpage>104775</fpage>. doi:<pub-id pub-id-type="doi">10.1016/j.jpdc.2023.104775</pub-id>.</mixed-citation></ref>
<ref id="ref-6"><label>[6]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Sun</surname> <given-names>F</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>Z</given-names></string-name>, <string-name><surname>Chang</surname> <given-names>X</given-names></string-name>, <string-name><surname>Zhu</surname> <given-names>K</given-names></string-name></person-group>. <article-title>Toward heterogeneous environment: lyapunov-orientated imphetero reinforcement learning for task offloading</article-title>. <source>IEEE Trans Netw Serv Manag</source>. <year>2023</year>;<volume>20</volume>(<issue>2</issue>):<fpage>1572</fpage>&#x2013;<lpage>86</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tnsm.2023.3266779</pub-id>.</mixed-citation></ref>
<ref id="ref-7"><label>[7]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Jiang</surname> <given-names>X</given-names></string-name>, <string-name><surname>Yu</surname> <given-names>FR</given-names></string-name>, <string-name><surname>Song</surname> <given-names>T</given-names></string-name>, <string-name><surname>Leung</surname> <given-names>VC</given-names></string-name></person-group>. <article-title>A survey on multi-access edge computing applied to video streaming: some research issues and challenges</article-title>. <source>IEEE Commun Surv Tutor</source>. <year>2021</year>;<volume>23</volume>(<issue>2</issue>):<fpage>871</fpage>&#x2013;<lpage>903</lpage>. doi:<pub-id pub-id-type="doi">10.1109/comst.2021.3065237</pub-id>.</mixed-citation></ref>
<ref id="ref-8"><label>[8]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Xu</surname> <given-names>X</given-names></string-name>, <string-name><surname>Liu</surname> <given-names>K</given-names></string-name>, <string-name><surname>Dai</surname> <given-names>P</given-names></string-name>, <string-name><surname>Jin</surname> <given-names>F</given-names></string-name>, <string-name><surname>Ren</surname> <given-names>H</given-names></string-name>, <string-name><surname>Zhan</surname> <given-names>C</given-names></string-name>, <etal>et al</etal></person-group>. <article-title>Joint task offloading and resource optimization in NOMA-based vehicular edge computing: a game-theoretic DRL approach</article-title>. <source>J Syst Archit</source>. <year>2023</year>;<volume>134</volume>(<issue>1</issue>):<fpage>102780</fpage>. doi:<pub-id pub-id-type="doi">10.1016/j.sysarc.2022.102780</pub-id>.</mixed-citation></ref>
<ref id="ref-9"><label>[9]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Zhang</surname> <given-names>C</given-names></string-name>, <string-name><surname>Yang</surname> <given-names>J</given-names></string-name></person-group>. <article-title>An energy-efficient collaborative offloading scheme with heterogeneous tasks for satellite edge computing</article-title>. <source>IEEE Trans Netw Sci Eng</source>. <year>2024</year>;<volume>11</volume>(<issue>6</issue>):<fpage>6396</fpage>&#x2013;<lpage>407</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tnse.2024.3476968</pub-id>.</mixed-citation></ref>
<ref id="ref-10"><label>[10]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Huang</surname> <given-names>X</given-names></string-name>, <string-name><surname>Huang</surname> <given-names>G</given-names></string-name></person-group>. <article-title>Joint optimization of energy and task scheduling in wireless-powered irs-assisted mobile-edge computing systems</article-title>. <source>IEEE Internet Things J</source>. <year>2023</year>;<volume>10</volume>(<issue>12</issue>):<fpage>10997</fpage>&#x2013;<lpage>13</lpage>. doi:<pub-id pub-id-type="doi">10.1109/jiot.2023.3242951</pub-id>.</mixed-citation></ref>
<ref id="ref-11"><label>[11]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Deng</surname> <given-names>Y</given-names></string-name>, <string-name><surname>Chen</surname> <given-names>X</given-names></string-name>, <string-name><surname>Zhu</surname> <given-names>G</given-names></string-name>, <string-name><surname>Fang</surname> <given-names>Y</given-names></string-name>, <string-name><surname>Chen</surname> <given-names>Z</given-names></string-name>, <string-name><surname>Deng</surname> <given-names>X</given-names></string-name></person-group>. <article-title>Actions at the edge: jointly optimizing the resources in multi-access edge computing</article-title>. <source>IEEE Wirel Commun</source>. <year>2022</year>;<volume>29</volume>(<issue>2</issue>):<fpage>192</fpage>&#x2013;<lpage>8</lpage>. doi:<pub-id pub-id-type="doi">10.1109/mwc.006.2100699</pub-id>.</mixed-citation></ref>
<ref id="ref-12"><label>[12]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Porambage</surname> <given-names>P</given-names></string-name>, <string-name><surname>Okwuibe</surname> <given-names>J</given-names></string-name>, <string-name><surname>Liyanage</surname> <given-names>M</given-names></string-name>, <string-name><surname>Ylianttila</surname> <given-names>M</given-names></string-name>, <string-name><surname>Taleb</surname> <given-names>T</given-names></string-name></person-group>. <article-title>Survey on multi-access edge computing for internet of things realization</article-title>. <source>IEEE Commun Surv Tutor</source>. <year>2018</year>;<volume>20</volume>(<issue>4</issue>):<fpage>2961</fpage>&#x2013;<lpage>91</lpage>. doi:<pub-id pub-id-type="doi">10.1109/comst.2018.2849509</pub-id>.</mixed-citation></ref>
<ref id="ref-13"><label>[13]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Liu</surname> <given-names>J</given-names></string-name>, <string-name><surname>Yang</surname> <given-names>P</given-names></string-name>, <string-name><surname>Chen</surname> <given-names>C</given-names></string-name></person-group>. <article-title>Intelligent energy-efficient scheduling with ant colony techniques for heterogeneous edge computing</article-title>. <source>J Parall Distrib Comput</source>. <year>2023</year>;<volume>172</volume>:<fpage>84</fpage>&#x2013;<lpage>96</lpage>. doi:<pub-id pub-id-type="doi">10.1016/j.jpdc.2022.10.003</pub-id>.</mixed-citation></ref>
<ref id="ref-14"><label>[14]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Deng</surname> <given-names>X</given-names></string-name>, <string-name><surname>Yin</surname> <given-names>J</given-names></string-name>, <string-name><surname>Guan</surname> <given-names>P</given-names></string-name>, <string-name><surname>Xiong</surname> <given-names>NN</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>L</given-names></string-name>, <string-name><surname>Mumtaz</surname> <given-names>S</given-names></string-name></person-group>. <article-title>Intelligent delay-aware partial computing task offloading for multiuser industrial Internet of Things through edge computing</article-title>. <source>IEEE Internet Things J</source>. <year>2021</year>;<volume>10</volume>(<issue>4</issue>):<fpage>2954</fpage>&#x2013;<lpage>66</lpage>. doi:<pub-id pub-id-type="doi">10.1109/jiot.2021.3123406</pub-id>.</mixed-citation></ref>
<ref id="ref-15"><label>[15]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Li</surname> <given-names>Y</given-names></string-name>, <string-name><surname>Liu</surname> <given-names>B</given-names></string-name>, <string-name><surname>Wu</surname> <given-names>E</given-names></string-name>, <string-name><surname>Li</surname> <given-names>J</given-names></string-name>, <string-name><surname>Zhou</surname> <given-names>Z</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>W</given-names></string-name></person-group>. <article-title>DRA-MQoS: an MQoS scheduling algorithm based on resource feature matching in federated edge cloud</article-title>. <source>Concurr Comput Pract Exp</source>. <year>2023</year>;<volume>35</volume>(<issue>2</issue>):<fpage>e7478</fpage>. doi:<pub-id pub-id-type="doi">10.1002/cpe.7478</pub-id>.</mixed-citation></ref>
<ref id="ref-16"><label>[16]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Liu</surname> <given-names>Q</given-names></string-name>, <string-name><surname>Zeng</surname> <given-names>L</given-names></string-name>, <string-name><surname>Bilal</surname> <given-names>M</given-names></string-name>, <string-name><surname>Song</surname> <given-names>H</given-names></string-name>, <string-name><surname>Liu</surname> <given-names>X</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>Y</given-names></string-name>, <etal>et al</etal></person-group>. <article-title>A multi-swarm PSO approach to large-scale task scheduling in a sustainable supply chain datacenter</article-title>. <source>IEEE Trans Green Commun Netw</source>. <year>2023</year>;<volume>7</volume>(<issue>4</issue>):<fpage>1667</fpage>&#x2013;<lpage>77</lpage>. doi:<pub-id pub-id-type="doi">10.21203/rs.3.rs-1844078/v1</pub-id>.</mixed-citation></ref>
<ref id="ref-17"><label>[17]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Gao</surname> <given-names>A</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>S</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>Q</given-names></string-name>, <string-name><surname>Hu</surname> <given-names>Y</given-names></string-name>, <string-name><surname>Liu</surname> <given-names>S</given-names></string-name>, <string-name><surname>Liang</surname> <given-names>W</given-names></string-name>, <etal>et al</etal></person-group>. <article-title>Task offloading and energy optimization in hybrid UAV-assisted mobile edge computing systems</article-title>. <source>IEEE Trans Veh Technol</source>. <year>2024</year>;<volume>73</volume>(<issue>8</issue>):<fpage>12052</fpage>&#x2013;<lpage>66</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tvt.2024.3380003</pub-id>.</mixed-citation></ref>
<ref id="ref-18"><label>[18]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Cai</surname> <given-names>J</given-names></string-name>, <string-name><surname>Liu</surname> <given-names>W</given-names></string-name>, <string-name><surname>Huang</surname> <given-names>Z</given-names></string-name>, <string-name><surname>Yu</surname> <given-names>FR</given-names></string-name></person-group>. <article-title>Task decomposition and hierarchical scheduling for collaborative cloud-edge-end computing</article-title>. <source>IEEE Trans Serv Comput</source>. <year>2024</year>;<volume>17</volume>(<issue>6</issue>):<fpage>4368</fpage>&#x2013;<lpage>82</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tsc.2024.3402169</pub-id>.</mixed-citation></ref>
<ref id="ref-19"><label>[19]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Chen</surname> <given-names>W</given-names></string-name>, <string-name><surname>Wei</surname> <given-names>X</given-names></string-name>, <string-name><surname>Chi</surname> <given-names>K</given-names></string-name>, <string-name><surname>Yu</surname> <given-names>K</given-names></string-name>, <string-name><surname>Tolba</surname> <given-names>A</given-names></string-name>, <string-name><surname>Mumtaz</surname> <given-names>S</given-names></string-name>, <etal>et al</etal></person-group>. <article-title>Computation time minimized offloading in NOMA-enabled wireless powered mobile edge computing</article-title>. <source>IEEE Trans Commun</source>. <year>2024</year>;<volume>72</volume>(<issue>11</issue>):<fpage>7182</fpage>&#x2013;<lpage>97</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tcomm.2024.3405316</pub-id>.</mixed-citation></ref>
<ref id="ref-20"><label>[20]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Fan</surname> <given-names>W</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>Y</given-names></string-name>, <string-name><surname>Zhou</surname> <given-names>G</given-names></string-name>, <string-name><surname>Liu</surname> <given-names>Y</given-names></string-name></person-group>. <article-title>Deep reinforcement learning-based task offloading for vehicular edge computing with flexible RSU-RSU cooperation</article-title>. <source>IEEE Trans Intell Transp Syst</source>. <year>2024</year>;<volume>25</volume>(<issue>7</issue>):<fpage>7712</fpage>&#x2013;<lpage>25</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tits.2024.3349546</pub-id>.</mixed-citation></ref>
<ref id="ref-21"><label>[21]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Guo</surname> <given-names>H</given-names></string-name>, <string-name><surname>Chen</surname> <given-names>X</given-names></string-name>, <string-name><surname>Zhou</surname> <given-names>X</given-names></string-name>, <string-name><surname>Liu</surname> <given-names>J</given-names></string-name></person-group>. <article-title>Trusted and efficient task offloading in vehicular edge computing networks</article-title>. <source>IEEE Trans Cogn Commun Netw</source>. <year>2024</year>;<volume>10</volume>(<issue>6</issue>):<fpage>2370</fpage>&#x2013;<lpage>82</lpage>. doi:<pub-id pub-id-type="doi">10.1109/globecom48099.2022.10000816</pub-id>.</mixed-citation></ref>
<ref id="ref-22"><label>[22]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Li</surname> <given-names>K</given-names></string-name>, <string-name><surname>Wang</surname> <given-names>X</given-names></string-name>, <string-name><surname>He</surname> <given-names>Q</given-names></string-name>, <string-name><surname>Wang</surname> <given-names>J</given-names></string-name>, <string-name><surname>Li</surname> <given-names>J</given-names></string-name>, <string-name><surname>Zhan</surname> <given-names>S</given-names></string-name>, <etal>et al</etal></person-group>. <article-title>Computation offloading in resource-constrained multi-access edge computing</article-title>. <source>IEEE Trans Mob Comput</source>. <year>2024</year>;<volume>23</volume>(<issue>11</issue>):<fpage>10665</fpage>&#x2013;<lpage>77</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tmc.2024.3383041</pub-id>.</mixed-citation></ref>
<ref id="ref-23"><label>[23]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Li</surname> <given-names>L</given-names></string-name>, <string-name><surname>Qiu</surname> <given-names>Q</given-names></string-name>, <string-name><surname>Xiao</surname> <given-names>Z</given-names></string-name>, <string-name><surname>Lin</surname> <given-names>Q</given-names></string-name>, <string-name><surname>Gu</surname> <given-names>J</given-names></string-name>, <string-name><surname>Ming</surname> <given-names>Z</given-names></string-name></person-group>. <article-title>A two-stage hybrid multi-objective optimization evolutionary algorithm for computing offloading in sustainable edge computing</article-title>. <source>IEEE Trans Consum Electron</source>. <year>2024</year>;<volume>70</volume>(<issue>1</issue>):<fpage>735</fpage>&#x2013;<lpage>46</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tce.2024.3376930</pub-id>.</mixed-citation></ref>
<ref id="ref-24"><label>[24]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Lin</surname> <given-names>H</given-names></string-name>, <string-name><surname>Yang</surname> <given-names>L</given-names></string-name>, <string-name><surname>Guo</surname> <given-names>H</given-names></string-name>, <string-name><surname>Cao</surname> <given-names>J</given-names></string-name></person-group>. <article-title>Decentralized task offloading in edge computing: an offline-to-online reinforcement learning approach</article-title>. <source>IEEE Trans Comput</source>. <year>2024</year>;<volume>73</volume>(<issue>6</issue>):<fpage>1603</fpage>&#x2013;<lpage>15</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tc.2024.3377912</pub-id>.</mixed-citation></ref>
<ref id="ref-25"><label>[25]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Liu</surname> <given-names>Q</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>H</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>X</given-names></string-name>, <string-name><surname>Yuan</surname> <given-names>D</given-names></string-name></person-group>. <article-title>Improved DDPG based two-timescale multi-dimensional resource allocation for multi-access edge computing networks</article-title>. <source>IEEE Trans Veh Technol</source>. <year>2024</year>;<volume>73</volume>(<issue>6</issue>):<fpage>9153</fpage>&#x2013;<lpage>8</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tvt.2024.3360943</pub-id>.</mixed-citation></ref>
<ref id="ref-26"><label>[26]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Liu</surname> <given-names>P</given-names></string-name>, <string-name><surname>An</surname> <given-names>K</given-names></string-name>, <string-name><surname>Lei</surname> <given-names>J</given-names></string-name>, <string-name><surname>Sun</surname> <given-names>Y</given-names></string-name>, <string-name><surname>Liu</surname> <given-names>W</given-names></string-name>, <string-name><surname>Chatzinotas</surname> <given-names>S</given-names></string-name></person-group>. <article-title>Computation rate maximization for SCMA-aided edge computing in IoT networks: a multi-agent reinforcement learning approach</article-title>. <source>IEEE Trans Wirel Commun</source>. <year>2024</year>;<volume>23</volume>(<issue>8</issue>):<fpage>10414</fpage>&#x2013;<lpage>29</lpage>. doi:<pub-id pub-id-type="doi">10.1109/twc.2024.3371791</pub-id>.</mixed-citation></ref>
<ref id="ref-27"><label>[27]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Neto</surname> <given-names>JLD</given-names></string-name>, <string-name><surname>Yu</surname> <given-names>SY</given-names></string-name>, <string-name><surname>Macedo</surname> <given-names>DF</given-names></string-name>, <string-name><surname>Nogueira</surname> <given-names>JMS</given-names></string-name>, <string-name><surname>Langar</surname> <given-names>R</given-names></string-name>, <string-name><surname>Secci</surname> <given-names>S</given-names></string-name></person-group>. <article-title>ULOOF: a user level online offloading framework for mobile edge computing</article-title>. <source>IEEE Trans Mob Comput</source>. <year>2018</year>;<volume>17</volume>(<issue>11</issue>):<fpage>2660</fpage>&#x2013;<lpage>74</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tmc.2018.2815015</pub-id>.</mixed-citation></ref>
<ref id="ref-28"><label>[28]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Han</surname> <given-names>C</given-names></string-name>, <string-name><surname>Yao</surname> <given-names>H</given-names></string-name>, <string-name><surname>Mai</surname> <given-names>T</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>N</given-names></string-name>, <string-name><surname>Guizani</surname> <given-names>M</given-names></string-name></person-group>. <article-title>QMIX aided routing in social-based delay-tolerant networks</article-title>. <source>IEEE Trans Veh Technol</source>. <year>2021</year>;<volume>71</volume>(<issue>2</issue>):<fpage>1952</fpage>&#x2013;<lpage>63</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tvt.2021.3133449</pub-id>.</mixed-citation></ref>
<ref id="ref-29"><label>[29]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Peng</surname> <given-names>B</given-names></string-name>, <string-name><surname>Rashid</surname> <given-names>T</given-names></string-name>, <string-name><surname>Schroeder de Witt</surname> <given-names>C</given-names></string-name>, <string-name><surname>Kamienny</surname> <given-names>PA</given-names></string-name>, <string-name><surname>Torr</surname> <given-names>P</given-names></string-name>, <string-name><surname>Boehmer</surname> <given-names>W</given-names></string-name>, <etal>et al</etal></person-group>. <article-title>FACMAC: factored multi-agent centralised policy gradients</article-title>. <source>Adv Neural Inf Process Syst</source>. <year>2021</year>;<volume>34</volume>:<fpage>12208</fpage>&#x2013;<lpage>21</lpage>.</mixed-citation></ref>
<ref id="ref-30"><label>[30]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Yu</surname> <given-names>C</given-names></string-name>, <string-name><surname>Velu</surname> <given-names>A</given-names></string-name>, <string-name><surname>Vinitsky</surname> <given-names>E</given-names></string-name>, <string-name><surname>Gao</surname> <given-names>J</given-names></string-name>, <string-name><surname>Wang</surname> <given-names>Y</given-names></string-name>, <string-name><surname>Bayen</surname> <given-names>A</given-names></string-name>, <etal>et al</etal></person-group>. <article-title>The surprising effectiveness of PPO in cooperative multi-agent games</article-title>. <source>Adv Neural Inf Process Syst</source>. <year>2022</year>;<volume>35</volume>:<fpage>24611</fpage>&#x2013;<lpage>24</lpage>.</mixed-citation></ref>
<ref id="ref-31"><label>[31]</label><mixed-citation publication-type="journal"><person-group person-group-type="author"><string-name><surname>Lin</surname> <given-names>H</given-names></string-name>, <string-name><surname>Xiao</surname> <given-names>B</given-names></string-name>, <string-name><surname>Zhou</surname> <given-names>X</given-names></string-name>, <string-name><surname>Zhang</surname> <given-names>Y</given-names></string-name>, <string-name><surname>Liu</surname> <given-names>X</given-names></string-name></person-group>. <article-title>A multi-tier offloading optimization strategy for consumer electronics in vehicular edge computing</article-title>. <source>IEEE Trans Consum Electron</source>. <year>2025</year>;<volume>71</volume>(<issue>1</issue>):<fpage>2118</fpage>&#x2013;<lpage>30</lpage>. doi:<pub-id pub-id-type="doi">10.1109/tce.2025.3527043</pub-id>.</mixed-citation></ref>
</ref-list>
</back></article>