Dependent Task Scheduling and Offloading for Minimizing Deadline Violation Ratio in Mobile Edge Comp

Dependent Task Scheduling and Offloading for Minimizing Deadline Violation Ratio in Mobile Edge Computing Networks

• 背景：移动边缘计算（MEC）系统可以为移动设备（MD）提供计算卸载服务，以处理具有任务依赖性要求的计算密集型应用，如增强现实（AR）、图像处理和人脸识别等。
• 解决的问题：传统的计算卸载方案只考虑了单个应用或单个时隙的情况，没有充分利用多任务间的依赖性和相似性，也没有考虑到在线应用到达和系统可靠性的影响。
• 方法：提出了一种基于任务迁移和合并的截止期违反率（DVR）最小化计算卸载方案（DVRMO-MM），该方案利用有向无环图（DAG）模型描述任务依赖性，并采用深度确定性策略梯度（DDPG）算法学习最优的卸载策略。
• 贡献：DVRMO-MM方案可以有效地构建整体任务DAG，确定最优的任务执行顺序，并自适应地调整卸载策略，从而在多时隙MEC系统中显著降低系统DVR，并提高资源利用率和服务效率。

I、介绍

新兴的计算和通信服务爆炸式增长，推动了新的移动应用程序（AR、VR）的出现。

而计算资源有限的移动设备（MD）难以在本地完成这些应用，随之出现了移动边缘计算（MEC）系统。MEC服务器因其地理位置更靠近移动设备（MD），能克服传输延迟长、通信开销高的缺点，高效提供计算卸载服务。

在现实场景中，很多移动应用（如增强现实AR、图像处理和人脸识别等）都是延迟比较敏感和计算密集型的任务，而且应用内的各个任务之间具有相互依赖关系，这就需要按照他们的逻辑顺序来处理。

关于任务依赖的移动应用任务卸载，大多的工作是优化方向是缩短延迟，节约能源，以及实现延迟和能源消耗之间的权衡。

本文呢，主要解决下面这三个open issues：

• 当应用程序到达新的时隙，而以前的应用程序尚未完全完成且尚未到达其截止日期时，如何迁移和调度未完成的相关任务？
• 当每个时间段有很多应用到达时，如何在不改变每个应用的任务依赖关系的情况下，去除重复并合并同类型的应用？

  在同一时隙中，可能会有相同类型的应用，有着相似的需求。这些应用中的任务就会出现重叠的

• 如何在多核之间调度和卸载依赖任务，以最大限度地减少系统逾期率DVR，同时满足各种任务依赖要求？

  现有的工作都是关注传统的像延迟、能耗的服务需求，他们的目标也是增强个人的QoE。但由于实际应用的类型、依赖性和延迟约束的多样性，这些仅考虑个体需求的解决方案可能会大大降低系统的可靠性。（如果只考虑满足个别应用程序的需求，可能会忽视其他应用程序的需求，从而影响整个系统的稳定性和可靠性）最后会丢弃一些应用为了提高已完成应用的QoE，这也会导致较高的逾期率。

贡献：
提出了一种具有任务迁移M和合并M功能的最小化DVR的计算卸载O方案（DVRMO-MM）

• 给定每个时隙达到的应用数量，将DVR最小化问题等价转换为在给定时间内的最大化完成任务的数量。
• 建立任务迁移与合并的模型，对一个时隙的任务构建总体的DAG。迁移，迁移上个时隙中有效但未完成的任务到当前时隙执行。合并，合并同一个时隙中相同类型的应用。
• 一个基于迁移的多优先级任务排序算法（MMPTS），引入了多个任务优先级指标。
• 基于MMPTS，问题转化为确定最佳执行顺序后的延迟最小化问题。为了处理不同类型应用程序的随机到达，提出了一种基于DDPG的任务卸载算法。同时，为了避免偏离任务依赖关系，在DDPG算法中设计了执行单元选择模块。
• 系统DVR显著降低了60.34%∼70.3%。

II、相关工作

现有的工作可以分为三类：

1. 最小化总的应用完成时间
2. 最小化能量消耗
3. 最小化能耗和执行时间的加权和

这三类现有的工作都是考虑到前面的那3个open issues，得到的解也是不贴近现实的次优解。

III、系统模型和问题表述

A.系统模型

系统由一个拥有丰富计算资源的多核AP 和 多个移动用户组成。

AP：有$\rho$个核心处理器，可以$\rho$个任务并行计算
MDs： M = { 1 , … , m , M } \mathcal{M}=\{1,\ldots,m,M\} M={1,…,m,M}。产生计算密集型的且具有依赖关系的任务（AR、图像处理、人脸识别服务）。由于AP的计算能力更为强大，MDs会把他们的具有依赖关系的任务卸载到AP。

1）多时隙系统模型

考虑的是在线的场景，只能知道当前时隙的到达的任务，
。总的时间范围是$\mathcal{T}$，等分为 $X$份,每份的时长是$t_{def}$时隙的集合表示为 T = { t x , x = 1 , 2 , … , X } \mathcal{T}=\{t_x,x=1,2,\ldots,X\} T={tx​,x=1,2,…,X}，$t_x=x{t}_{def}$。每个时隙，用户$m$会请求$K$种应用，用$m_k$来表示用户$m$请求的类型为$k$的应用。

2)DAG表示的任务依赖模型

以图像的处理过程为例。它通常由一些相互依赖的任务组成，如图像预处理、特征提取、特征编码、数据分类。这些任务应该严格的按照这样的逻辑顺序执行。

对于$m_k$这样的一个应用，其DAG表示为$G_{m,k}^x=({\mathcal{N}}_{m,k}^x,{\mathcal{E}}_{m,k}^x)$.
点集： N m , k x = { τ 1 , … , τ n , … , τ N } \mathcal{N}_{m,k}^{x}=\{\tau_{1},\ldots,\tau_{n},\ldots,\tau_{N}\} Nm,kx​={τ1​,…,τn​,…,τN​}表示这应用中的任务，$L_n$表示任务${\tau }_n$的计算量；
边集：$({\tau }_{n-1},{\tau }_n)\in {\mathcal{E}}_{m,k}^x$，即任务${\tau }_n$依赖${\tau }_{n-1}$产生的结果。

对于一些复杂点的应用，可能有多个出口任务，要这些全部的出口任务都完成那么该应用才完成，所以会给应用加一个虚拟的入口和出口节点。

截止时间：$D_n$表示任务${\tau }_n$也是整个应用的$m_k$的截止时间

CPU周期：$C_n$ 定义为处理一位任务${\tau }_n$所需的中央处理单元 (CPU) 周期数。

3）部分任务卸载模型

对于一个依赖任务，他的不同在于具有外部的依赖关系。但是，这个任务本身的计算量通常是按位独立的，就像一个独立的任务。

现有的文献表明，部分卸载相比二元卸载更加的灵活，并且能获得更好的服务性能，所以这篇文章采用的是部分卸载。

用${\alpha }_n\in [0,1]$表示卸载变量。${\alpha }_n{L}_n$是本地处理的部分，$(1-{\alpha }_n)L_n$表示卸载到AP的部分。

结果数据，每个任务产生的数据一般都很小，所以就把他任务是一个常量$\vartheta$

B.任务迁移与合并模型

1）第一阶段 任务迁移

在考虑延时约束的情况下，从上一个时隙迁移未完成的有效任务 到 当前的时隙继续执行。这样不丢弃的原则可以极大的减小DVR

2）第二阶段 任务去重与合并

在一步在当前时隙完成，他会考虑上一个时隙迁移过来的任务和当前任务种类的相似性。

比如，现在有俩个用户，$m$和$m^{\prime }$。他们都产生了3个应用，种类分别是A、B、C。但是由于个人的需求不一样，在相同的应用中，会有重叠的任务和不一样的任务。会对这些重叠的任务进行合并，${\mathcal{G}}_{\text{merge}}^{x,k}={\bigcup }_{t_x,k,\forall m}{G}_{m,k}^x.$ 即对时隙x产生的相同应用进行合并。

3）第三阶段 整体任务DAG建模

对上一阶段未完成的和新到达的任务进行整理：
$$\begin{array}{rl}{\mathcal{G}}_{\mathrm{total}}^x& ={\mathcal{G}}_{\mathrm{uncom}}^{x-1}+\underset{t_x,\forall k}{\cup }{\mathcal{G}}_{\mathrm{merge}}^{x,k}\\ & ={\mathcal{G}}_{\mathrm{uncom}}^{x-1}+\underset{t_x,\forall k,\forall m}{\cup }{G}_{m,k}^x\end{array}$$

注意不会对上一个时间未完成的应用进行合并
因为它们可能侧重于不同的时间和空间方面的结果。如果进行去重或合并，可能会损失某些应用程序所需的特定信息。

下面是一些定义：

1. 执行顺序：在一个时隙的整体任务中，对于所有的任务进行优先级排序，形成一个执行序列${\mathcal{O}}_x$.怎么形成的，在后面会讲。然后对于每个任务，可以求出他的前序任务，$preo({\mathcal{O}}_x[{\tau }_n])$.
2. 等待时间：即一个任务最早收到全部他所需要的输入数据的时刻，将要开始执行计算的时刻。用$W_{m,n}^{loc}$和$W_{i,n}^{AP}$,i是AP的某一个计算核心
3. 完成时间：$F_n$表示任务${\tau }_n$的所有工作量在延迟时间内算完成的时间

C.本地计算模型

1、本地计算时间：$t_{m,n}^{\mathrm{loc}}=\frac{{\alpha }_n{C}_n{L}_n}{f_m}.$

$f_m$是本地设备的平均频率

2.1、还有一部分是在AP执行的，需要把n-1任务结果数据传到执行n任务的本地设备m上：
下行速度：$R_{Am}^{\mathrm{down}}=B{\log }_2(1+\frac{p_{\mathrm{AP}}{h}_{Am}}{{\sigma }^2})$

传输时间：$t_{m,n-1}^{\mathrm{down}}=\frac{\vartheta }{R_{Am}^{\mathrm{down}}}$

2.2、还可能前面任务的本地执行部分会在设备$m^{\prime }$上，传输速度和传输时间分别是：
速度：$R_{m^{\prime }m}=B{\log }_2(1+\frac{p_{m^{\prime }}{g}_{m^{\prime }m}}{{\sigma }^2})$
时间：$t_{m,n-1}^{m^{\prime }}=\frac{\vartheta }{R_{m^{\prime }m}}$

至此我们可以到得，任务${\tau }_n$的等待时间：
$$W_{m,n}^{\mathrm{loc}}=\max \left\{F_{n-1},\underset{{\tau }_{n^{\prime }}\in \mathrm{preo}({\mathcal{O}}_x[{\tau }_n])}{\max }{\eta }_{m,n^{\prime }}\left(W_{m,n^{\prime }}^{\mathrm{loc}}+t_{m,n^{\prime }}^{\mathrm{loc}}\right)\right\}+g(m,{\tau }_n)$$

什么时候可以开始算：
即 获得计算资源时间 与 获得数据资源时间 的最晚时间
1、需要我前面依赖的任务算完即$F_{n-1}$.
2、设备需要完成所有已分配的任务，需要把分配在设备m上的且在任务n前面的任务都执行完，即获得CPU资源的时间。
3、算完之后还要把结果都发来，即$F_{n-1}+g(m,{\tau }_n)$

为什么不把发送的时间加在 $F_{n-1}$后面，可能是它只能算或者只能发，不能边算边发。

为什么内部的max不直接是$F_{n^{\prime }}$,而是$W$ + $t^{loc}$，因为$F_n$是AP和本地算完的最晚时间，这里只是想知道本地计算资源的释放时间。

D.计算卸载和边缘计算模型

• 卸载速率：$R_{mA}^{\mathrm{up}}=B{\log }_2(1+\frac{p_m{h}_{mA}}{{\sigma }^2})$
• 卸载时间：$t_{m,n}^{\mathrm{off}}=\frac{(1-{\alpha }_n)L_n}{R_{mA}^{\mathrm{up}}}$
• 结果数据发送时间：$t_{m,n-1}^{\mathrm{up}}=\frac{\vartheta }{R_{mA}^{\mathrm{up}}}$
• AP端执行时间：$t_{i,n}^{\mathrm{AP}}=\frac{(1-{\alpha }_n)C_n{L}_n}{f_{\mathrm{AP}}^i}$
• AP的等待时间：$$W_{i,n}^{\mathrm{AP}}=\max \left\{F_{n-1},\underset{{\tau }_{n^{\prime }}\in \mathrm{preo}({\mathcal{O}}_x[{\tau }_n])}{\max }{\gamma }_{i,n^{\prime }}\left(W_{i,n^{\prime }}^{\mathrm{AP}}+t_{i,n^{\prime }}^{\mathrm{AP}}\right)\right\}+t_{m,n-1}^{\mathrm{up}}+t_{m,n}^{\mathrm{off}},\forall m\in \mathcal{M},$$

E.问题表述

目标是最小化在给定时间范围 T 的延迟限制内未完全完成的应用程序的数量 = 最大化满足长度为 $t_{def}$ 的给定 X 时隙的延迟约束的已完成应用程序的数量。
此处给出完成时间$F_n$的表述： F n = max ⁡ { W m , n l o c + t m , n l o c , W i , n A P + t i , n A P } F_n=\max\{W_{m,n}^\mathrm{loc}+t_{m,n}^\mathrm{loc},W_{i,n}^\mathrm{AP}+t_{i,n}^\mathrm{AP}\} Fn​=max{Wm,nloc​+tm,nloc​,Wi,nAP​+ti,nAP​}
所以，应用$m_k$的完成时间就是 max ⁡ { F n , ∀ τ n ∈ G m , k x } \max\{F_{n},\forall\tau_{n}\in G_{m,k}^{x}\} max{Fn​,∀τn​∈Gm,kx​}
一个应用完成的指标就是：
$${\mathcal{F}}_{m,k}^{x^{\prime }}={\delta }_{m,k}^{x^{\prime }}\cdot \prod _{\forall {\tau }_n\in G_{m,k}^x}{\mu }_n^{x^{\prime }}$$

$\mu$表示任务n在时隙x’已完成，即$F_n\le x^{\prime }\cdot t_{def}$
辅助变量$\delta$一开始等于1，直到所有的$\mu =1$后，$\delta$等于0，也就是说只会存在一个时隙，${\mathcal{F}}_{m,k}^{x^{\prime }}$等于1

所以，在某一时刻应用的完成个数是：$${\hat{\mathcal{F}}}^{x^{\prime }}=\sum _{m=1}^M\sum _{k=1}^K{\mathcal{F}}_{m,k}^{x^{\prime }}$$

得到问题表述：

下面就是用基于迁移的多优先级任务排序(MMPTS) 算法，得到最大化完成数量的执行顺序${\mathcal{O}}_x^{\ast }$，再用得到的顺序使用基于DDGP的任务卸载算法去解决计算卸载问题，然后获得执行${\mathcal{O}}_x^{\ast }$中每个任务最小时间的卸载方案。