C++ 调度算法的实现

我有一个任务，我需要开发一个进程调度器的模拟。我已经完成了大部分的设置，但我一直在努力找出实际安排流程的逻辑。现在我创建了一个结构，它保存进程的pid、周期计数和内存需求。我使用了一个向量来保存所有的100个进程，这样我可以根据需要对它们进行排序，并在调度过程中删除进程

对于5个处理器，我刚刚创建了一个int数组，但我猜处理器应该有循环计数和内存限制？在这种情况下，可能会有另一个结构

我如何将进程分配给这5个处理器？有人能帮我弄清楚吗？我只需要实现一个简单的FCFS算法

void init_process_list(vector<process> &p_list) {

    generator generate; // Random number generator class
    process p;

    for(int i = 0; i < process_count; i++) {
        p.process_id = i;
        p.cpu_cycles = generate.rand_num_between(cycle_lbound, cycle_ubound);
        p.mem_footprint = generate.rand_num_between(mem_lbound, mem_ubound);
        p_list.push_back(p);
    }

}

// Initialize processor array
void init_processor_list(int *processor_list) {

    for(int i = 0; i < processor_count; i++)
        processor_list[i] = 0;

}

void schedule_processes(vector<process> &p_list, int *processor) {

}

int main() {

    vector<process> process_list;
    int cpu[processor_count];

    init_process_list(process_list);
    init_processor_list(cpu);

    schedule_processes(process_list, cpu);

}

void init\u进程列表（向量和p\u列表）{
生成器生成；//随机数生成器类
过程p；
for（int i=0；i

应在中进行说明。我读过（没有英文版本）关于进程调度算法的描述

检查您是否理解以下内容

#include <iostream>
#include <vector>
#include<thread>
#include <future>

int global_processorID =0;
int global_processID   =0;

struct Process
{
    int cycles;
    int memory;
    int pid;
    Process()
    {
        pid = global_processID++;
        cycles = rand()%1000;
        memory = rand()%100;
    }
};

class Processor
{
public:
    Processor():processing(false)
    {

        this->processorID = global_processorID++;
    }
    bool processsing()
    {
        return processing;
    }
    void process(Process& process)
    {
        processing= true;

        std::async(std::launch::async,[&]
        {
            std::cout<<"Processor ID: "<<this->processorID<<" ,started Processing for cycles"<<process.cycles<<" ,process id :"<<process.pid<<std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(process.cycles*10));
            std::cout<<"Done Processing: "<<process.pid<<std::endl;
            processing=false;
        });
    }
    int processorID;
private:
    bool processing; 
};
class scheduler
{
public:

    void addPrcessor(Processor& aprocessor)
    {
        processor.push_back(&aprocessor);
    }

    void prcess(Process& process)
    {
        getNextAvilableProcessor()->process(process);
    }
    Processor* getNextAvilableProcessor()
    {
        for(auto& a : processor)
        {
            if(!a->processsing())
                return a;
        }
        std::cout<<"All processors are busy, Waiting for next avilable processor\n";
        while(true)
        {
            for(auto& a : processor)
            {
                if(!a->processsing())
                    return a;
            }
        }
    }

private:
    std::vector<Processor*> processor;

};

int main()
{

int i =257;
int*ptr = &i;
    std::vector<Process> processes(100);
    scheduler scheduler;
    Processor one;
    Processor two;
    Processor three;
    Processor four;
    scheduler.addPrcessor(one);
    scheduler.addPrcessor(two);
    scheduler.addPrcessor(three);
    scheduler.addPrcessor(four);

    for(auto& process : processes)
    {
        scheduler.prcess(process);
    };


}

#包括
#包括
#包括
#包括
int global_processorID=0；
int global_processID=0；
结构过程
{
整数圈；
内部存储器；
int-pid；
过程（）
{
pid=全局_进程ID++；
周期=兰德（）%1000；
内存=rand（）%100；
}
};
类处理器
{
公众：
处理器（）：正在处理（false）
{
这->processorID=global_processorID++；
}
boolprocessing（）
{
退货处理；
}
无效流程（流程和流程）
{
处理=真；
std:：async（std:：launch:：async，[&]
{
std：：coutf通过快速查看您的作业，他们可能希望您实现@Mints97我实际上需要实现一个简单的FCFS算法。好吧，听起来您走在正确的轨道上-做了简单的一点，了解谷歌FCFS的一些示例伪代码或实际代码-您为什么在这里？我们帮助那些陷入困境的人，而不是暂停的人…FCFS如何算是开发一个最小化总时间的算法？嗯。可能是因为C++ 11，按你的代码来调整代码。compiler@Satbir您是否有不使用O.O.P实现此功能的方法？很难理解其逻辑。@Mohsin我将尝试并很快给您提供一个链接。THX建议更正：删除前面描述的
中的
，add
a
在非常相似的书之前