利用python实现资源调度算法

资源调度算法分为最大载干比算法、轮询调度算法、比例公平算法、最大加权时延优先算法、公平吞吐量算法这五种算法。

最大载干比算法： 

基站首先对每个用户的载干比预测值进行排序，之后信道条件最好的用户首先进行数据传输。

轮询调度算法：

轮询调度算法是研究资源分配公平性时作为衡量标准的算法，在此算法中，认为所有的用户都具有相同的优先级，系统按顺序循环调用不同的用户数据。

比例公平算法：

比例公平算法的思想是为小区中的每个用户都设置一个优先级，之后根据优先级为小区的用户分配资源，即优先级高的用户优先进行资源调度。

最大加权时延优先算法：

最大加权时延优先算法是一种基于优先级的调度算法，通常用于网络流量调度和任务调度中。在该算法中，每个任务或流量根据其加权时延被分配优先级。加权时延指的是任务的时延与权重的乘积。该算法的基本思想是优先调度那些加权时延较大的任务或流量，目的是尽可能减少这些任务的等待时间

公平吞吐量算法：

公平吞吐量算法的目的是在多个竞争的用户或任务之间公平地分配带宽或计算资源，以确保每个用户都能获得一定的吞吐量，并且不会被其他用户长时间排挤或忽略。

那么如何实现这些算法呢？本文就主要通过python编写实现最大载干比算法、轮询调度算法、最大加权时延优先算法：

最大载干比算法的核心代码：

定义一个用户类：

# 定义用户类
class User:
    def __init__(self, uid, ci):
        self.uid, self.ci = uid, ci  # 初始化用户ID和载干比（C/I）

最大载干比算法的核心思想：

# 最大载干比（Max C/I）算法实现
def max_ci(users):
    t = 0 #参数t用于后续时间格式的输出
    while users:
        u = max(users, key=lambda x: x.ci) #用于取出载干比最大的数
        print(f"用户{u.uid} 时间{t} 载干比{u.ci}")
        u.ci -= 1  #载干比减一，自定义
        if u.ci <= 0: users.remove(u)  #如果载干比小于或等于0，就移除
        t += 1

 定义一个进程类：

# 定义进程类
class Process:
    def __init__(self, pid, burst):
        self.pid, self.burst = pid, burst  # 初始化进程ID、执行时间

轮询调度RR算法核心思想：

# 轮询调度（RR）算法实现
def rr(procs, q):
    dq = deque(procs)
    t = 0
    while dq:
        p = dq.popleft()
        if p.burst <= q:
            t += p.burst
            print(f"进程{p.pid} 完成于{t}")
        else:
            t += q
            p.burst -= q
            print(f"进程{p.pid} 时间{t} 剩余{p.burst}")
            dq.append(p)

 定义一个任务类：

# 定义任务类
class Task:
    def __init__(self, task_id, delay, weight):
        self.task_id = task_id  # 任务ID
        self.delay = delay  # 任务时延
        self.weight = weight  # 任务权重
        self.weighted_delay = delay * weight  # 计算加权时延

    def update_weighted_delay(self):
        # 每次调度后可以更新加权时延
        self.delay -= 1
        self.weighted_delay = self.delay * self.weight

    def __repr__(self):
        return f"任务{self.task_id} | 时延: {self.delay} | 权重: {self.weight} | 加权时延: {self.weighted_delay}"

 最大加权时延优先算法核心思想：

# 最大加权时延优先算法实现
def M_LWDF(tasks):
    t = 0
    while tasks:
        task = max(tasks, key=lambda x: x.weighted_delay)  # 选择加权时延最大的任务
        print(f"时间{t}: 执行任务 {task.task_id}，加权时延 {task.weighted_delay}")

        task.update_weighted_delay()

        # 如果任务的时延小于等于0，移除该任务
        if task.delay <= 0:
            tasks.remove(task)

        t += 1

全部代码：

from collections import deque

# 定义进程类
class Process:
    def __init__(self, pid, burst):
        self.pid, self.burst = pid, burst  # 初始化进程ID、执行时间

# 定义用户类
class User:
    def __init__(self, uid, ci):
        self.uid, self.ci = uid, ci  # 初始化用户ID和载干比（C/I）

# 定义任务类
class Task:
    def __init__(self, task_id, delay, weight):
        self.task_id = task_id  # 任务ID
        self.delay = delay  # 任务时延
        self.weight = weight  # 任务权重
        self.weighted_delay = delay * weight  # 计算加权时延

    def update_weighted_delay(self):
        # 每次调度后可以更新加权时延
        self.delay -= 1
        self.weighted_delay = self.delay * self.weight

    def __repr__(self):
        return f"任务{self.task_id} | 时延: {self.delay} | 权重: {self.weight} | 加权时延: {self.weighted_delay}"

# 轮询调度（RR）算法实现
def rr(procs, q):
    dq = deque(procs)
    t = 0
    while dq:
        p = dq.popleft()
        if p.burst <= q:
            t += p.burst
            print(f"进程{p.pid} 完成于{t}")
        else:
            t += q
            p.burst -= q
            print(f"进程{p.pid} 时间{t} 剩余{p.burst}")
            dq.append(p)

# 最大载干比（Max C/I）算法实现
def max_ci(users):
    t = 0
    while users:
        u = max(users, key=lambda x: x.ci)
        print(f"用户{u.uid} 时间{t} 载干比{u.ci}")
        u.ci -= 1
        if u.ci <= 0: users.remove(u)
        t += 1

# 最大加权时延优先算法实现
def M_LWDF(tasks):
    t = 0
    while tasks:
        task = max(tasks, key=lambda x: x.weighted_delay)  # 选择加权时延最大的任务
        print(f"时间{t}: 执行任务 {task.task_id}，加权时延 {task.weighted_delay}")

        task.update_weighted_delay()

        # 如果任务的时延小于等于0，移除该任务
        if task.delay <= 0:
            tasks.remove(task)

        t += 1

if __name__ == "__main__":
    while True:
        print("请选择调度算法：")
        print("0.退出 1.轮询调度RR算法 2.最大载干比算法 3.最大加权时延优先算法")
        c = input("选择调度算法：")
        if c == "0":
            break
        elif c == "1":
            rr([Process(1, 10), Process(2, 5), Process(3, 8)], int(input("时间片：")))
        elif c == "2":
            max_ci([User(1, 5), User(2, 3), User(3, 7)])
        elif c == "3":
            M_LWDF([Task(1, 5, 2), Task(2, 3, 3), Task(3, 8, 1)])
        else:
            print("无效")

这是比较简单的python代码编写，小辈不才，只能做到这样了，仅供参考；