【源码】移动边缘计算卸载机制MECOffloadingPython（Matlab）仿真 之前看了⼀个移动边缘计算的三级卸载⽅案，然后打算做⼀个仿真，论⽂名如下
《Energy-efficient Offloading for Mobile Edge Computing in 5G Heterogeneous Networks》
由于⽂中涉及的变量和公式过多，导致仿真异常难做
这⾥整理出⼏个问题和⼤家⼀起讨论
已经做好的代码见下⽂，历时10天（中间有⼤⼤⼩⼩的事情）
由于本⽂的变量较多，⽽且⽬前在度娘和github也搜不到数据集
所以，所有的数据都是我假设出来的，通过随机函数给出遥控直升机制作
本⽂出现的疑问将会持续更新。
1、任务是原⼦级的，不可进⼀步划分
2、MEC服务器允许多个计算任务同时进⾏
3、回传的功耗是忽略的，因为回传是与其他基础设施共享的
4、SBS到底经不经过MBS，⽂中说的不经过（⽤的or），但是要回传⼲什么
6、设备所需的总信道数应该⼩于MBS和SBS共有的信道数
7、选择了SBS就不能选其他的，选择本地和MBS和local也是同理
8、⼀个迭代阶段，⼀个任务只能选择⼀个信道传输⾄MBS
9.每个MBS信道的发射功率相同，不同的信道不同的只能是信道增益
伪代码
#include<stdio.h>
#inlcude<math.h>
int main()
{
#定义⼤结构体MBS
int mbs[50];
int sbs[50];
int Pr=4//MEC服务器的计算能⼒是4GHZ/s
double Pl[i]=random（0.1，1）//⽤户的计算能⼒是0.1-1
int Rr=1//MEC服务器的能耗是1W/GHZ
float Fai=0.0001//回传时延系数fa=0.0001秒/KB
int d[50]=random(300,800)
float c[50]=random(0.1,1)
float dead[50]=random(0.5,1)
int el[i];
#下⾯是假设的系数#
pm、gm//⼤的信道增益和传输功率未知-------------------思考⼀个问题：上的每个信道是否不同
ps、gs//⼩的信道增益和传输功率未知
rou=-100//背景噪声功率dBm
I//彼此信道⼲扰
#临时筛选⽤的数组#
GR[50]
GL[50]
GO[50]
/*class mbs:
def __init__(self):
self.rate = 0 # 传输速率
self.than = 0 # 信噪⽐
self.time = 0 # 时间
*/
int Pr=1 #（fr）MEC的计算能⼒，是⼀个常数
mb = pm*gm/(I+rou*rou)#信噪⽐
mr = w*log(2,1+mt)#速率
mt = d[i]/mr+c[i]/Pr#传输时间
####同理可得####
sb
sr
st=d[i]/sr+c[i]/Pr+d[i]*Fai
>###第⼀级卸载机制>###>###第⼀级卸载机制>###for（i=0,j=0,k=0,l=0;i<=49;i++）{
tl[i]=c[i]/Pl
数字电视伴侣if(tl>dead[i])
GR[j++]=i;
else if(tl<=dead[i])
{
int nm=di/((dead[i]-ci/pl[i])*(wlong2,(1+pm*gm/(rou*rou))))
int ns=di/((dead[i]-ci/pl[i]-d[i]*Fai)*(wlong2,(1+ps*gs/(rou*rou))))
int min=minimize(pm*nm,ps*ns)//缺少的数据:pm[i];gm[i];ps[i];gs[i];el[i]
if(e[i]<min)
Gl[k++]=i;
}比例电磁铁
else
{GO[l++]=i;
}
>###第⼆级卸载机制>###int m；##系数m未知，⼤⼩需要假设出来
int G0[25];
int Ai,hm,hs
#每个任务计算mb sb
for(i=0;i<50;i++)
{
for(k=0;k<50;k++){
if(mb>=m)内孔撑圆涨紧夹具
hm++;
if(sb>=m)
hs++;
}
}
#每个任务计算h
gff全贴合技术for(i=0;i<50;i++){
if(hm>=hs)
{int h[i]=hm;
p[j]=h[i];
j=i;}
else
{h[i]=hs;
p[j]=h[i];
j=i;
}
}
for(i=0;i<=50;i++)
{
en=el[i]-c[i]*Rr
p[i]=t1*(dead[i]/sum(dead[i]))+t2*(h[i]/sum(h[i]))+t3*(sum(en)/en)
}
#排序p[i]
#
#WARNING：想要进⾏下⼀步动作，还得让每⼀个i对应相应的设备i（⽤⼀步结构体）
#⽽且GR有最⾼的优先级，先选择信道，剩下的信道再留给GO进⾏选择
#
>###第三级卸载机制>###for（i=0;i<50;i++）
{
if((pm/mr>=ps/sr)&&(e[i]<el))#还是先把ps pr规定好了
}
真正的代码如下：⽬前已做出来第⼀级卸载机制
当然⽬前也遇到了不少问题
问题：
1、回传机制是啥样的，为什么⼩传⼤没有能耗
2、ps gs pm gm⼤⼩传输的信道增益和信道功率未知
3、卸载机制⼆中，总传输速度是怎么算的
4、信道分配问题，为什么⼆三级卸载机制只处理待处理集，那些在第⼀级已经确定的设备优先选择信道吗？（并⾏问题）
5、第三级卸载机制中，为什么p最⼩的先选信道
# -*- coding: utf-8 -*-
"""
Created on Sun Dec 22 11:28:38 2019
@author: han
"""
import numpy as np
import matplotlib.pyplot as plt
from math import log
import operator
###正常情况⽆卸载机制###
el=np.random.randint(1,10,100)#⼀个cpu周期的本地的能耗
y=[]
cl=np.random.randint(1,10,100)#计算此任务所需的能⼒，能cpu周期规划
d =np.random.randint(300,800,100)#每个计算任务的⼤⼩
x = np.linspace(10,100,10,dtype=int)#x个移动设备
print(x)
for i in x:
print(i)
sum=0
for j in range(i):
sum=sum+(2*cl[j]*el[j])/100
# print(sum)
y.append(sum);
print(y)
plt.plot(x,y,color='blue',linestyle='-')
plt.title('Handsome Programmers picture')
###第⼀级卸载机制如下###
pl=np.random.randint(1,10,100)
tl=[]#本地计算任务消耗时间
GR=[]#传给MEC服务器的设备集合
GL=[]#本地计算任务的集合
GO=[]#继续筛选的集合
le=[]#单个任务本地消耗的能耗
ns=[]#在⼩计算的设备数⽬
nm=[]#在⼤计算的设备数⽬
L=[]
def findMin(alist):
findMin = alist[0];
for i in range(1,len(alist)):
if alist[i]< findMin:
findMin = alist[i]
return findMin
tl =(cl*10.0)//pl>>#### deadline和tmax的精度不对dead=np.random.randint(5,10,100)
print(x)
for k in x:
if k==100:
break;
if tl[k]> dead[k]:
if tl[k]> dead[k]:
print('success')
GR.append(k)
elif tl[k]<=dead[k]:
le = cl*el
print('wonderful')
ns=d/((dead-cl/4)*log((1+40),2))#【【⼤和⼩的传输功率未知这⾥统⼀成20W】】
nm=d/((dead-cl/4)*log((1+80),2))#【【⼤和⼩的传输功率未知这⾥统⼀成20W】】
L=[ns[k],nm[k]]
p=findMin(L)
if el[k]<p:
GL.append(k)
print('1')
else:
GO.append(k)
print('2')
print('next is the answer of first jih')
print(GR)
print(GL)
print(GO)
##第⼆级卸载机制##
##第三级卸载机制##
最后的结果，做出前两级机制，并没有考虑第三级信道的分配
⼤体图已经画出
由于信道不好量化就省略了第⼆级和第三级卸载机制
⽬前拟理解是分配信道的量化是通过速度来衡量，不同的信道速度不同# -*- coding: utf-8 -*-
"""
Created on Sun Dec 22 11:28:38 2019
@author: han
"""
import numpy as np
import matplotlib.pyplot as plt
from math import log
###正常情况⽆卸载机制###
el=np.random.randint(1,10,100)#⼀个cpu周期的本地的能耗
y=[]
cl=np.random.randint(1,10,100)#计算此任务所需的能⼒，能cpu周期规划
d =np.random.randint(300,800,100)#每个计算任务的⼤⼩
x = np.linspace(10,100,10,dtype=int)#x个移动设备
print(x)
for i in x:
print(i)
sum=0
for j in range(i):
sum=sum+(2*cl[j]*el[j])/100#加了个2调整系数
# print(sum)
y.append(sum);
print(y)
plt.plot(x,y,color='blue',linestyle='-')
plt.title('Handsome Programmers picture')
>>#第⼀级卸载机制如下>>>pl=np.random.randint(1,10,100)#扩⼤了10倍，使⽤的时候请注意，本地功率
tl=[]#本地计算任务消耗时间
GR=[]#传给MEC服务器的设备集合
GL=[]#本地计算任务的集合
GO=[]#继续筛选的集合
le=[]#单个任务本地消耗的能耗
ns=[]#在⼩计算的设备数⽬
nm=[]#在⼤计算的设备数⽬
L=[]
p={}
def findMin(alist):
findMin = alist[0];
for i in range(1,len(alist)):
if alist[i]< findMin:
findMin = alist[i]
return findMin
tl =(cl*10.0)//pl# deadline和tmax的精度不对，已修正
dead=np.random.randint(5,10,100)
print(x)
for i in range(0,99):
print('this i is=====',i)
if tl[i]> dead[i]:
print('success')
GR.append(i)
elif tl[i]<=dead[i]:
运维流程管理le = cl*el
print('wonderful')
ns=d/((dead-cl/4)*log((1+40*20/100),2))#{论⽂⾥的公式}【【⼤和⼩的传输功率未知这⾥统⼀成20W】】？？背景噪声功率 nm=d/((dead-cl/4)*log((1+80*20/100),2))#{论⽂⾥的公式}【【⼤和⼩的传输功率未知这⾥统⼀成20W】】？？背景噪声功率 L=[40*ns[i],80*nm[i]]#warni
ng!40和80的单位，⽽且忘记乘10000
c=findMin(L)
p[i]=c/100#调整系数
if el[i]<p[i]:
GL.append(i)
print('GL!')
elif el[i]>=p[i]:
GO.append(i)
print('2')
print('next is the answer of first Offloading')
豫公网安备41160202000603
站长QQ:729038198
关于我们
投诉建议