Wie sollte ich ein FCFS-Scheduling-Programm in C oder C++ erstellen?

Question

Ich bleibe bei meiner aktuellen Aufgabe stecken, hauptsächlich weil ich nach einer langen Zeit nicht mehr sehr gut in C bin.

Wir müssen einen FCFS (First Come First Serve) Scheduling Algorithm Simulator erstellen, der einfach alle Zeitvorgänge durchläuft und durchgeht, die für jeden Prozess stattfinden würden, und sie ausdrucken, wenn sie ihren Prozess und ihre Bearbeitungszeit abgeschlossen haben .

Ich bekomme, wie der Prozess funktioniert, aber die Implementierung in ein C oder C++ Programm stampft mich und ich weiß nicht einmal, wo ich anfangen soll.

Wir haben unsere Eingabe von stdin werden immer und es wird in diesem Format sein:

Erste Zeile: (Anzahl der CPUs) (Anzahl der Prozesse) (Quantengröße)

Prozesslinie: (ID) (Priorität) (Zeitpunkt der Übermittlung) (CPU - Zeit erforderlich) (Berechnungszeit vor der E/A - Anforderung) (E/A - Zeit für jede Berechnung)

Weitere benötigte Prozesslinien basierend auf der Anzahl der definierten Prozesse erste Linie.

Beispiel Eingang kann sein:

Lange Rede kurzer Sinn, kann mir jemand auf einige Ressourcen verweisen, die Quelle helfen oder Probe, die eine umfassen Möglichkeit von mehreren CPUs. Oder wenn ihr mir helfen könnt, mich anzufangen, würde ich es wirklich sehr schätzen. Ich bitte dich nicht, die ganze Sache zu machen, hilf mir, damit ich anfangen kann, damit ich von dort aus weiß, wohin ich gehe.

Danke!

edit:

Hier ist, was ich bisher habe. Es ist sehr rudimentär, aber schon jetzt ich bin nur versuchen, dies zu erhalten getan und wie ich schon sagte, ich bin extrem rostig mit C (nicht, dass ich mit ihm geübt war sowieso):

int main() 
{ 
    //process * proc = (process *)malloc(100*sizeof(process)); 
    process proc[25]; 
    CPU cp[4]; 
    int count = 0; 
    //int * input = malloc(sizeof(int) * 100); 
    int input = 0; 
    int cpus = 0; 
    int processes = 0; 
    int quantum = 0; 
    int processLoop = 0; 
    int x = 0; 

    int id = 0; 
    int pri = 0; 
    int sub = 0; 
    int cptime = 0; 
    int compute = 0; 
    int itime = 0; 
    int complete = 0; 


    while(1 == scanf("%d", &input)) 
    { 
      if(count < 0) 
        break; 
      if(count == 0) 
      { 
        cpus = input; 
      } 
      else if(count == 1) 
      { 
        processes = input; 
      } 
      else if(count == 2) 
      { 
        quantum = input; 
      } 
      else 
      { 
        if(count == 3) 
        { 
          proc[processLoop].ID = input; 
        } 
        else if(count == 4) 
        { 
          proc[processLoop].Priority = input; 
        } 
        else if(count == 5) 
        { 
          proc[processLoop].subTime = input; 
        } 
        else if(count == 6) 
        { 
          proc[processLoop].cpuTime = input; 
        } 
        else if(count == 7) 
        { 
          proc[processLoop].computeTime = input; 
        } 
        else if(count == 8) 
        { 
          proc[processLoop].ioTime = input; 
          proc[processLoop].isCompleted = 0; 
          processLoop++; 
          if(processLoop == processes) 
          { 
            count = -1;   //Leaves possibility for multiple simulations in one run 
          } 
          else 
          { 
            count = 2;   //Repeats if multiple processes are detected 
          } 
        } 
      } 
      count++; 

    } 

    for(x = 0; x < cpus; x++) 
    { 
      cpu[x].idle = 0; 
    } 

    return 0; 
} 

Ja, super primitiv und nicht effizient, aber es liest alle Zahlen und endet entweder bei EOF oder wenn irgendetwas nicht eine Ziffer kommt es ist Weg. Auch eine negative Zahl. Der Grund, warum ich proc ein Array von 25 gemacht habe, ist, weil das die Grenze ist, von der unser Ausbilder sagte, dass die Zahl auch steigen wird. Und mit CPUs, sagte er, dass maximal vier verwendet werden, also habe ich gerade ein Array gemacht, hauptsächlich weil ich mit Zeigern schrecklich bin.

Jetzt, da ich die Daten in mein Array (s) habe, muss ich mein proc-Array nach subTime sortieren und mit den eigentlichen Berechnungen beginnen. Wie schlimm wird dieser Teil sein, besonders mit meiner lausigen Einrichtung?

Answer 1

Aktionsplan für Sie Ihr Ziel zu erreichen:

1. Daten definieren Strukturen für die Prozess- und CPU
2. Scan alle Eingänge. Initialisiere alle Datenstrukturen.
3. Entwickeln Sie Code für einzelne CPU. Überprüfen Sie, ob es richtig funktioniert
4. Ändern Sie den Code für mehrere CPUs.Überprüfen, ob es

Schritt 1 funktioniert:

Definieren eine Datenstruktur für den Prozess. (Für C++ Verwendung Klasse)

typedef struct process 
{ 
     int ID; 
     int Priority; 
     int time_of_submission; 
     int cpu_time_required; 
     int compute_time_before_IO; 
     int IO_time_per_compute; 
     int isCompleted; // if 1 means its complete. at start, its value is 0 
}process; 

für CPUs, halten eine Reihe, die Sie id seine Leerlauf- oder zugewiesen einige Verfahren kann sagen: Für C können Sie Struktur wie folgt verwenden.

typedef struct CPU 
{ 
     int idle;  // if set to 1, then its idle. 
        // If set to 0, then its working on a process 
     process *next; // points to the process that CPU is executing 
         // points to null if CPU is idle. 
}CPU; 

Schritt 2:

Scan alle Eingänge scanf verwenden, füllen ein Array von 'process' für alle Eingänge Prozesse. Sortieren Sie das Array 'process' anhand der Felder, die die Planung gemäß FCFS bestimmen, um Ihre Arbeit zu erleichtern. (zB time_of_submission, CPU time required, Priorität .. ich überlasse es Ihnen für andere Felder)

Initialize Array von 'CPU'.

Schritt 3: Entwickeln Sie Code für einzelne CPU. Überprüfen Sie, ob es richtig funktioniert.

Ich denke, Sie haben ein Problem mit dem Multiple-CPU-Szenario. Also nehmen Sie diese Multiple-CPU-Vorstellung aus Rücksicht auf die Zeit. Schreiben Sie die Logik für einzelne CPU auf Papier auf. Erstellen Sie Pseudocode. Dann erstellen Sie einen C (oder C++) Code daraus. Wenn Sie bei der Syntax bleiben, googeln Sie, wie Sie das tun und weitermachen.

Schritt 4: Den Code für mehrere CPUs ändern. Überprüfen Sie, ob es funktioniert

Denken Sie darüber nach, was mit multiple CPU passieren wird.

Sobald Sie hier fertig sind, können Sie dies ändern, um Priorität des zu berücksichtigenden Prozesses zu haben.