README with explanations added

README.md

@@ -0,0 +1,133 @@
+### Erklärung des Programms und seiner Funktionsweise
+
+#### 1. Grundlegende Struktur
+Das Programm simuliert einen präemptiven Scheduler nach dem Round-Robin-Prinzip für einen Mikrocontroller. Es verwaltet mehrere Tasks (Prozesse), die aus Dateien gelesen werden und abwechselnd Rechenzeit erhalten.
+
+#### 2. Wichtige Komponenten
+- **Task-Struktur**: Repräsentiert einen Prozess
+  ```cpp
+  struct Task {
+      int pid;              // Prozess-ID
+      std::string filename; // Dateiname des Tasks
+      std::vector<std::pair<std::string, std::string>> program; // Befehlsliste
+      int pc;               // Program Counter
+      int accu;             // Akkumulator-Wert
+      int blocked;          // Verbleibende Blockierungszeit
+      int start_tick;       // Startzeitpunkt
+      int end_tick;         // Endzeitpunkt
+      bool terminated;      // Status ob beendet
+      int slice_remaining;  // Verbleibende Zeitscheibenzeit
+  };
+  ```
+
+#### 3. Ablauf des Programms
+
+**A. Initialisierung**
+```cpp
+auto init_program = readFile("init"); // Liest init-Datei OHNE .txt
+Task init_task = {
+    next_pid++,          // PID 0
+    "init",              // Dateiname
+    init_program,        // Programmcode
+    0,                  // PC startet bei 0
+    0,                  // Akku startet bei 0
+    0,                  // Nicht blockiert
+    0,                  // Start bei Tick 0
+    -1,                 // Ende noch nicht bekannt
+    false,              // Noch nicht terminiert
+    time_slice          // Volle Zeitscheibe
+};
+tasks.push_back(init_task);
+```
+
+**B. Hauptschleife - Der Scheduler**
+```cpp
+while (!all_terminated) {
+    // 1. Suche nächsten ausführbaren Task (Round-Robin)
+    // 2. Führe Task aus (so lange Zeitscheibe reicht)
+    // 3. Verarbeite Blockierungszeiten
+    // 4. Prüfe auf Terminierung
+}
+```
+
+**C. Task-Ausführung**
+Für jeden Befehl:
+```cpp
+if (command == "LOAD") {
+    current_task->accu = std::stoi(param);
+} else if (command == "ADD") {
+    current_task->accu += std::stoi(param);
+} else if (command == "SUB") {
+    current_task->accu -= std::stoi(param);
+} else if (command == "READ") {
+    current_task->accu = rand() % 4096; // Zufallswert 0-4095
+    current_task->blocked = 2;          // 2 Takte blockieren
+} else if (command == "EXE") {
+    // NEU: Direkt param verwenden OHNE .txt
+    std::string filename = param; 
+    auto new_program = readFile(filename);
+    // Neuen Task erstellen und hinzufügen
+} else if (command == "T") {
+    current_task->terminated = true;
+}
+```
+
+**D. Besondere Logik**
+- **Blockierung**: Bei `READ` wird der Task für 2 Takte blockiert
+- **EXE-Befehl**: Startet neuen Task mit eigenem Programm
+- **Zeitscheibe**: Task läuft maximal `time_slice` Befehle am Stück
+- **IDLE**: Wenn alle Tasks blockiert sind
+  ```cpp
+  std::cout << current_tick << "\tIDLE" << std::endl;
+  ```
+
+**E. Statistik am Ende**
+Ausgabe für jeden Task:
+```cpp
+PID  Task    Start  Ende  Verweilzeit  Akku
+0    init    0      12    13           7
+1    file_a  3      8     6            19
+...
+```
+
+#### 4. Durchgeführte Änderungen
+Ihre Anpassungen sind hier besonders wichtig:
+```cpp
+// Vorher: "init.txt" -> Jetzt: "init"
+auto init_program = readFile("init");
+
+// Vorher: param + ".txt" -> Jetzt: direkt param
+std::string filename = param; 
+auto new_program = readFile(filename);
+```
+
+**Begründung**: 
+- Die Aufgabenstellung gibt Dateien ohne `.txt`-Erweiterung vor (init, file_a, etc.)
+- Die Funktion `readFile` versucht direkt den übergebenen Namen zu öffnen
+- Ohne Änderung würde das Programm nach nicht existierenden Dateien suchen (z.B. "file_a.txt" statt "file_a")
+
+#### 5. Beispielablauf
+Für init.txt mit:
+```
+LOAD 5
+ADD 3
+EXE file_a
+```
+
+1. Tick 0: Lädt `LOAD 5` in init-Task
+2. Tick 1: Führt `ADD 3` aus (Akku=8)
+3. Tick 2: Startet neuen Task aus file_a
+4. Abwechselnde Ausführung beider Tasks
+
+#### 6. Besondere Szenarien
+- **Alle Tasks blockiert**: 
+  - Scheduler gibt "IDLE" aus
+  - Blockierungszeiten werden dekrementiert
+- **EXE in mehreren Tasks**: 
+  - Neue Tasks werden sofort zur Ausführung hinzugefügt
+  - Können vor dem Eltern-Task terminieren
+- **Zeitscheibe zu Ende**: 
+  - Task wird unterbrochen (präemptiv)
+  - Zustand (PC, Akku) wird gespeichert
+  - Nächster Task in Round-Robin-Reihenfolge kommt dran
+

einlesen.cpp

@@ -1,47 +1,228 @@
-#include "task.h"
-#include <deque>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <utility>
+#include <sstream>
+#include <cstdlib>
+#include <ctime>
+#include <algorithm>
+#include <iomanip>
 
-using namespace std;
+struct Task {
+    int pid;
+    std::string filename;
+    std::vector<std::pair<std::string, std::string>> program;
+    int pc;
+    int accu;
+    int blocked;
+    int start_tick;
+    int end_tick;
+    bool terminated;
+    int slice_remaining;
+};
 
-vector<pair<string, string> > readFile(const string &filename) {
-    vector<pair<string, string> > instructions;
-    ifstream file(filename);
+std::vector<std::pair<std::string, std::string>> readFile(const std::string &filename) {
+    std::vector<std::pair<std::string, std::string>> instructions;
+    std::ifstream file(filename);
     if(!file.is_open()) {
-        cerr << "Fehler: Datei " << filename << " konnte nicht geöffnet werden.\n";
+        std::cerr << "Fehler: Datei " << filename << " konnte nicht geöffnet werden.\n";
         return instructions;
     }
 
-    string line;
-    while (getline(file, line)) {
-        // Entferne führende oder trailing Whitespace
+    std::string line;
+    while (std::getline(file, line)) {
         if (line.empty()) continue;
 
-        istringstream iss(line);
-        string command;
-        string param;
+        std::istringstream iss(line);
+        std::string command;
+        std::string param;
 
         if (!(iss >> command)) {
-            // Keine gültige Eingabe in dieser Zeile
             continue;
         }
 
-        // Optionalen Parameter einlesen, falls vorhanden
         if (!(iss >> param)) {
-            // Kein Parameter vorhanden
             param = "";
         }
 
-        instructions.push_back(make_pair(command, param));
+        instructions.push_back(std::make_pair(command, param));
     }
 
     return instructions;
 }
 
-// Beispiel zur Nutzung
-int main() {
-    auto result = readFile("init");
-    for (const auto &inst : result) {
-        cout << "Befehl: " << inst.first << " | Parameter: " << inst.second << "\n";
+int main(int argc, char* argv[]) {
+    if (argc < 2) {
+        std::cerr << "Verwendung: " << argv[0] << " <Zeitscheibenlänge>" << std::endl;
+        return 1;
+    }
+    int time_slice = std::stoi(argv[1]);
+    srand(time(0));
+
+    std::vector<Task> tasks;
+    int next_pid = 0;
+    int current_tick = 0;
+
+    // Initialen Task aus init erstellen
+    auto init_program = readFile("init");
+    if (init_program.empty()) {
+        std::cerr << "Fehler: init konnte nicht gelesen werden." << std::endl;
+        return 1;
+    }
+    Task init_task = {
+        next_pid++, 
+        "init", 
+        init_program, 
+        0, 
+        0, 
+        0, 
+        0, 
+        -1, 
+        false,
+        time_slice
+    };
+    tasks.push_back(init_task);
+
+    // Header ausgeben
+    std::cout << "Tick\tPID\tTask\tPC\tAccu\tInstr" << std::endl;
+
+    int last_executed_index = -1;
+    bool all_terminated = false;
+
+    while (!all_terminated) {
+        all_terminated = true;
+        bool found_runnable = false;
+        int start_index = (last_executed_index + 1) % tasks.size();
+        int current_index = start_index;
+        Task* current_task = nullptr;
+
+        do {
+            Task& task = tasks[current_index];
+            if (!task.terminated && task.blocked == 0) {
+                current_task = &task;
+                found_runnable = true;
+                last_executed_index = current_index;
+                break;
+            }
+            current_index = (current_index + 1) % tasks.size();
+        } while (current_index != start_index);
+
+        if (found_runnable) {
+            while (current_task->slice_remaining > 0 && !current_task->terminated && current_task->blocked == 0) {
+                // Hole Befehl
+                auto& instruction = current_task->program[current_task->pc];
+                std::string command = instruction.first;
+                std::string param = instruction.second;
+
+                // Ausgabe des aktuellen Zustands
+                std::cout << current_tick << "\t" 
+                          << current_task->pid << "\t" 
+                          << current_task->filename << "\t" 
+                          << current_task->pc << "\t" 
+                          << current_task->accu << "\t" 
+                          << command;
+                if (!param.empty()) {
+                    std::cout << " " << param;
+                }
+                std::cout << std::endl;
+
+                // Führe Befehl aus
+                if (command == "LOAD") {
+                    current_task->accu = std::stoi(param);
+                } else if (command == "ADD") {
+                    current_task->accu += std::stoi(param);
+                } else if (command == "SUB") {
+                    current_task->accu -= std::stoi(param);
+                } else if (command == "READ") {
+                    current_task->accu = rand() % 4096;
+                    current_task->blocked = 2;
+                } else if (command == "EXE") {
+                    std::string filename = param;
+                    auto new_program = readFile(filename);
+                    if (!new_program.empty()) {
+                        Task new_task = {
+                            next_pid++,
+                            param,
+                            new_program,
+                            0,
+                            0,
+                            0,
+                            current_tick + 1,
+                            -1,
+                            false,
+                            time_slice
+                        };
+                        tasks.push_back(new_task);
+                    }
+                } else if (command == "T") {
+                    current_task->terminated = true;
+                    current_task->end_tick = current_tick;
+                }
+
+                // PC erhöhen, außer bei Terminierung
+                if (command != "T") {
+                    current_task->pc++;
+                    if (current_task->pc >= current_task->program.size()) {
+                        current_task->terminated = true;
+                        current_task->end_tick = current_tick;
+                    }
+                }
+
+                // Blockierungszeit für andere Tasks dekrementieren
+                for (auto& task : tasks) {
+                    if (task.blocked > 0) {
+                        if (&task == current_task && command == "READ") {
+                            // Nicht dekrementieren
+                        } else {
+                            task.blocked--;
+                        }
+                    }
+                }
+
+                // Zeitscheibe verbrauchen
+                current_task->slice_remaining--;
+                current_tick++;
+
+                // Bei Blockierung oder Terminierung Schleife verlassen
+                if (current_task->blocked > 0 || current_task->terminated) {
+                    break;
+                }
+            }
+
+            // Zeitscheibe zurücksetzen
+            current_task->slice_remaining = time_slice;
+        } else {
+            // Kein lauffähiger Task (IDLE)
+            std::cout << current_tick << "\tIDLE" << std::endl;
+            for (auto& task : tasks) {
+                if (task.blocked > 0) {
+                    task.blocked--;
+                }
+            }
+            current_tick++;
+        }
+
+        // Prüfen, ob noch aktive Tasks existieren
+        for (const auto& task : tasks) {
+            if (!task.terminated) {
+                all_terminated = false;
+                break;
+            }
+        }
+    }
+
+    // Statistik ausgeben
+    std::cout << "\nStatistik:" << std::endl;
+    std::cout << "PID\tTask\tStart\tEnde\tVerweilzeit\tAccu" << std::endl;
+    for (const auto& task : tasks) {
+        int turnaround = task.end_tick - task.start_tick + 1;
+        std::cout << task.pid << "\t" 
+                  << task.filename << "\t" 
+                  << task.start_tick << "\t" 
+                  << task.end_tick << "\t" 
+                  << turnaround << "\t\t" 
+                  << task.accu << std::endl;
     }
 
     return 0;

task.cpp

@@ -1,15 +0,0 @@
-#include <task.h>
-
-Task::Task(int pid, 
-           const std::string &name, 
-           const std::vector<std::pair<std::string, std::string>> &program)
-{
-    this->pid=pid;
-    this->name=name;
-    this->program=program;
-    this->pc=0;
-    this->acc=0;
-    this->blockTicks=0;
-    this->active=true;
-}
-

task.h

@@ -1,28 +0,0 @@
-#ifndef TASK_H
-#define TASK_H
-
-#include <iostream>
-#include <iomanip>
-#include <fstream>
-#include <string>
-#include <vector>
-#include <utility>
-#include <sstream>
-
-class Task 
-{
-public:
-    Task()=delete;
-    Task(int pid, const std::string &name, const std::vector<std::pair<std::string, std::string>> &program);
-private:
-    int pid,
-        pc,
-        acc,
-        blockTicks;
-    std::string name;
-    std::vector<std::pair<std::string, std::string>> program;
-    bool active;
-};
-
-
-#endif //TASK_H