SchedSim - Simulator de Planificare a Proceselor

Acest proiect este o aplicatie scrisa in limbajul C care simuleaza executia proceselor pe un procesor, folosind diversi algoritmi de planificare (scheduling). Aplicatia calculeaza metrici de performanta si genereaza o reprezentare vizuala a graficului Gantt folosind un script Python.

Descriere Generala

SchedSim permite utilizatorului sa analizeze comportamentul a trei algoritmi distincti de planificare. Pentru gestionarea eficienta a cozii de asteptare (Ready Queue), aplicatia utilizeaza o structura de date de tip Heap (Min-Heap sau Max-Heap, in functie de algoritm).

Aplicatia ofera trei moduri de functionare:

1. Rularea unui set de teste predefinite.
2. Rularea unui test custom dintr-un fisier specific.
3. Generarea automata a unui test de stres pentru compararea performantei.

Algoritmi Suportati

1. Priority Scheduling (Non-Preemptive):

   • Procesul cu prioritatea cea mai mare (valoare numerica mai mare) este selectat pentru executie.
   • Odata ce un proces incepe executia, acesta ruleaza pana la finalizare, fara a fi intrerupt.

2. Priority Scheduling (Preemptive):

   • Procesul cu prioritatea cea mai mare ruleaza.
   • Daca apare un proces nou cu o prioritate mai mare decat procesul curent, procesul curent este intrerupt (preemptat) si pus inapoi in coada.

3. Earliest Deadline First (EDF):

   • Este un algoritm dinamic de planificare in timp real.
   • Prioritatea este determinata de deadline: procesul cu cel mai apropiat deadline (valoare minima) are prioritate maxima.
   • Suporta preemtiune.

Cerinte de Sistem

Pentru a compila si rula proiectul, aveti nevoie de urmatoarele:

• Compilator C: Compatibil cu standardul C11 (ex: GCC, Clang, MSVC).
• CMake: Versiunea 3.30 sau mai noua.
• Python 3: Pentru rularea vizualizatorului grafic.
• Biblioteci Python: matplotlib si pandas.

Instalarea dependentelor Python:

pip install matplotlib pandas

Structura Proiectului

• main.c: Punctul de intrare in aplicatie. Gestioneaza meniul, citirea fisierelor, rularea simularii si calculul statisticilor.
• Heap.h / Heap.c: Implementarea structurii de date Heap, folosita pentru coada de prioritati. Functia de comparare se adapteaza dinamic in functie de algoritmul ales.
• process.h: Definirea structurii Process si a tipurilor de date asociate.
• visualizer.py: Script Python care citeste fisierul simulation_data.csv generat de aplicatia C si afiseaza un grafic Gantt.
• test_generator.c: Utilitar pentru generarea aleatorie a fisierelor de intrare (util pentru stress testing).
• CMakeLists.txt: Fisierul de configurare pentru sistemul de build CMake.
• tests/: Director (trebuie creat) care contine fisiere de intrare pentru testele implicite.

Compilare si Instalare

1. Creati un director de build:

   mkdir build
   cd build

2. Generati fisierele de build folosind CMake:

   cmake ..

3. Compilati proiectul:

   cmake --build .

Acest proces va genera executabilele SchedSim (aplicatia principala) si test_generator.

Utilizare

Rulati executabilul principal:

Linux/macOS:

./SchedSim

Windows:

SchedSim.exe

Meniul Aplicatiei

La pornire, veti intalni urmatoarele optiuni:

1. Ruleaza testele implicite:

   • Cauta fisiere .in in directorul tests/.
   • Ruleaza toti cei 3 algoritmi pentru fiecare fisier gasit.
   • Afiseaza statistici in consola fara a genera grafice.

2. Ruleaza test custom:

   • Citeste fisierul custom_input.in din directorul radacina.
   • Cere utilizatorului sa aleaga un algoritm specific.
   • Genereaza fisierul simulation_data.csv.
   • Lanseaza automat scriptul Python pentru a afisa graficul Gantt.

3. Ruleaza stress test:

   • Apeleaza test_generator pentru a crea un fisier generated_test.in cu date aleatorii.
   • Ruleaza toti cei 3 algoritmi pe acest fisier.
   • Afiseaza un tabel comparativ cu metrici (Timp mediu de asteptare, Turnaround time, Utilizare CPU, Numar de context switches).

Formatul Fisierelor de Intrare

Fisierele de intrare (ex: custom_input.in, fisierele din tests/) trebuie sa respecte urmatorul format text:

• Prima linie: Un numar intreg N reprezentand numarul de procese.
• Urmatoarele N linii: Detalii despre fiecare proces, sub forma a 5 coloane separate prin spatiu:

  PID  Arrival_Time  Burst_Time  Priority  Deadline
  

Exemplu:

3
1 0 5 10 20
2 2 4 20 15
3 4 2 15 10

Interpretarea Rezultatelor

Dupa rularea simularii, aplicatia afiseaza un tabel cu urmatoarele coloane:

• PID: ID-ul procesului.
• AT (Arrival Time): Momentul sosirii in sistem.
• BT (Burst Time): Timpul necesar executiei pe CPU.
• CT (Completion Time): Momentul in care procesul a terminat executia.
• TAT (Turnaround Time): CT - AT. Durata totala petrecuta in sistem.
• WT (Waiting Time): TAT - BT. Timpul petrecut asteptand in coada.
• PRIO: Prioritatea procesului.
• Status: OK (terminat cu succes) sau FAILED (deadline ratat - specific EDF).

De asemenea, se afiseaza metrici globale:

• Timpul mediu de raspuns (Average Turnaround Time).
• Timpul mediu de asteptare (Average Waiting Time).
• Gradul de utilizare al procesorului (CPU Utilization).
• Numarul de comutari de context (Context Switches).

Detalii Tehnice

• Context Switching: Simulat in momentul in care procesorul schimba procesul curent cu un altul. Acest lucru se intampla frecvent in algoritmii preemtivi.
• Heap: Implementarea foloseste un vector static pentru stocarea nodurilor. Functiile push si pop asigura mentinerea proprietatii de heap in O(log N).
• Vizualizare: Fisierul simulation_data.csv contine segmente de timp (PID, Start, Duration) pe care Python le interpreteaza pentru a desena bare orizontale colorate diferit pentru fiecare PID.