毕业设计项目——基于RISC-V的标签化跨层调度应用任务管理（论文/代码）

完整的论文代码见文章末尾 以下为核心内容

摘要

在现代操作系统中，高效的系统调度策略对于优化系统性能、提高资源利用率和保证系统稳定性至关重要。本文提出了一个基于Linux进程文件系统（procfs）的系统监控工具，旨在通过实时收集系统运行数据，为系统调度提供精确的决策依据。该监控工具利用Linux特有的/proc文件系统，实时监控CPU使用率、内存占用、网络流量等关键性能指标，支持多线程并行数据收集，以最小化监控过程对系统性能的影响。

本文详细探讨了系统监控工具与系统调度之间的互动机制。监控工具收集的数据反映了系统当前的状态和负载情况，这些信息对于调度器优化任务分配、调整资源分配策略以及处理系统瓶颈具有重要价值。特别是在面对复杂应用和高并发场景时，基于实时监控数据的动态调度策略能够显著提升系统的响应速度和处理能力。

系统设计

本文实现了Linux系统资源的全面监控系统。用于实时监测和展示主机的CPU使用率、内存占用、运行时间以及网络接口的流量信息。其基本原理涉及到操作系统级别的资源监控、多线程编程和网络编程。大致分为以下几个模块：

CPU使用率监控：通过读取/proc/stat文件，获取系统CPU的使用情况。该文件提供了自系统启动以来各项CPU时间的累积值，包括用户模式、系统模式和空闲时间等。计算两个时间点之间的差值，可得到CPU使用率。

内存占用监控：通过读取/proc/meminfo文件和使用sysinfo结构，获取系统的内存使用情况。该文件提供了系统的总内存、可用内存等信息，从而可以计算出内存占用率。

系统运行时间监控：利用sysinfo结构提供的uptime成员，计算出系统的运行时间。
网络接口信息获取：通过socket编程和ioctl系统调用，获取每个网络接口的基本信息，如名称、IP地址和MAC地址等。

网络流量监测：通过读取/proc/net/dev文件，获取网络接口的收发包数量。计算一定时间间隔内的收发包差值，从而得到网络接口的上行和下行速度。

项目通过创建多个线程分别进行系统资源监控和网络接口流量监控：

CPU、内存和运行时间监控线程(thread_core)：定期更新系统的CPU使用率、内存占用和运行时间信息。

网络流量监控线程(thread_net)：定期更新网络接口的流量信息，包括上行和下行速度。

系统资源监控

系统资源监控的原理主要涉及到CPU使用率、内存使用率和系统运行时间的获取和计算。本文的逻辑如下：

初始化和资源获取：使用open_sysinfo()函数初始化并获取系统的全局状态信息。

运行时间监控：通过get_host_runtime()函数获取系统的累计运行时间。

CPU使用率监控：使用get_cpuoccupy()函数获取两个时间点的CPU使用情况。利用

cal_occupy()函数计算得到CPU使用率。

内存使用率监控：调用get_mem_usage()函数计算系统的内存使用率。

通过这些函数的协同工作，项目能够实时监控和显示系统的CPU和内存使用情况，以及系统的累计运行时间。这些信息对于标签调度来说非常有用，可以帮助其他辅助程序了解系统的当前状态和性能瓶颈，及时作出调整。

网络接口流量监控

网络接口流量监控是通过收集网络接口上的数据包信息来实现的，主要关注网络流量的上行（发送）和下行（接收）速度。该过程涉及读取系统网络接口的状态，特别是/proc/net/dev文件，该文件提供了Linux系统中每个网络接口的统计数据，包括接收和发送的字节数等信息。本文通过以下流程执行整个过程：

初始化网络接口信息链表：get_interface_info(&p_interface, &nums)：首先调用此函数初始化网络接口信息，包括接口名称、IP地址和MAC地址等。这些信息被存储在一个NET_INTERFACE类型的链表中，每个节点代表一个网络接口。

开启网络信息监控线程：在main()函数中，使用pthread_create()创建一个线程，线程执行函数为thread_net（下文提到）。这个线程负责定期更新网络接口的流量信息。
在thread_net函数中，周期性地调用get_network_speed()函数。这个函数遍历p_interface链表中的每个网络接口，使用以下函数收集每个接口的流量信息：

首先，对每个接口调用get_rtx_bytes()函数获取初始的接收（rx）和发送（tx）字节总数。这些数据被存储在rtx0中。

再次调用get_rtx_bytes()函数获取等待一段时间后的接收和发送字节总数，存储在rtx1中。使用cal_netinterface_speed()函数计算两个时间点之间的网络流量速度，包括上行速度u_speed和下行速度d_speed，同时确定速度的单位（KB/s或MB/s），存储在speed_level中。最后，调用show_netinterfaces()函数显示每个网络接口的名称、IP地址、MAC地址和计算得到的上行及下行速度。

这个流程实现了对系统中所有网络接口的实时流量监控，通过周期性地计算每个接口在一定时间间隔内的流量变化，来监测网络活动和性能。这些信息对于网络管理和性能优化是非常有用的，可以帮助辅助程序及时发现网络瓶颈或异常流量模式，来进行任务调度。

部分代码如下：

int get_interface_info(NET_INTERFACE **net, int *n)
{
    int fd;
    int num = 0;
    struct ifreq buf[16];
    struct ifconf ifc;

    NET_INTERFACE *p_temp = NULL;
    (*net)->next = NULL;

    if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        close(fd);
        printf("socket open failed\n");
    }

    ifc.ifc_len = sizeof(buf);
    ifc.ifc_buf = (caddr_t)buf;

    if (!ioctl(fd, SIOCGIFCONF, (char *)&ifc)) {
        num = ifc.ifc_len / sizeof(struct ifreq);
        *n = num;
        while (num-- > 0) {
            strcpy((*net)->name, buf[num].ifr_name);
            if (!(ioctl(fd, SIOCGIFADDR, (char *)&buf[num]))) {

                memset((*net)->ip, 0, 16);
                strcpy((*net)->ip,
                inet_ntoa(((struct sockaddr_in *)(&buf[num].ifr_addr))->sin_addr));
            }
            if (!ioctl(fd, SIOCGIFHWADDR, (char *)(&buf[num]))) 
            {
                memset((*net)->mac, 0, 13);
                snprintf((*net)->mac, 13, "%02x%02x%02x%02x%02x%02x",
                         (unsigned char)buf[num].ifr_hwaddr.sa_data[0],
                         (unsigned char)buf[num].ifr_hwaddr.sa_data[1],
                         (unsigned char)buf[num].ifr_hwaddr.sa_data[2],
                         (unsigned char)buf[num].ifr_hwaddr.sa_data[3],
                         (unsigned char)buf[num].ifr_hwaddr.sa_data[4],
                         (unsigned char)buf[num].ifr_hwaddr.sa_data[5]);
            }
            if (num >= 1) {
                p_temp = (NET_INTERFACE *)malloc(sizeof(NET_INTERFACE));
                memset(p_temp, 0, sizeof(NET_INTERFACE));
                p_temp->next = *net;
                *net = p_temp;
            }
        }
        return 0;
    } else {
        return -1;
    }
}

多线程监控

本文通过多线程的方式同时进行网络流量监控和系统资源（CPU、内存、系统运行时间）监控。

网络信息监控线程：通过pthread_create创建一个线程thread_net_id，执行thread_net函数。这个线程无限循环地调用get_network_speed(p_interface)来更新网络接口的流量信息，然后通过show_netinterfaces(p_interface, 1)展示每个接口的流量信息（上传和下载速度）。

系统资源监控线程：同样通过pthread_create创建另一个线程thread_core_id，执行thread_core函数。这个线程也是无限循环，每隔一段时间（这里是10秒）更新和展示系统资源信息，包括系统运行时间、内存使用率和CPU使用率。

通过将网络监控和系统资源监控分配到两个独立的线程中，程序能够同时监控网络和系统资源，增加了监控的效率和实时性。充分利用了系统资源，为调度程序提供了一个实用的监控和诊断工具。

任务调度

本文实现的算法如下：
初始化：所有任务在创建时被标记为 IO 密集型或 CPU 密集型。系统维护两个队列，一个用于 IO 密集型任务，一个用于 CPU 密集型任务。系统定期（或根据需求）监控 CPU 和 IO 资源的使用情况。

任务分发：调度器检查 CPU 和 IO 的当前负载情况。如果 CPU 负载高，优先调度 IO 密集型任务；如果 IO 负载高，优先调度 CPU 密集型任务。如果相应资源的负载低，从相应队列中取出任务进行调度。

动态优先级调整：根据实时反馈调整任务的优先级，例如，如果某类型任务因资源不足而频繁等待，则提高该类型任务的优先级。设置优先级阈值来控制不同类型任务的调度比例，以优化整体性能。

资源监控与反馈：持续监控资源使用情况，如 CPU 和 IO 的负载。根据监控数据动态调整任务分发中的调度策略，确保资源利用最优化。

性能评估：定期评估任务执行的效率和响应时间，以检测并优化调度策略的有效性。调整任务标签分配策略或任务优先级算法以应对系统性能瓶颈。

部分代码如下：

enum ResourceType { CPU, IO };
struct Resource {
    ResourceType type;
    int amount;
};
class Task {
public:
    int task_id;
    std::string task_type;
    int priority;
    int duration;  // 任务持续时间（秒）
    std::map<ResourceType, int> resourceRequirements;
    Task(int id, std::string type, int pri, int dur) : task_id(id), task_type(type), priority(pri), duration(dur) {
        if (type == "cpu") {
            resourceRequirements[CPU] = 1;
        } else {
            resourceRequirements[IO] = 10;
        }
    }
    bool operator<(const Task& other) const {
        return priority < other.priority;
    }
};

class Scheduler {
private:
    std::priority_queue<Task> tasks;
    std::map<ResourceType, int> availableResources;
    std::mutex mtx;
    std::condition_variable cv;
    bool stop = false;
public:
    Scheduler() {
        availableResources[CPU] = 4;  // CPU核心数量
        availableResources[IO] = 100;  // IO带宽数量
    }
    ~Scheduler() {
        stop = true;
        cv.notify_all();
    }
    void addTask(const Task& task) {
        std::lock_guard<std::mutex> lock(mtx);
        tasks.push(task);
        cv.notify_one();
    }
    void run() {
        std::unique_lock<std::mutex> lock(mtx);
        while (!stop) {
            cv.wait(lock, [&]{ return !tasks.empty() || stop; });
            while (!tasks.empty()) {
                Task task = tasks.top();
                bool canDispatch = true;
                for (auto& req : task.resourceRequirements) {
                    if (availableResources[req.first] < req.second) {
                        canDispatch = false;
                        break;
                    }
                }
                if (canDispatch) {
                    tasks.pop();
                    lock.unlock();
                    dispatchTask(task);
                    lock.lock();
                } else {
                    break;
                }
            }
        }
    }
    void dispatchTask(Task& task) {
        std::cout << "Dispatching Task ID: " << task.task_id << " (" << task.task_type << ") with priority: " << task.priority << std::endl;
        for (auto& req : task.resourceRequirements) {
            availableResources[req.first] -= req.second;
        }
        std::this_thread::sleep_for(std::chrono::seconds(task.duration));
        for (auto& req : task.resourceRequirements) {
            availableResources[req.first] += req.second;
        }
        std::cout << "Task ID: " << task.task_id << " completed and resources released." << std::endl;
    }
};

系统评估

资源监控

使用Makefile脚本编译出可执行文件，之后打开一个游览器，观察系统运行结果，运行结果如下所示：

任务调度

本文模拟了几个虚拟的任务节点，可以看到调度器如何处理和执行不同任务的详细过程。
// 创建一些示例任务

scheduler.addTask(Task(1, "cpu", 5, 2));
scheduler.addTask(Task(2, "io", 3, 1));
scheduler.addTask(Task(3, "cpu", 1, 3));
scheduler.addTask(Task(4, "io", 4, 2));

获取方式

功能完备，具有40页完整论文及代码