调度算法的实现

Question

我有一个任务，我需要开发一个流程调度程序的模拟。我已经完成了大部分设置，但我一直在弄清楚实际安排流程的逻辑。现在，我创建了一个结构，其中包含进程的 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);

}

Answer 1

请检查您是否理解以下内容。

#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);
    };


}

Answer 2

应该在Windows Internals 中描述。我已阅读a very similar book（未提供英文版），其中描述了进程调度算法。