计算/任务卸载任务系统模型中能耗和时延计算公式系统讲解

code
import argparse


def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--num-ue', type=int, default=5)
    parser.add_argument('--F', type=int, default=5)
    args = parser.parse_args()
    return args


import numpy as np


class Enviroment():
    def __init__(self, W, num_ue, F, bn, dn, dist, f, pn, pi, it=0.5, ie=0.5):
        self.W, self.num_ue, self.F = W, num_ue, F
        self.bn, self.dn, self.dist = bn, dn, dist
        self.f, self.it, self.ie = f, it, ie
        self.pn, self.pi = pn, pi

        # W = 10  # MHz 带宽
        # F = args.F  # Ghz/sec MEC 计算能力
        # f = 1  # Ghz/sec 本地 计算能力
        # num_ue = args.num_ue  # ue的个数
        #
        # dist = np.random.random(size=num_ue) * 200  # 每个ue的距离基站
        # bn = np.random.uniform(300, 500, size=num_ue)  # 输入量 kbits
        # dn = np.random.uniform(900, 1100, size=num_ue)  # 需要周期量 兆周期数 1Mhz = 1000khz = 1000 * 1000hz
        # #     tao = np.random.
        # it, ie = 0.5, 0.5  # 权重
        # pn, pi = 500, 100  # 传输功率， 闲置功率 mW

    def get_Init_state(self):  # 随机初始化, 返回 tc, ac, ra, rf 消耗，剩余F，此时的ra, rf
        # 1.0
        ra = np.random.randint(2, size=num_ue)
        rf = np.zeros(ra.size)
        for i in range(ra.size):
            if ra[i] == 1.0:
                rf[i] = self.F / sum(ra)
        tc = 0
        for i in range(ra.size):
            if ra[i] == 0.:
                tc += self.it * self.dn[i] / (self.f * 1000)
                tc += self.ie * self.dn[i] * 1000 * 1000 * pow(10, -27) * pow(self.f * 1000 * 1000 * 1000, 2)
            else:
                '''
                W/K log(1+(PH)/(W/K N0))
                W 带宽 Hz
                P W
                WiFi 无线网卡的发射功率通常为 0.036W ，或者说36mW 。
                '''
                tmp_rn = 1000 * 1000 * self.W / sum(ra)
                # dBm=10*lg(mW) mW=pow(10, dBm/10)
                # WiFi 无线网卡的发射功率通常为 0.036W,或者说36mW。
                mw = pow(10, -174 / 10) * 0.001 # 噪声功率转化 -174dbm 转成瓦特
                rn = tmp_rn * np.log10(1 + self.pn * 0.001 * pow(self.dist[i], -3) / (tmp_rn * mw))
                tc += self.it * self.bn[i] * 1024 / rn + self.ie * self.pn * 0.001 * self.bn[i] * 1024 / rn
                tc += self.it * self.dn[i] / (rf[i] * 1000) + self.ie * self.dn[i] * 1000 * 1000 * self.pi * 0.001 / (
                        rf[i] * 1000 * 1000 * 1000)
        ac = 0