feat: Implement initial Process Scheduling Simulator application with core logic, algorithms, UI components, and project setup.
This commit is contained in:
Lucas Guerra committed
commit
083fc0027e
54 files changed
+8815
No files matched your search
+19
@@ -0,0 +1,19 @@
|
|||||||
|
!**/glob-import/dir/node_modules
|
||||||
|
.DS_Store
|
||||||
|
.idea
|
||||||
|
.pnpm-store
|
||||||
|
*.cpuprofile
|
||||||
|
*.local
|
||||||
|
*.log
|
||||||
|
/.vscode/
|
||||||
|
/docs/.vitepress/cache
|
||||||
|
/docs/.vitepress/.temp
|
||||||
|
/packages/vite/LICENSE
|
||||||
|
dist
|
||||||
|
dist-ssr
|
||||||
|
explorations
|
||||||
|
node_modules
|
||||||
|
playground-temp
|
||||||
|
temp
|
||||||
|
TODOs.md
|
||||||
|
.eslintcache
|
||||||
@@ -0,0 +1,713 @@
|
|||||||
|
# Process Scheduler Simulator — Especificação Técnica Completa
|
||||||
|
|
||||||
|
> **Versão:** 1.0
|
||||||
|
> **Data:** 2026-03-19
|
||||||
|
> **Autor:** Lucas Rayan Guerra
|
||||||
|
> **Stack alvo:** React + Vite (Single Page Application, browser-only, sem backend)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 1. Visão Geral
|
||||||
|
|
||||||
|
O **Process Scheduler Simulator** é uma ferramenta educacional interativa que roda inteiramente no navegador. Ele permite ao usuário criar processos, escolher um algoritmo de escalonamento, executar a simulação passo a passo ou de forma automática, visualizar o diagrama de Gantt em tempo real e analisar métricas detalhadas por processo e globais.
|
||||||
|
|
||||||
|
### 1.1 Objetivos
|
||||||
|
|
||||||
|
| # | Objetivo |
|
||||||
|
|---|----------|
|
||||||
|
| O1 | Simular fielmente os algoritmos clássicos de escalonamento de SO |
|
||||||
|
| O2 | Permitir execução passo a passo para fins didáticos |
|
||||||
|
| O3 | Exibir diagrama de Gantt animado com estados de CPU e I/O |
|
||||||
|
| O4 | Calcular e exibir métricas completas por processo e agregadas |
|
||||||
|
| O5 | Ser completamente autocontido — sem servidor, sem dependências externas de dados |
|
||||||
|
|
||||||
|
### 1.2 Público-Alvo
|
||||||
|
|
||||||
|
- Estudantes de Sistemas Operacionais (graduação/pós)
|
||||||
|
- Professores que queiram usar em sala de aula
|
||||||
|
- Profissionais revisando fundamentos de SO
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 2. Requisitos Funcionais
|
||||||
|
|
||||||
|
### RF-01 — Gerenciamento de Processos
|
||||||
|
|
||||||
|
| ID | Descrição |
|
||||||
|
|----|-----------|
|
||||||
|
| RF-01.1 | O usuário pode **criar** um processo com os atributos listados na seção 3.1 |
|
||||||
|
| RF-01.2 | O usuário pode **editar** um processo antes de iniciar a simulação |
|
||||||
|
| RF-01.3 | O usuário pode **remover** um processo individual ou **limpar** todos |
|
||||||
|
| RF-01.4 | O usuário pode **gerar processos aleatórios** com parâmetros configuráveis (quantidade, faixas de valores) |
|
||||||
|
| RF-01.5 | A lista de processos exibe uma prévia das propriedades e a classificação CPU/I/O Bound estimada |
|
||||||
|
| RF-01.6 | Mínimo de 1 processo, máximo de 16 processos por simulação |
|
||||||
|
|
||||||
|
### RF-02 — Configuração do Escalonador
|
||||||
|
|
||||||
|
| ID | Descrição |
|
||||||
|
|----|-----------|
|
||||||
|
| RF-02.1 | O usuário seleciona **um** algoritmo de escalonamento por simulação |
|
||||||
|
| RF-02.2 | Parâmetros específicos de algoritmo são exibidos dinamicamente (ex.: quantum para RR) |
|
||||||
|
| RF-02.3 | O usuário configura o **tempo de context switch** (0–10 unidades de tempo, padrão 0) |
|
||||||
|
| RF-02.4 | O usuário configura se o escalonador é **preemptivo ou cooperativo** (onde aplicável) |
|
||||||
|
|
||||||
|
### RF-03 — Simulação
|
||||||
|
|
||||||
|
| ID | Descrição |
|
||||||
|
|----|-----------|
|
||||||
|
| RF-03.1 | **Play** inicia/retoma a simulação com velocidade configurável |
|
||||||
|
| RF-03.2 | **Pause** suspende a execução sem perder o estado |
|
||||||
|
| RF-03.3 | **Step** avança exatamente 1 unidade de tempo (tick) |
|
||||||
|
| RF-03.4 | **Reset** retorna ao estado inicial sem perder a configuração de processos |
|
||||||
|
| RF-03.5 | **Velocidade** ajustável: 0.25×, 0.5×, 1×, 2×, 4× (padrão 1×) |
|
||||||
|
| RF-03.6 | A simulação termina quando todos os processos atingem estado **Terminated** |
|
||||||
|
| RF-03.7 | O tick atual é exibido em destaque no painel de controle |
|
||||||
|
|
||||||
|
### RF-04 — Diagrama de Gantt
|
||||||
|
|
||||||
|
| ID | Descrição |
|
||||||
|
|----|-----------|
|
||||||
|
| RF-04.1 | Cada processo ocupa uma linha horizontal no diagrama |
|
||||||
|
| RF-04.2 | Cada tick é representado por uma célula colorida conforme o estado |
|
||||||
|
| RF-04.3 | O tick atual é destacado com uma linha vertical animada |
|
||||||
|
| RF-04.4 | Legenda de cores dos estados exibida abaixo do diagrama |
|
||||||
|
| RF-04.5 | O diagrama faz scroll horizontal automático para acompanhar o tick atual |
|
||||||
|
| RF-04.6 | Hovering sobre uma célula exibe tooltip: processo, tick, estado, detalhes |
|
||||||
|
|
||||||
|
### RF-05 — Métricas
|
||||||
|
|
||||||
|
| ID | Descrição |
|
||||||
|
|----|-----------|
|
||||||
|
| RF-05.1 | Métricas são calculadas por processo ao final da simulação |
|
||||||
|
| RF-05.2 | Métricas globais (médias, totais) são exibidas em painel separado |
|
||||||
|
| RF-05.3 | Um gráfico de barras comparativo exibe o turnaround e waiting time por processo |
|
||||||
|
| RF-05.4 | A classificação CPU Bound / I/O Bound é determinada automaticamente (ver seção 5) |
|
||||||
|
| RF-05.5 | As métricas podem ser exportadas como CSV |
|
||||||
|
|
||||||
|
### RF-06 — Persistência Local
|
||||||
|
|
||||||
|
| ID | Descrição |
|
||||||
|
|----|-----------|
|
||||||
|
| RF-06.1 | O estado atual (processos + configuração) é salvo automaticamente no `localStorage` |
|
||||||
|
| RF-06.2 | O usuário pode exportar/importar configurações como JSON |
|
||||||
|
| RF-06.3 | Cenários pré-definidos (presets) estão disponíveis para carregamento rápido |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 3. Modelo de Dados
|
||||||
|
|
||||||
|
### 3.1 Processo (`Process`)
|
||||||
|
|
||||||
|
```typescript
|
||||||
|
interface BurstSegment {
|
||||||
|
type: "cpu" | "io";
|
||||||
|
duration: number; // unidades de tempo
|
||||||
|
}
|
||||||
|
|
||||||
|
interface Process {
|
||||||
|
id: string; // UUID gerado na criação
|
||||||
|
name: string; // "P1", "P2" ou nome personalizado
|
||||||
|
arrivalTime: number; // tick de chegada na fila ready (≥ 0)
|
||||||
|
priority: number; // 1 (maior prioridade) a 10 (menor); padrão 5
|
||||||
|
color: string; // cor HEX para o diagrama
|
||||||
|
bursts: BurstSegment[]; // sequência alternada CPU→I/O→CPU→...
|
||||||
|
// deve começar e terminar com CPU
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
**Exemplo de processo:**
|
||||||
|
|
||||||
|
```json
|
||||||
|
{
|
||||||
|
"id": "p1",
|
||||||
|
"name": "P1",
|
||||||
|
"arrivalTime": 0,
|
||||||
|
"priority": 3,
|
||||||
|
"color": "#4FC3F7",
|
||||||
|
"bursts": [
|
||||||
|
{ "type": "cpu", "duration": 4 },
|
||||||
|
{ "type": "io", "duration": 3 },
|
||||||
|
{ "type": "cpu", "duration": 2 }
|
||||||
|
]
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
> **Regra:** `bursts` deve ter estrutura CPU → (IO → CPU)\* — sempre começa com CPU. Mínimo: 1 burst CPU.
|
||||||
|
|
||||||
|
### 3.2 Configuração do Escalonador (`SchedulerConfig`)
|
||||||
|
|
||||||
|
```typescript
|
||||||
|
interface SchedulerConfig {
|
||||||
|
algorithm: SchedulingAlgorithm;
|
||||||
|
quantum: number; // apenas para RR (padrão: 2)
|
||||||
|
contextSwitchTime: number; // overhead entre processos (padrão: 0)
|
||||||
|
isPreemptive: boolean; // aplicável a SJF e Priority
|
||||||
|
agingEnabled: boolean; // evitar starvation em Priority
|
||||||
|
agingInterval: number; // ticks para incremento de prioridade
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
### 3.3 Estado de Execução do Processo (`ProcessState`)
|
||||||
|
|
||||||
|
```typescript
|
||||||
|
type StateLabel =
|
||||||
|
| "New" // antes do arrivalTime
|
||||||
|
| "Ready" // na fila, aguardando CPU
|
||||||
|
| "Running" // executando burst CPU
|
||||||
|
| "Waiting" // executando burst I/O
|
||||||
|
| "Terminated"; // concluído
|
||||||
|
|
||||||
|
interface ProcessRuntime {
|
||||||
|
processId: string;
|
||||||
|
state: StateLabel;
|
||||||
|
remainingBurst: number; // ticks restantes no burst atual
|
||||||
|
burstIndex: number; // índice atual em Process.bursts
|
||||||
|
arrivalTick: number; // tick em que entrou na fila Ready pela 1ª vez
|
||||||
|
startTick: number | null; // tick da 1ª vez em Running
|
||||||
|
finishTick: number | null; // tick em que terminou
|
||||||
|
waitingTime: number; // acumulado em Ready
|
||||||
|
cpuTime: number; // acumulado em Running
|
||||||
|
ioTime: number; // acumulado em Waiting
|
||||||
|
responseTime: number | null;
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
### 3.4 Tick de Simulação (`SimTick`)
|
||||||
|
|
||||||
|
```typescript
|
||||||
|
interface SimTick {
|
||||||
|
tick: number;
|
||||||
|
cpuProcess: string | null; // PID executando na CPU
|
||||||
|
ioProcesses: string[]; // PIDs em I/O
|
||||||
|
readyQueue: string[]; // ordem da fila ready
|
||||||
|
states: Record<string, StateLabel>;
|
||||||
|
contextSwitching: boolean; // overhead ativo
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 4. Algoritmos de Escalonamento
|
||||||
|
|
||||||
|
### 4.1 Lista de Algoritmos Suportados
|
||||||
|
|
||||||
|
| Código | Nome | Preemptivo? | Parâmetro extra |
|
||||||
|
|--------|------|-------------|-----------------|
|
||||||
|
| `FCFS` | First Come First Served | Não | — |
|
||||||
|
| `SJF_NP` | Shortest Job First (não-preemptivo) | Não | — |
|
||||||
|
| `SJF_P` | Shortest Remaining Time First (preemptivo) | Sim | — |
|
||||||
|
| `RR` | Round Robin | Sim | Quantum |
|
||||||
|
| `PRIORITY_NP` | Priority Scheduling (não-preemptivo) | Não | — |
|
||||||
|
| `PRIORITY_P` | Priority Scheduling (preemptivo) | Sim | — |
|
||||||
|
| `MULTILEVEL` | Multilevel Queue | Sim | Nº de filas, quantum por fila |
|
||||||
|
| `HRRN` | Highest Response Ratio Next | Não | — |
|
||||||
|
|
||||||
|
### 4.2 Regras de Desempate
|
||||||
|
|
||||||
|
Para todos os algoritmos, quando dois processos têm o mesmo critério de seleção, o desempate é feito por ordem de chegada (`arrivalTime`) e depois por `id` lexicográfico.
|
||||||
|
|
||||||
|
### 4.3 Especificação de Comportamento por Algoritmo
|
||||||
|
|
||||||
|
#### FCFS
|
||||||
|
- A fila ready é ordenada por `arrivalTime` ascendente.
|
||||||
|
- O processo na cabeça da fila ocupa a CPU até terminar seu burst CPU atual.
|
||||||
|
- Ao término do burst CPU, se houver burst I/O, transita para Waiting.
|
||||||
|
- Ao terminar o I/O, retorna para a fila Ready (cauda).
|
||||||
|
|
||||||
|
#### SJF Não-Preemptivo
|
||||||
|
- Na seleção, escolhe o processo com **menor burst CPU atual** (`remainingBurst`).
|
||||||
|
- Não interrompe o processo em execução.
|
||||||
|
|
||||||
|
#### SRTF (SJF Preemptivo)
|
||||||
|
- A cada tick, verifica se algum processo na fila Ready tem `remainingBurst` menor que o processo atual.
|
||||||
|
- Se sim, realiza preempção (com context switch se configurado).
|
||||||
|
|
||||||
|
#### Round Robin
|
||||||
|
- Usa fila FIFO com quantum `q`.
|
||||||
|
- Ao expirar o quantum, o processo retorna ao fim da fila Ready se ainda tiver burst CPU restante.
|
||||||
|
- I/O bursts não consomem quantum.
|
||||||
|
|
||||||
|
#### Priority (Não-Preemptivo / Preemptivo)
|
||||||
|
- Menor valor numérico = maior prioridade.
|
||||||
|
- Com aging habilitado: a cada `agingInterval` ticks em Ready, `priority--` (até mínimo 1).
|
||||||
|
|
||||||
|
#### HRRN
|
||||||
|
- `ratio = (waitingTime + burstTime) / burstTime`
|
||||||
|
- A cada seleção, escolhe o processo com maior ratio.
|
||||||
|
- Não-preemptivo.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 5. Definição de CPU Bound vs. I/O Bound
|
||||||
|
|
||||||
|
A classificação é feita **por processo**, baseada na proporção de tempo total gasto:
|
||||||
|
|
||||||
|
```
|
||||||
|
cpuRatio = cpuTime / (cpuTime + ioTime)
|
||||||
|
ioRatio = ioTime / (cpuTime + ioTime)
|
||||||
|
|
||||||
|
if cpuRatio >= 0.65 → "CPU Bound"
|
||||||
|
if ioRatio >= 0.65 → "I/O Bound"
|
||||||
|
else → "Balanced"
|
||||||
|
```
|
||||||
|
|
||||||
|
A classificação aparece:
|
||||||
|
- Na lista de processos (badge de preview, calculado sobre os bursts declarados)
|
||||||
|
- Na tabela de métricas (calculado sobre os tempos reais simulados)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 6. Métricas
|
||||||
|
|
||||||
|
### 6.1 Métricas por Processo
|
||||||
|
|
||||||
|
| Métrica | Fórmula | Descrição |
|
||||||
|
|---------|---------|-----------|
|
||||||
|
| **Arrival Time** | `arrivalTime` | Tick de chegada na fila |
|
||||||
|
| **First CPU Tick** | `startTick` | Primeiro tick em Running |
|
||||||
|
| **Finish Time** | `finishTick` | Tick de término |
|
||||||
|
| **Response Time** | `startTick − arrivalTime` | Tempo até 1ª vez na CPU |
|
||||||
|
| **Turnaround Time** | `finishTick − arrivalTime` | Tempo total de vida |
|
||||||
|
| **Waiting Time** | `turnaround − cpuTime − ioTime` | Tempo na fila Ready |
|
||||||
|
| **CPU Time** | Σ Running ticks | Total de CPU consumida |
|
||||||
|
| **I/O Time** | Σ Waiting ticks | Total de I/O |
|
||||||
|
| **CPU Utilization** | `cpuTime / turnaround × 100` | % do turnaround em CPU |
|
||||||
|
| **Bound Type** | ver seção 5 | CPU Bound / I/O Bound / Balanced |
|
||||||
|
|
||||||
|
### 6.2 Métricas Globais
|
||||||
|
|
||||||
|
| Métrica | Fórmula |
|
||||||
|
|---------|---------|
|
||||||
|
| **Avg Response Time** | Média dos response times |
|
||||||
|
| **Avg Turnaround Time** | Média dos turnarounds |
|
||||||
|
| **Avg Waiting Time** | Média dos waiting times |
|
||||||
|
| **CPU Throughput** | `processos concluídos / tempo total` |
|
||||||
|
| **CPU Utilization (global)** | `Σ Running ticks / tempo total × 100` |
|
||||||
|
| **Total Simulation Time** | Tick final |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 7. Arquitetura da Aplicação
|
||||||
|
|
||||||
|
### 7.1 Stack Tecnológica
|
||||||
|
|
||||||
|
```
|
||||||
|
Runtime: React 18 + Vite 5
|
||||||
|
Linguagem: TypeScript 5
|
||||||
|
Estilos: Tailwind CSS 3 + CSS Modules (para componentes específicos)
|
||||||
|
Gráficos: Recharts (gráfico de barras de métricas)
|
||||||
|
Estado: Zustand (store global)
|
||||||
|
Persistência: localStorage (auto-save) + JSON import/export
|
||||||
|
Testes: Vitest + @testing-library/react
|
||||||
|
```
|
||||||
|
|
||||||
|
### 7.2 Estrutura de Pastas
|
||||||
|
|
||||||
|
```
|
||||||
|
src/
|
||||||
|
├── core/ # Lógica pura — sem React
|
||||||
|
│ ├── algorithms/
|
||||||
|
│ │ ├── fcfs.ts
|
||||||
|
│ │ ├── sjf.ts
|
||||||
|
│ │ ├── rr.ts
|
||||||
|
│ │ ├── priority.ts
|
||||||
|
│ │ ├── hrrn.ts
|
||||||
|
│ │ ├── multilevel.ts
|
||||||
|
│ │ └── index.ts # dispatch por algoritmo
|
||||||
|
│ ├── engine.ts # SimulationEngine — step(), runAll()
|
||||||
|
│ ├── metrics.ts # cálculo de métricas
|
||||||
|
│ ├── types.ts # todas as interfaces
|
||||||
|
│ └── presets.ts # cenários pré-definidos
|
||||||
|
│
|
||||||
|
├── store/
|
||||||
|
│ ├── processStore.ts # CRUD de processos
|
||||||
|
│ ├── simulationStore.ts # estado da simulação, ticks
|
||||||
|
│ └── uiStore.ts # estado da UI (painéis abertos, velocidade)
|
||||||
|
│
|
||||||
|
├── components/
|
||||||
|
│ ├── ProcessPanel/ # criação/edição de processos
|
||||||
|
│ │ ├── ProcessList.tsx
|
||||||
|
│ │ ├── ProcessForm.tsx
|
||||||
|
│ │ └── ProcessCard.tsx
|
||||||
|
│ ├── SchedulerPanel/ # seleção de algoritmo e parâmetros
|
||||||
|
│ │ ├── AlgorithmSelector.tsx
|
||||||
|
│ │ └── SchedulerConfig.tsx
|
||||||
|
│ ├── ControlBar/ # play, pause, step, reset, velocidade
|
||||||
|
│ │ └── ControlBar.tsx
|
||||||
|
│ ├── GanttChart/ # diagrama de Gantt
|
||||||
|
│ │ ├── GanttChart.tsx
|
||||||
|
│ │ ├── GanttRow.tsx
|
||||||
|
│ │ ├── GanttCell.tsx
|
||||||
|
│ │ └── GanttLegend.tsx
|
||||||
|
│ ├── MetricsPanel/ # tabela + gráficos
|
||||||
|
│ │ ├── MetricsTable.tsx
|
||||||
|
│ │ ├── MetricsChart.tsx
|
||||||
|
│ │ └── GlobalMetrics.tsx
|
||||||
|
│ └── shared/ # botões, badges, tooltips, modais
|
||||||
|
│
|
||||||
|
├── hooks/
|
||||||
|
│ ├── useSimulation.ts # loop de simulação com requestAnimationFrame
|
||||||
|
│ ├── useLocalStorage.ts
|
||||||
|
│ └── useExport.ts
|
||||||
|
│
|
||||||
|
├── App.tsx
|
||||||
|
└── main.tsx
|
||||||
|
```
|
||||||
|
|
||||||
|
### 7.3 Fluxo de Dados
|
||||||
|
|
||||||
|
```
|
||||||
|
[ProcessForm] ──create/edit──► [processStore]
|
||||||
|
│
|
||||||
|
[AlgorithmSelector] ──config──► [simulationStore]
|
||||||
|
│
|
||||||
|
[SimulationEngine]
|
||||||
|
┌──────┴──────┐
|
||||||
|
step() runAll()
|
||||||
|
└──────┬──────┘
|
||||||
|
SimTick[]
|
||||||
|
│
|
||||||
|
┌─────────────────┼────────────────┐
|
||||||
|
[GanttChart] [ControlBar] [MetricsPanel]
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 8. Motor de Simulação (`SimulationEngine`)
|
||||||
|
|
||||||
|
### 8.1 Interface Pública
|
||||||
|
|
||||||
|
```typescript
|
||||||
|
class SimulationEngine {
|
||||||
|
constructor(processes: Process[], config: SchedulerConfig);
|
||||||
|
|
||||||
|
// Avança 1 tick; retorna o snapshot daquele tick
|
||||||
|
step(): SimTick;
|
||||||
|
|
||||||
|
// Executa todos os ticks até o fim; retorna array completo
|
||||||
|
runAll(): SimTick[];
|
||||||
|
|
||||||
|
// Verdadeiro se todos os processos estão Terminated
|
||||||
|
get isFinished(): boolean;
|
||||||
|
|
||||||
|
// Tick atual
|
||||||
|
get currentTick(): number;
|
||||||
|
|
||||||
|
// Estado atual de todos os processos
|
||||||
|
get runtimeStates(): ProcessRuntime[];
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
### 8.2 Loop Principal (pseudocódigo)
|
||||||
|
|
||||||
|
```
|
||||||
|
function step():
|
||||||
|
tick++
|
||||||
|
|
||||||
|
// 1. Verificar chegadas de novos processos
|
||||||
|
for each process where arrivalTime == tick:
|
||||||
|
transitionTo(process, "Ready")
|
||||||
|
addToReadyQueue(process)
|
||||||
|
|
||||||
|
// 2. Aging (se habilitado)
|
||||||
|
if agingEnabled and tick % agingInterval == 0:
|
||||||
|
for each process in readyQueue:
|
||||||
|
process.priority = max(1, process.priority - 1)
|
||||||
|
|
||||||
|
// 3. Verificar fim de I/O
|
||||||
|
for each process in ioQueue:
|
||||||
|
process.remainingBurst--
|
||||||
|
if process.remainingBurst == 0:
|
||||||
|
advanceBurst(process)
|
||||||
|
if hasMoreBursts(process):
|
||||||
|
transitionTo(process, "Ready")
|
||||||
|
addToReadyQueue(process)
|
||||||
|
else:
|
||||||
|
transitionTo(process, "Terminated")
|
||||||
|
process.finishTick = tick
|
||||||
|
|
||||||
|
// 4. Verificar fim do burst CPU atual
|
||||||
|
if cpuProcess != null:
|
||||||
|
cpuProcess.remainingBurst--
|
||||||
|
cpuProcess.cpuTime++
|
||||||
|
if cpuProcess.remainingBurst == 0:
|
||||||
|
advanceBurst(cpuProcess)
|
||||||
|
if hasIoBurst(cpuProcess):
|
||||||
|
transitionTo(cpuProcess, "Waiting")
|
||||||
|
addToIoQueue(cpuProcess)
|
||||||
|
cpuProcess = null
|
||||||
|
else if hasMoreCpuBurst(cpuProcess):
|
||||||
|
// volta pra ready (ex: após I/O futuro)
|
||||||
|
else:
|
||||||
|
transitionTo(cpuProcess, "Terminated")
|
||||||
|
cpuProcess = null
|
||||||
|
|
||||||
|
// 5. Verificar preempção (algoritmos preemptivos)
|
||||||
|
if isPreemptive and cpuProcess != null:
|
||||||
|
candidate = algorithm.selectFromReady(readyQueue)
|
||||||
|
if shouldPreempt(candidate, cpuProcess):
|
||||||
|
preempt(cpuProcess)
|
||||||
|
cpuProcess = candidate
|
||||||
|
|
||||||
|
// 6. Selecionar próximo processo (se CPU livre)
|
||||||
|
if cpuProcess == null and readyQueue.length > 0:
|
||||||
|
cpuProcess = algorithm.selectFromReady(readyQueue)
|
||||||
|
if cpuProcess.startTick == null:
|
||||||
|
cpuProcess.startTick = tick
|
||||||
|
transitionTo(cpuProcess, "Running")
|
||||||
|
|
||||||
|
// 7. Acumular waiting time
|
||||||
|
for each process in readyQueue:
|
||||||
|
process.waitingTime++
|
||||||
|
|
||||||
|
return snapshot()
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 9. Interface do Usuário
|
||||||
|
|
||||||
|
### 9.1 Layout Geral (Desktop)
|
||||||
|
|
||||||
|
```
|
||||||
|
┌─────────────────────────────────────────────────────────────────────┐
|
||||||
|
│ HEADER: título, botão de preset, import/export │
|
||||||
|
├──────────────┬──────────────────────────────────────────────────────┤
|
||||||
|
│ │ │
|
||||||
|
│ ESQUERDA │ CENTRO/DIREITA │
|
||||||
|
│ (320px) │ │
|
||||||
|
│ │ ┌─────────────────────────────────────────────────┐ │
|
||||||
|
│ [Processos] │ │ BARRA DE CONTROLE (play/pause/step/reset/vel.) │ │
|
||||||
|
│ + lista │ └─────────────────────────────────────────────────┘ │
|
||||||
|
│ + formulário│ │
|
||||||
|
│ │ ┌─────────────────────────────────────────────────┐ │
|
||||||
|
│ ────────── │ │ GANTT CHART (scroll horizontal) │ │
|
||||||
|
│ │ │ Tick: 00000000000001111111111122222222222233... │ │
|
||||||
|
│ [Algoritmo] │ │ P1: ██████░░░░░░██████░░░░░█████ │ │
|
||||||
|
│ + parâmetros│ │ P2: ░░░░░░██████░░░░░░████░░░░░ │ │
|
||||||
|
│ │ └─────────────────────────────────────────────────┘ │
|
||||||
|
│ │ │
|
||||||
|
│ │ ┌─────────────────────────────────────────────────┐ │
|
||||||
|
│ │ │ MÉTRICAS (tabela por processo + gráficos) │ │
|
||||||
|
│ │ └─────────────────────────────────────────────────┘ │
|
||||||
|
└──────────────┴──────────────────────────────────────────────────────┘
|
||||||
|
```
|
||||||
|
|
||||||
|
### 9.2 Cores de Estado no Gantt
|
||||||
|
|
||||||
|
| Estado | Cor | Token CSS |
|
||||||
|
|--------|-----|-----------|
|
||||||
|
| New | Cinza escuro | `--state-new` |
|
||||||
|
| Ready | Amarelo âmbar | `--state-ready` |
|
||||||
|
| Running | Verde brilhante | `--state-running` |
|
||||||
|
| Waiting (I/O) | Azul ciano | `--state-waiting` |
|
||||||
|
| Terminated | Cinza claro | `--state-terminated` |
|
||||||
|
| Context Switch | Vermelho/laranja | `--state-ctx-switch` |
|
||||||
|
|
||||||
|
### 9.3 Formulário de Processo
|
||||||
|
|
||||||
|
Campos:
|
||||||
|
- **Nome** (text, max 8 chars)
|
||||||
|
- **Arrival Time** (number, ≥ 0)
|
||||||
|
- **Priority** (1–10)
|
||||||
|
- **Cor** (color picker)
|
||||||
|
- **Bursts** — editor visual de bursts com botões +/− por segmento
|
||||||
|
- Tipo: `CPU` | `I/O`
|
||||||
|
- Duração (number, ≥ 1)
|
||||||
|
- Validação: deve iniciar com CPU, alternar CPU/IO
|
||||||
|
|
||||||
|
### 9.4 Painel de Algoritmo
|
||||||
|
|
||||||
|
Exibe:
|
||||||
|
- Dropdown de seleção de algoritmo
|
||||||
|
- Campos condicionais:
|
||||||
|
- RR → `quantum`
|
||||||
|
- Priority → `preemptive toggle`, `aging toggle + interval`
|
||||||
|
- Multilevel → configuração de filas
|
||||||
|
- Context switch time (sempre)
|
||||||
|
- Tooltip explicativo por algoritmo
|
||||||
|
|
||||||
|
### 9.5 Barra de Controle
|
||||||
|
|
||||||
|
```
|
||||||
|
[⏮ Reset] [⏭ Step] [▶ Play / ⏸ Pause] [Tick: 0042] [Velocidade: 1×▾]
|
||||||
|
```
|
||||||
|
|
||||||
|
### 9.6 Painel de Métricas (após simulação)
|
||||||
|
|
||||||
|
**Tab 1 — Por Processo:**
|
||||||
|
|
||||||
|
Tabela com colunas:
|
||||||
|
`Processo | Arrival | Start | Finish | Response | Turnaround | Waiting | CPU Time | I/O Time | CPU% | Bound`
|
||||||
|
|
||||||
|
**Tab 2 — Globais:**
|
||||||
|
|
||||||
|
Cards com:
|
||||||
|
- Avg Response Time
|
||||||
|
- Avg Turnaround Time
|
||||||
|
- Avg Waiting Time
|
||||||
|
- CPU Throughput
|
||||||
|
- CPU Utilization %
|
||||||
|
- Total Simulation Time
|
||||||
|
|
||||||
|
**Tab 3 — Gráfico:**
|
||||||
|
|
||||||
|
Gráfico de barras agrupadas por processo:
|
||||||
|
- Barras: Waiting Time, CPU Time, I/O Time (empilhadas para turnaround)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 10. Cenários Pré-definidos (Presets)
|
||||||
|
|
||||||
|
| Nome | Descrição | Algoritmo sugerido |
|
||||||
|
|------|-----------|-------------------|
|
||||||
|
| `classic_fcfs` | 4 processos simples, sem I/O | FCFS |
|
||||||
|
| `convoy_effect` | Demonstra o efeito de comboio do FCFS | FCFS vs SJF |
|
||||||
|
| `rr_demo` | 5 processos com quantum 3 | Round Robin |
|
||||||
|
| `starvation` | Prioridades que causam starvation | Priority NP |
|
||||||
|
| `aging_fix` | Mesmo cenário, com aging ativo | Priority P + Aging |
|
||||||
|
| `io_heavy` | Processos I/O Bound vs CPU Bound misturados | SRTF |
|
||||||
|
| `multilevel_demo` | Demonstra MLQ | Multilevel |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 11. Requisitos Não-Funcionais
|
||||||
|
|
||||||
|
| RNF | Requisito |
|
||||||
|
|-----|-----------|
|
||||||
|
| RNF-01 | Desempenho: simulações com até 16 processos e 1000 ticks sem travamento |
|
||||||
|
| RNF-02 | Responsividade: layout funcional em telas ≥ 768px |
|
||||||
|
| RNF-03 | Acessibilidade: ARIA labels nos controles principais, contraste WCAG AA |
|
||||||
|
| RNF-04 | Offline-first: 100% funcional sem internet após build |
|
||||||
|
| RNF-05 | Build size < 500 KB gzipped |
|
||||||
|
| RNF-06 | Suporte a Chrome 120+, Firefox 120+, Safari 17+ |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 12. Plano de Implementação (Fases)
|
||||||
|
|
||||||
|
### Fase 1 — Core Engine (sem UI) — *~2 dias*
|
||||||
|
- [ ] Definir todos os tipos em `core/types.ts`
|
||||||
|
- [ ] Implementar `SimulationEngine` com suporte a FCFS
|
||||||
|
- [ ] Testes unitários: FCFS, estados de transição, métricas
|
||||||
|
- [ ] Implementar SJF NP e RR com testes
|
||||||
|
- [ ] Implementar Priority NP/P com aging e testes
|
||||||
|
- [ ] Implementar SRTF e HRRN com testes
|
||||||
|
|
||||||
|
### Fase 2 — Store & State Management — *~1 dia*
|
||||||
|
- [ ] Configurar Zustand stores
|
||||||
|
- [ ] Hook `useSimulation` com loop de animação
|
||||||
|
- [ ] Integração com localStorage
|
||||||
|
|
||||||
|
### Fase 3 — UI Base — *~2 dias*
|
||||||
|
- [ ] Layout geral (sidebar + área principal)
|
||||||
|
- [ ] `ProcessForm` e `ProcessList`
|
||||||
|
- [ ] `AlgorithmSelector` e `SchedulerConfig`
|
||||||
|
- [ ] `ControlBar`
|
||||||
|
|
||||||
|
### Fase 4 — Gantt Chart — *~2 dias*
|
||||||
|
- [ ] Renderização de células por tick e processo
|
||||||
|
- [ ] Auto-scroll horizontal
|
||||||
|
- [ ] Tooltip por célula
|
||||||
|
- [ ] Legenda de estados
|
||||||
|
|
||||||
|
### Fase 5 — Métricas e Gráficos — *~1 dia*
|
||||||
|
- [ ] Tabela de métricas por processo
|
||||||
|
- [ ] Cards de métricas globais
|
||||||
|
- [ ] Gráfico de barras com Recharts
|
||||||
|
- [ ] Export CSV
|
||||||
|
|
||||||
|
### Fase 6 — Polimento e Presets — *~1 dia*
|
||||||
|
- [ ] Presets prontos para carregar
|
||||||
|
- [ ] Gerador de processos aleatórios
|
||||||
|
- [ ] Import/export JSON
|
||||||
|
- [ ] Responsividade mobile (≥768px)
|
||||||
|
- [ ] Refinamento visual
|
||||||
|
|
||||||
|
**Total estimado: ~9 dias de trabalho focado**
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 13. Casos de Teste Funcionais
|
||||||
|
|
||||||
|
### CT-01: FCFS Básico
|
||||||
|
|
||||||
|
**Entrada:**
|
||||||
|
```
|
||||||
|
P1: arrival=0, bursts=[CPU:4]
|
||||||
|
P2: arrival=1, bursts=[CPU:3]
|
||||||
|
P3: arrival=2, bursts=[CPU:1]
|
||||||
|
```
|
||||||
|
|
||||||
|
**Esperado:**
|
||||||
|
```
|
||||||
|
Gantt: P1(0-4), P2(4-7), P3(7-8)
|
||||||
|
P1: response=0, turnaround=4, waiting=0
|
||||||
|
P2: response=3, turnaround=6, waiting=3
|
||||||
|
P3: response=5, turnaround=6, waiting=5
|
||||||
|
```
|
||||||
|
|
||||||
|
### CT-02: Round Robin (quantum=2)
|
||||||
|
|
||||||
|
**Entrada:**
|
||||||
|
```
|
||||||
|
P1: arrival=0, bursts=[CPU:5]
|
||||||
|
P2: arrival=0, bursts=[CPU:3]
|
||||||
|
P3: arrival=0, bursts=[CPU:1]
|
||||||
|
quantum=2
|
||||||
|
```
|
||||||
|
|
||||||
|
**Esperado:**
|
||||||
|
```
|
||||||
|
Gantt: P1(0-2), P2(2-4), P3(4-5), P1(5-7), P2(7-8), P1(8-9)
|
||||||
|
P1: response=0, turnaround=9, waiting=4
|
||||||
|
P2: response=2, turnaround=8, waiting=5
|
||||||
|
P3: response=4, turnaround=5, waiting=4
|
||||||
|
```
|
||||||
|
|
||||||
|
### CT-03: Classificação Bound
|
||||||
|
|
||||||
|
**Entrada:**
|
||||||
|
```
|
||||||
|
P1: bursts=[CPU:8, IO:1, CPU:1] → cpuRatio = 9/10 = 90% → CPU Bound
|
||||||
|
P2: bursts=[CPU:1, IO:8, CPU:1] → cpuRatio = 2/10 = 20% → I/O Bound
|
||||||
|
P3: bursts=[CPU:4, IO:2, CPU:4] → cpuRatio = 8/10 = 80% → CPU Bound
|
||||||
|
```
|
||||||
|
|
||||||
|
### CT-04: Preempção SRTF
|
||||||
|
|
||||||
|
**Entrada:**
|
||||||
|
```
|
||||||
|
P1: arrival=0, bursts=[CPU:8]
|
||||||
|
P2: arrival=1, bursts=[CPU:4]
|
||||||
|
quantum=∞ (SRTF)
|
||||||
|
```
|
||||||
|
|
||||||
|
**Esperado:**
|
||||||
|
```
|
||||||
|
P1 executa tick 0-1, P2 preempta no tick 1 (remaining=3<7), P2 termina tick 5,
|
||||||
|
P1 retoma e termina tick 12
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 14. Glossário
|
||||||
|
|
||||||
|
| Termo | Definição |
|
||||||
|
|-------|-----------|
|
||||||
|
| **Tick** | Unidade atômica de tempo na simulação (equivale a 1 unidade de tempo de CPU) |
|
||||||
|
| **Burst** | Segmento contínuo de execução (CPU ou I/O) |
|
||||||
|
| **Quantum** | Fatia máxima de CPU no Round Robin |
|
||||||
|
| **Context Switch** | Overhead ao trocar o processo em execução na CPU |
|
||||||
|
| **Starvation** | Processo que nunca recebe CPU por processos de maior prioridade sempre chegando |
|
||||||
|
| **Aging** | Mecanismo que aumenta gradualmente a prioridade de processos esperando há muito tempo |
|
||||||
|
| **Turnaround Time** | Tempo total desde a chegada até o término do processo |
|
||||||
|
| **Response Time** | Tempo entre a chegada e o primeiro uso de CPU |
|
||||||
|
| **Waiting Time** | Tempo total em que o processo ficou na fila Ready |
|
||||||
|
| **CPU Bound** | Processo que passa a maior parte do tempo usando CPU |
|
||||||
|
| **I/O Bound** | Processo que passa a maior parte do tempo aguardando I/O |
|
||||||
|
| **FCFS** | First Come, First Served — ordem de chegada |
|
||||||
|
| **SJF** | Shortest Job First — menor burst next |
|
||||||
|
| **SRTF** | Shortest Remaining Time First — SJF preemptivo |
|
||||||
|
| **RR** | Round Robin — revezamento com quantum |
|
||||||
|
| **HRRN** | Highest Response Ratio Next — balanceia tempo de espera e burst |
|
||||||
+13
@@ -0,0 +1,13 @@
|
|||||||
|
<!doctype html>
|
||||||
|
<html lang="pt-BR">
|
||||||
|
<head>
|
||||||
|
<meta charset="UTF-8" />
|
||||||
|
<link rel="icon" type="image/svg+xml" href="/vite.svg" />
|
||||||
|
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||||
|
<title>Process Scheduler Simulator</title>
|
||||||
|
</head>
|
||||||
|
<body class="bg-slate-900 text-slate-100 antialiased overflow-hidden selection:bg-blue-500/30">
|
||||||
|
<div id="root"></div>
|
||||||
|
<script type="module" src="/src/main.tsx"></script>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
Generated
+4563
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,50 @@
|
|||||||
|
{
|
||||||
|
"name": "pss",
|
||||||
|
"version": "1.0.0",
|
||||||
|
"description": "O Process Scheduler Simulator é uma ferramenta educacional interativa que roda inteiramente no navegador",
|
||||||
|
"main": "index.js",
|
||||||
|
"scripts": {
|
||||||
|
"dev": "vite",
|
||||||
|
"build": "tsc -b && vite build",
|
||||||
|
"preview": "vite preview",
|
||||||
|
"test": "vitest run",
|
||||||
|
"test:watch": "vitest",
|
||||||
|
"test:coverage": "vitest run --coverage"
|
||||||
|
},
|
||||||
|
"dependencies": {
|
||||||
|
"clsx": "^2.1.1",
|
||||||
|
"lucide-react": "^0.577.0",
|
||||||
|
"react": "^18.3.1",
|
||||||
|
"react-dom": "^18.3.1",
|
||||||
|
"tailwind-merge": "^3.5.0",
|
||||||
|
"zustand": "^5.0.12"
|
||||||
|
},
|
||||||
|
"devDependencies": {
|
||||||
|
"@tailwindcss/vite": "^4.2.2",
|
||||||
|
"@testing-library/jest-dom": "^6.9.1",
|
||||||
|
"@testing-library/react": "^16.3.2",
|
||||||
|
"@testing-library/user-event": "^14.6.1",
|
||||||
|
"@types/node": "^25.5.0",
|
||||||
|
"@types/react": "^18.3.1",
|
||||||
|
"@types/react-dom": "^18.3.1",
|
||||||
|
"@vitejs/plugin-react": "^4.3.4",
|
||||||
|
"@vitest/coverage-v8": "^3.0.9",
|
||||||
|
"jsdom": "^29.0.0",
|
||||||
|
"tailwindcss": "^4.2.2",
|
||||||
|
"typescript": "~5.6.2",
|
||||||
|
"vite": "^6.2.2",
|
||||||
|
"vitest": "^3.0.9"
|
||||||
|
},
|
||||||
|
"repository": {
|
||||||
|
"type": "git",
|
||||||
|
"url": "git+https://github.com/lucasrguerra/pss.git"
|
||||||
|
},
|
||||||
|
"keywords": [],
|
||||||
|
"author": "Lucas Rayan Guerra",
|
||||||
|
"license": "ISC",
|
||||||
|
"type": "commonjs",
|
||||||
|
"bugs": {
|
||||||
|
"url": "https://github.com/lucasrguerra/pss/issues"
|
||||||
|
},
|
||||||
|
"homepage": "https://github.com/lucasrguerra/pss#readme"
|
||||||
|
}
|
||||||
@@ -0,0 +1,9 @@
|
|||||||
|
import AppLayout from './components/Layout/AppLayout';
|
||||||
|
|
||||||
|
function App() {
|
||||||
|
return (
|
||||||
|
<AppLayout />
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
export default App;
|
||||||
@@ -0,0 +1,167 @@
|
|||||||
|
import {
|
||||||
|
SkipBack, StepForward, Play, Pause, RotateCcw
|
||||||
|
} from 'lucide-react';
|
||||||
|
import { useProcessStore } from '../../store/processStore';
|
||||||
|
import { useSimulationStore, type SimStatus } from '../../store/simulationStore';
|
||||||
|
import { useUiStore, SPEED_OPTIONS } from '../../store/uiStore';
|
||||||
|
import IconButton from '../shared/IconButton';
|
||||||
|
|
||||||
|
const SPEED_LABELS: Record<number, string> = {
|
||||||
|
0.25: '0.25×',
|
||||||
|
0.5: '0.5×',
|
||||||
|
1: '1×',
|
||||||
|
2: '2×',
|
||||||
|
4: '4×',
|
||||||
|
};
|
||||||
|
|
||||||
|
const statusLabel: Record<SimStatus, string> = {
|
||||||
|
idle: 'Pronto',
|
||||||
|
paused: 'Pausado',
|
||||||
|
running: 'Executando',
|
||||||
|
finished: 'Concluído',
|
||||||
|
};
|
||||||
|
|
||||||
|
const statusDotClass: Record<SimStatus, string> = {
|
||||||
|
idle: 'bg-slate-500',
|
||||||
|
paused: 'bg-amber-400',
|
||||||
|
running: 'bg-emerald-400 animate-pulse',
|
||||||
|
finished: 'bg-blue-400',
|
||||||
|
};
|
||||||
|
|
||||||
|
const ControlBar = () => {
|
||||||
|
const processes = useProcessStore(s => s.processes);
|
||||||
|
const config = useProcessStore(s => s.config);
|
||||||
|
|
||||||
|
const status = useSimulationStore(s => s.status);
|
||||||
|
const ticks = useSimulationStore(s => s.ticks);
|
||||||
|
const { init, stepOnce, play, pause, reset } = useSimulationStore();
|
||||||
|
|
||||||
|
const speed = useUiStore(s => s.speed);
|
||||||
|
const setSpeed = useUiStore(s => s.setSpeed);
|
||||||
|
|
||||||
|
const currentTick = ticks.length;
|
||||||
|
const isIdle = status === 'idle';
|
||||||
|
const isRunning = status === 'running';
|
||||||
|
const isFinished = status === 'finished';
|
||||||
|
const canPlay = (status === 'paused' || status === 'idle') && !isFinished && processes.length > 0;
|
||||||
|
|
||||||
|
const handlePlay = () => {
|
||||||
|
if (isIdle) {
|
||||||
|
init(processes, config);
|
||||||
|
}
|
||||||
|
play();
|
||||||
|
};
|
||||||
|
|
||||||
|
const handleStep = () => {
|
||||||
|
if (isIdle) {
|
||||||
|
init(processes, config);
|
||||||
|
}
|
||||||
|
stepOnce();
|
||||||
|
};
|
||||||
|
|
||||||
|
const handleReset = () => {
|
||||||
|
if (isIdle) return;
|
||||||
|
reset();
|
||||||
|
};
|
||||||
|
|
||||||
|
return (
|
||||||
|
<div
|
||||||
|
className="h-16 flex items-center px-5 gap-3 bg-slate-800 border-b border-slate-700 shadow-sm"
|
||||||
|
role="toolbar"
|
||||||
|
aria-label="Controles da simulação"
|
||||||
|
>
|
||||||
|
{/* Left group: simulation controls */}
|
||||||
|
<div className="flex items-center gap-1.5">
|
||||||
|
{/* Reset */}
|
||||||
|
<IconButton
|
||||||
|
label="Reset"
|
||||||
|
variant="ghost"
|
||||||
|
onClick={handleReset}
|
||||||
|
disabled={isIdle}
|
||||||
|
data-testid="btn-reset"
|
||||||
|
>
|
||||||
|
<RotateCcw size={16} />
|
||||||
|
</IconButton>
|
||||||
|
|
||||||
|
{/* Step */}
|
||||||
|
<IconButton
|
||||||
|
label="Avançar 1 tick (Step)"
|
||||||
|
variant="default"
|
||||||
|
onClick={handleStep}
|
||||||
|
disabled={isFinished || processes.length === 0 || isRunning}
|
||||||
|
data-testid="btn-step"
|
||||||
|
>
|
||||||
|
<StepForward size={18} />
|
||||||
|
</IconButton>
|
||||||
|
|
||||||
|
{/* Play / Pause */}
|
||||||
|
{isRunning ? (
|
||||||
|
<IconButton
|
||||||
|
label="Pausar simulação"
|
||||||
|
variant="primary"
|
||||||
|
onClick={pause}
|
||||||
|
data-testid="btn-pause"
|
||||||
|
>
|
||||||
|
<Pause size={18} />
|
||||||
|
</IconButton>
|
||||||
|
) : (
|
||||||
|
<IconButton
|
||||||
|
label="Iniciar / Retomar simulação"
|
||||||
|
variant="primary"
|
||||||
|
onClick={handlePlay}
|
||||||
|
disabled={!canPlay && !isRunning}
|
||||||
|
data-testid="btn-play"
|
||||||
|
>
|
||||||
|
<Play size={18} />
|
||||||
|
</IconButton>
|
||||||
|
)}
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Divider */}
|
||||||
|
<div className="h-6 w-px bg-slate-700 mx-1" aria-hidden="true" />
|
||||||
|
|
||||||
|
{/* Tick display */}
|
||||||
|
<div
|
||||||
|
className="flex items-center gap-2 px-3 py-1 rounded-md bg-slate-900 border border-slate-700"
|
||||||
|
aria-live="polite"
|
||||||
|
aria-label={`Tick atual: ${currentTick}`}
|
||||||
|
>
|
||||||
|
<span className="text-[10px] text-slate-500 uppercase tracking-wide font-medium">Tick</span>
|
||||||
|
<span
|
||||||
|
className="font-mono font-bold text-blue-300 text-sm min-w-[3ch] text-right"
|
||||||
|
data-testid="tick-display"
|
||||||
|
>
|
||||||
|
{String(currentTick).padStart(4, '0')}
|
||||||
|
</span>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Status badge */}
|
||||||
|
<div className="flex items-center gap-1.5">
|
||||||
|
<span className={`h-2 w-2 rounded-full ${statusDotClass[status]}`} aria-hidden="true" />
|
||||||
|
<span className="text-xs text-slate-400">{statusLabel[status]}</span>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Right group: speed selector */}
|
||||||
|
<div className="ml-auto flex items-center gap-2">
|
||||||
|
<SkipBack size={14} className="text-slate-500" aria-hidden="true" />
|
||||||
|
<label htmlFor="speed-select" className="text-xs text-slate-400 sr-only">
|
||||||
|
Velocidade
|
||||||
|
</label>
|
||||||
|
<select
|
||||||
|
id="speed-select"
|
||||||
|
value={speed}
|
||||||
|
onChange={e => setSpeed(Number(e.target.value))}
|
||||||
|
className="rounded-md bg-slate-700 border border-slate-600 text-slate-200 text-xs px-2 py-1 focus:outline-none focus:ring-1 focus:ring-blue-500 cursor-pointer"
|
||||||
|
aria-label="Velocidade de simulação"
|
||||||
|
data-testid="speed-select"
|
||||||
|
>
|
||||||
|
{SPEED_OPTIONS.map(s => (
|
||||||
|
<option key={s} value={s}>{SPEED_LABELS[s]}</option>
|
||||||
|
))}
|
||||||
|
</select>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default ControlBar;
|
||||||
@@ -0,0 +1,13 @@
|
|||||||
|
import Sidebar from './Sidebar';
|
||||||
|
import MainArea from './MainArea';
|
||||||
|
|
||||||
|
const AppLayout = () => {
|
||||||
|
return (
|
||||||
|
<div className="flex h-screen w-full bg-slate-900 text-slate-200 overflow-hidden font-sans">
|
||||||
|
<Sidebar />
|
||||||
|
<MainArea />
|
||||||
|
</div>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default AppLayout;
|
||||||
@@ -0,0 +1,25 @@
|
|||||||
|
import ControlBar from '../ControlBar/ControlBar';
|
||||||
|
|
||||||
|
const MainArea = () => {
|
||||||
|
return (
|
||||||
|
<main className="flex-1 flex flex-col h-full bg-slate-900 overflow-hidden relative">
|
||||||
|
<div className="flex-1 flex flex-col">
|
||||||
|
<ControlBar />
|
||||||
|
|
||||||
|
{/* Placeholder for GanttChart — Phase 4 */}
|
||||||
|
<div className="border-b border-slate-800 h-80 flex items-center justify-center text-slate-600 bg-slate-900/50 text-sm">
|
||||||
|
[ Gantt Chart — Fase 4 ]
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Placeholder for MetricsPanel — Phase 5 */}
|
||||||
|
<div className="flex-1 flex items-center justify-center text-slate-600 bg-slate-950 p-6">
|
||||||
|
<div className="w-full h-full border border-dashed border-slate-700 rounded-xl flex items-center justify-center text-sm">
|
||||||
|
[ Metrics Panel — Fase 5 ]
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
</main>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default MainArea;
|
||||||
@@ -0,0 +1,27 @@
|
|||||||
|
import ProcessPanel from '../ProcessPanel/ProcessPanel';
|
||||||
|
import SchedulerPanel from '../SchedulerPanel/SchedulerPanel';
|
||||||
|
|
||||||
|
const Sidebar = () => {
|
||||||
|
return (
|
||||||
|
<aside className="w-80 min-w-[20rem] h-full bg-slate-800 border-r border-slate-700 flex flex-col shadow-xl z-20">
|
||||||
|
<div className="h-16 flex items-center px-6 border-b border-slate-700 bg-slate-800/80 backdrop-blur-sm">
|
||||||
|
<h1 className="text-xl font-bold bg-gradient-to-r from-blue-400 to-indigo-400 bg-clip-text text-transparent truncate">
|
||||||
|
Process Simulator
|
||||||
|
</h1>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<div className="flex-1 overflow-y-auto overflow-x-hidden p-4 space-y-6 scrollbar-hide">
|
||||||
|
<ProcessPanel />
|
||||||
|
<div className="border-t border-slate-700 pt-4">
|
||||||
|
<SchedulerPanel />
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<div className="h-12 border-t border-slate-700 flex items-center justify-center text-xs text-slate-500">
|
||||||
|
PSS v1.0
|
||||||
|
</div>
|
||||||
|
</aside>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default Sidebar;
|
||||||
@@ -0,0 +1,73 @@
|
|||||||
|
import { Pencil, Trash2 } from 'lucide-react';
|
||||||
|
import type { Process } from '@core/types';
|
||||||
|
import IconButton from '../shared/IconButton';
|
||||||
|
import Badge from '../shared/Badge';
|
||||||
|
import { classifyBound } from '../shared/processUtils';
|
||||||
|
|
||||||
|
interface ProcessCardProps {
|
||||||
|
process: Process;
|
||||||
|
onEdit: (process: Process) => void;
|
||||||
|
onRemove: (id: string) => void;
|
||||||
|
}
|
||||||
|
|
||||||
|
const ProcessCard = ({ process, onEdit, onRemove }: ProcessCardProps) => {
|
||||||
|
const bound = classifyBound(process.bursts);
|
||||||
|
const totalCpu = process.bursts.filter(b => b.type === 'cpu').reduce((a, b) => a + b.duration, 0);
|
||||||
|
const totalIo = process.bursts.filter(b => b.type === 'io').reduce((a, b) => a + b.duration, 0);
|
||||||
|
|
||||||
|
const boundVariant = bound === 'CPU Bound' ? 'cpu' : bound === 'I/O Bound' ? 'io' : 'balanced';
|
||||||
|
|
||||||
|
return (
|
||||||
|
<div
|
||||||
|
className="group relative flex items-start gap-3 rounded-lg bg-slate-800 border border-slate-700 p-3 hover:border-slate-500 transition-colors"
|
||||||
|
data-testid={`process-card-${process.id}`}
|
||||||
|
>
|
||||||
|
{/* Color indicator */}
|
||||||
|
<div
|
||||||
|
className="mt-0.5 h-8 w-1.5 rounded-full flex-shrink-0"
|
||||||
|
style={{ backgroundColor: process.color }}
|
||||||
|
aria-hidden="true"
|
||||||
|
/>
|
||||||
|
|
||||||
|
{/* Info */}
|
||||||
|
<div className="flex-1 min-w-0">
|
||||||
|
<div className="flex items-center gap-2 mb-1">
|
||||||
|
<span className="font-semibold text-sm text-slate-100 truncate">{process.name}</span>
|
||||||
|
<Badge variant={boundVariant}>{bound}</Badge>
|
||||||
|
</div>
|
||||||
|
<div className="flex flex-wrap gap-x-3 gap-y-0.5 text-[11px] text-slate-400">
|
||||||
|
<span>Arrival: <span className="text-slate-300 font-medium">{process.arrivalTime}</span></span>
|
||||||
|
<span>Priority: <span className="text-slate-300 font-medium">{process.priority}</span></span>
|
||||||
|
<span>CPU: <span className="text-emerald-400 font-medium">{totalCpu}</span></span>
|
||||||
|
{totalIo > 0 && (
|
||||||
|
<span>I/O: <span className="text-cyan-400 font-medium">{totalIo}</span></span>
|
||||||
|
)}
|
||||||
|
<span>Bursts: <span className="text-slate-300 font-medium">{process.bursts.length}</span></span>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Actions */}
|
||||||
|
<div className="flex gap-1 opacity-0 group-hover:opacity-100 transition-opacity flex-shrink-0">
|
||||||
|
<IconButton
|
||||||
|
size="sm"
|
||||||
|
variant="ghost"
|
||||||
|
label={`Editar ${process.name}`}
|
||||||
|
onClick={() => onEdit(process)}
|
||||||
|
>
|
||||||
|
<Pencil size={13} />
|
||||||
|
</IconButton>
|
||||||
|
<IconButton
|
||||||
|
size="sm"
|
||||||
|
variant="ghost"
|
||||||
|
label={`Remover ${process.name}`}
|
||||||
|
onClick={() => onRemove(process.id)}
|
||||||
|
className="hover:text-red-400 hover:bg-red-900/20"
|
||||||
|
>
|
||||||
|
<Trash2 size={13} />
|
||||||
|
</IconButton>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default ProcessCard;
|
||||||
@@ -0,0 +1,256 @@
|
|||||||
|
import { useState, useEffect } from 'react';
|
||||||
|
import { Plus, Minus, Check, X } from 'lucide-react';
|
||||||
|
import type { Process, BurstSegment } from '@core/types';
|
||||||
|
import { useProcessStore } from '../../store/processStore';
|
||||||
|
import IconButton from '../shared/IconButton';
|
||||||
|
import { generateId, nextColor } from '../shared/processUtils';
|
||||||
|
|
||||||
|
interface ProcessFormProps {
|
||||||
|
/** If provided, the form edits this process; otherwise creates a new one. */
|
||||||
|
editingProcess?: Process | null;
|
||||||
|
onClose: () => void;
|
||||||
|
}
|
||||||
|
|
||||||
|
const DEFAULT_BURSTS: BurstSegment[] = [{ type: 'cpu', duration: 4 }];
|
||||||
|
|
||||||
|
const ProcessForm = ({ editingProcess, onClose }: ProcessFormProps) => {
|
||||||
|
const addProcess = useProcessStore(s => s.addProcess);
|
||||||
|
const updateProcess = useProcessStore(s => s.updateProcess);
|
||||||
|
|
||||||
|
const isEditing = !!editingProcess;
|
||||||
|
|
||||||
|
const [name, setName] = useState('');
|
||||||
|
const [arrivalTime, setArrivalTime] = useState(0);
|
||||||
|
const [priority, setPriority] = useState(5);
|
||||||
|
const [color, setColor] = useState(nextColor);
|
||||||
|
const [bursts, setBursts] = useState<BurstSegment[]>(DEFAULT_BURSTS);
|
||||||
|
const [errors, setErrors] = useState<string[]>([]);
|
||||||
|
|
||||||
|
useEffect(() => {
|
||||||
|
if (editingProcess) {
|
||||||
|
setName(editingProcess.name);
|
||||||
|
setArrivalTime(editingProcess.arrivalTime);
|
||||||
|
setPriority(editingProcess.priority);
|
||||||
|
setColor(editingProcess.color);
|
||||||
|
setBursts([...editingProcess.bursts.map(b => ({ ...b }))]);
|
||||||
|
} else {
|
||||||
|
setName('');
|
||||||
|
setArrivalTime(0);
|
||||||
|
setPriority(5);
|
||||||
|
setColor(nextColor());
|
||||||
|
setBursts([{ type: 'cpu', duration: 4 }]);
|
||||||
|
}
|
||||||
|
setErrors([]);
|
||||||
|
}, [editingProcess]);
|
||||||
|
|
||||||
|
// ---- Burst helpers ----
|
||||||
|
|
||||||
|
const updateBurstDuration = (index: number, value: number) => {
|
||||||
|
setBursts(prev => prev.map((b, i) => i === index ? { ...b, duration: Math.max(1, value) } : b));
|
||||||
|
};
|
||||||
|
|
||||||
|
const addBurst = () => {
|
||||||
|
// enforce alternating cpu/io pattern
|
||||||
|
const lastType = bursts[bursts.length - 1]?.type ?? 'io';
|
||||||
|
const nextType: BurstSegment['type'] = lastType === 'cpu' ? 'io' : 'cpu';
|
||||||
|
setBursts(prev => [...prev, { type: nextType, duration: 2 }]);
|
||||||
|
};
|
||||||
|
|
||||||
|
const removeBurst = (index: number) => {
|
||||||
|
if (bursts.length <= 1) return;
|
||||||
|
setBursts(prev => {
|
||||||
|
const next = prev.filter((_, i) => i !== index);
|
||||||
|
// Safe-guard: ensure it still starts (and ends) with cpu
|
||||||
|
return next;
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
// ---- Validation ----
|
||||||
|
|
||||||
|
const validate = (): boolean => {
|
||||||
|
const errs: string[] = [];
|
||||||
|
if (!name.trim()) errs.push('Nome é obrigatório');
|
||||||
|
if (name.trim().length > 8) errs.push('Nome deve ter no máximo 8 caracteres');
|
||||||
|
if (arrivalTime < 0) errs.push('Arrival Time deve ser ≥ 0');
|
||||||
|
if (priority < 1 || priority > 10) errs.push('Priority deve estar entre 1 e 10');
|
||||||
|
if (bursts.length === 0) errs.push('Deve haver ao menos 1 burst CPU');
|
||||||
|
if (bursts[0]?.type !== 'cpu') errs.push('O primeiro burst deve ser CPU');
|
||||||
|
if (bursts.at(-1)?.type !== 'cpu') errs.push('O último burst deve ser CPU');
|
||||||
|
bursts.forEach((b, i) => {
|
||||||
|
if (b.duration < 1) errs.push(`Burst ${i + 1}: duração deve ser ≥ 1`);
|
||||||
|
if (i > 0 && bursts[i - 1].type === b.type) errs.push(`Bursts ${i} e ${i + 1} não podem ser do mesmo tipo (alternar CPU/IO)`);
|
||||||
|
});
|
||||||
|
setErrors(errs);
|
||||||
|
return errs.length === 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
const handleSubmit = () => {
|
||||||
|
if (!validate()) return;
|
||||||
|
if (isEditing && editingProcess) {
|
||||||
|
updateProcess(editingProcess.id, { name: name.trim(), arrivalTime, priority, color, bursts });
|
||||||
|
} else {
|
||||||
|
const p: Process = {
|
||||||
|
id: generateId(),
|
||||||
|
name: name.trim(),
|
||||||
|
arrivalTime,
|
||||||
|
priority,
|
||||||
|
color,
|
||||||
|
bursts,
|
||||||
|
};
|
||||||
|
addProcess(p);
|
||||||
|
}
|
||||||
|
onClose();
|
||||||
|
};
|
||||||
|
|
||||||
|
const inputCls = 'w-full rounded-md bg-slate-700 border border-slate-600 text-slate-200 text-sm px-3 py-1.5 focus:outline-none focus:ring-1 focus:ring-blue-500';
|
||||||
|
const labelCls = 'block text-xs text-slate-400 mb-1';
|
||||||
|
|
||||||
|
return (
|
||||||
|
<div className="bg-slate-800/60 rounded-xl border border-slate-600 shadow-xl p-4 space-y-4" data-testid="process-form">
|
||||||
|
<div className="flex items-center justify-between">
|
||||||
|
<h3 className="text-sm font-semibold text-slate-200">
|
||||||
|
{isEditing ? 'Editar Processo' : 'Novo Processo'}
|
||||||
|
</h3>
|
||||||
|
<IconButton size="sm" variant="ghost" label="Fechar" onClick={onClose}>
|
||||||
|
<X size={14} />
|
||||||
|
</IconButton>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Basic fields */}
|
||||||
|
<div className="grid grid-cols-2 gap-3">
|
||||||
|
<div className="col-span-2 flex gap-3">
|
||||||
|
{/* Name */}
|
||||||
|
<div className="flex-1">
|
||||||
|
<label className={labelCls} htmlFor="pf-name">Nome</label>
|
||||||
|
<input
|
||||||
|
id="pf-name"
|
||||||
|
type="text"
|
||||||
|
maxLength={8}
|
||||||
|
value={name}
|
||||||
|
onChange={e => setName(e.target.value)}
|
||||||
|
placeholder="P1"
|
||||||
|
className={inputCls}
|
||||||
|
aria-label="Nome do processo"
|
||||||
|
/>
|
||||||
|
</div>
|
||||||
|
{/* Color */}
|
||||||
|
<div>
|
||||||
|
<label className={labelCls} htmlFor="pf-color">Cor</label>
|
||||||
|
<input
|
||||||
|
id="pf-color"
|
||||||
|
type="color"
|
||||||
|
value={color}
|
||||||
|
onChange={e => setColor(e.target.value)}
|
||||||
|
className="h-[34px] w-12 rounded-md border border-slate-600 bg-slate-700 cursor-pointer"
|
||||||
|
aria-label="Cor do processo"
|
||||||
|
/>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Arrival */}
|
||||||
|
<div>
|
||||||
|
<label className={labelCls} htmlFor="pf-arrival">Arrival Time</label>
|
||||||
|
<input
|
||||||
|
id="pf-arrival"
|
||||||
|
type="number"
|
||||||
|
min={0}
|
||||||
|
value={arrivalTime}
|
||||||
|
onChange={e => setArrivalTime(Number(e.target.value))}
|
||||||
|
className={inputCls}
|
||||||
|
aria-label="Tempo de chegada"
|
||||||
|
/>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Priority */}
|
||||||
|
<div>
|
||||||
|
<label className={labelCls} htmlFor="pf-priority">Priority (1–10)</label>
|
||||||
|
<input
|
||||||
|
id="pf-priority"
|
||||||
|
type="number"
|
||||||
|
min={1}
|
||||||
|
max={10}
|
||||||
|
value={priority}
|
||||||
|
onChange={e => setPriority(Number(e.target.value))}
|
||||||
|
className={inputCls}
|
||||||
|
aria-label="Prioridade do processo"
|
||||||
|
/>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Bursts editor */}
|
||||||
|
<div>
|
||||||
|
<div className="flex items-center justify-between mb-2">
|
||||||
|
<label className="text-xs text-slate-400 font-medium">Bursts (CPU → I/O → CPU…)</label>
|
||||||
|
<IconButton size="sm" variant="ghost" label="Adicionar burst" onClick={addBurst}>
|
||||||
|
<Plus size={13} />
|
||||||
|
</IconButton>
|
||||||
|
</div>
|
||||||
|
<div className="space-y-1.5" data-testid="burst-list">
|
||||||
|
{bursts.map((burst, idx) => (
|
||||||
|
<div
|
||||||
|
key={idx}
|
||||||
|
className={`flex items-center gap-2 px-2 py-1.5 rounded-md border ${
|
||||||
|
burst.type === 'cpu'
|
||||||
|
? 'border-emerald-700/50 bg-emerald-900/20'
|
||||||
|
: 'border-cyan-700/50 bg-cyan-900/20'
|
||||||
|
}`}
|
||||||
|
>
|
||||||
|
<span className={`text-[10px] font-bold uppercase w-7 tracking-wider ${burst.type === 'cpu' ? 'text-emerald-400' : 'text-cyan-400'}`}>
|
||||||
|
{burst.type}
|
||||||
|
</span>
|
||||||
|
<input
|
||||||
|
type="number"
|
||||||
|
min={1}
|
||||||
|
value={burst.duration}
|
||||||
|
onChange={e => updateBurstDuration(idx, Number(e.target.value))}
|
||||||
|
className="w-full rounded bg-slate-700/60 border border-slate-600/50 text-slate-200 text-xs px-2 py-0.5 focus:outline-none focus:ring-1 focus:ring-blue-500"
|
||||||
|
aria-label={`Duração do burst ${idx + 1}`}
|
||||||
|
/>
|
||||||
|
<span className="text-[10px] text-slate-500">ticks</span>
|
||||||
|
<IconButton
|
||||||
|
size="sm"
|
||||||
|
variant="ghost"
|
||||||
|
label={`Remover burst ${idx + 1}`}
|
||||||
|
onClick={() => removeBurst(idx)}
|
||||||
|
disabled={bursts.length <= 1}
|
||||||
|
className="hover:text-red-400"
|
||||||
|
>
|
||||||
|
<Minus size={12} />
|
||||||
|
</IconButton>
|
||||||
|
</div>
|
||||||
|
))}
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Validation errors */}
|
||||||
|
{errors.length > 0 && (
|
||||||
|
<ul className="space-y-0.5" role="alert" aria-live="polite">
|
||||||
|
{errors.map((e, i) => (
|
||||||
|
<li key={i} className="text-[11px] text-red-400">{e}</li>
|
||||||
|
))}
|
||||||
|
</ul>
|
||||||
|
)}
|
||||||
|
|
||||||
|
{/* Actions */}
|
||||||
|
<div className="flex gap-2 pt-1">
|
||||||
|
<button
|
||||||
|
onClick={handleSubmit}
|
||||||
|
className="flex-1 flex items-center justify-center gap-1.5 bg-blue-600 hover:bg-blue-500 text-white text-sm font-medium py-1.5 rounded-lg transition-colors"
|
||||||
|
aria-label={isEditing ? 'Salvar processo' : 'Criar processo'}
|
||||||
|
>
|
||||||
|
<Check size={15} />
|
||||||
|
{isEditing ? 'Salvar' : 'Criar'}
|
||||||
|
</button>
|
||||||
|
<button
|
||||||
|
onClick={onClose}
|
||||||
|
className="px-4 bg-slate-700 hover:bg-slate-600 text-slate-300 text-sm rounded-lg transition-colors"
|
||||||
|
aria-label="Cancelar"
|
||||||
|
>
|
||||||
|
Cancelar
|
||||||
|
</button>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default ProcessForm;
|
||||||
@@ -0,0 +1,109 @@
|
|||||||
|
import { Plus, Shuffle, Trash2 } from 'lucide-react';
|
||||||
|
import type { Process } from '@core/types';
|
||||||
|
import { useProcessStore } from '../../store/processStore';
|
||||||
|
import ProcessCard from './ProcessCard';
|
||||||
|
import IconButton from '../shared/IconButton';
|
||||||
|
import { generateId, nextColor } from '../shared/processUtils';
|
||||||
|
|
||||||
|
interface ProcessListProps {
|
||||||
|
onEditProcess: (process: Process) => void;
|
||||||
|
onAddNew: () => void;
|
||||||
|
}
|
||||||
|
|
||||||
|
const MAX_PROCESSES = 16;
|
||||||
|
|
||||||
|
/** Generates a random process for quick testing */
|
||||||
|
function makeRandomProcess(index: number): Process {
|
||||||
|
const cpuDur = Math.floor(Math.random() * 6) + 1;
|
||||||
|
const ioDur = Math.floor(Math.random() * 5) + 1;
|
||||||
|
const hasBothBursts = Math.random() > 0.4;
|
||||||
|
return {
|
||||||
|
id: generateId(),
|
||||||
|
name: `P${index}`,
|
||||||
|
arrivalTime: Math.floor(Math.random() * 8),
|
||||||
|
priority: Math.floor(Math.random() * 10) + 1,
|
||||||
|
color: nextColor(),
|
||||||
|
bursts: hasBothBursts
|
||||||
|
? [{ type: 'cpu', duration: cpuDur }, { type: 'io', duration: ioDur }, { type: 'cpu', duration: Math.floor(Math.random() * 4) + 1 }]
|
||||||
|
: [{ type: 'cpu', duration: cpuDur }],
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
const ProcessList = ({ onEditProcess, onAddNew }: ProcessListProps) => {
|
||||||
|
const processes = useProcessStore(s => s.processes);
|
||||||
|
const removeProcess = useProcessStore(s => s.removeProcess);
|
||||||
|
const clearProcesses = useProcessStore(s => s.clearProcesses);
|
||||||
|
const addProcess = useProcessStore(s => s.addProcess);
|
||||||
|
|
||||||
|
const canAdd = processes.length < MAX_PROCESSES;
|
||||||
|
|
||||||
|
const handleRandomize = () => {
|
||||||
|
const p = makeRandomProcess(processes.length + 1);
|
||||||
|
addProcess(p);
|
||||||
|
};
|
||||||
|
|
||||||
|
return (
|
||||||
|
<div data-testid="process-list">
|
||||||
|
{/* List header */}
|
||||||
|
<div className="flex items-center justify-between mb-2">
|
||||||
|
<span className="text-xs text-slate-400">
|
||||||
|
{processes.length}/{MAX_PROCESSES} processos
|
||||||
|
</span>
|
||||||
|
<div className="flex gap-1">
|
||||||
|
<IconButton
|
||||||
|
size="sm"
|
||||||
|
variant="ghost"
|
||||||
|
label="Gerar processo aleatório"
|
||||||
|
onClick={handleRandomize}
|
||||||
|
disabled={!canAdd}
|
||||||
|
>
|
||||||
|
<Shuffle size={13} />
|
||||||
|
</IconButton>
|
||||||
|
<IconButton
|
||||||
|
size="sm"
|
||||||
|
variant="ghost"
|
||||||
|
label="Limpar todos os processos"
|
||||||
|
onClick={clearProcesses}
|
||||||
|
disabled={processes.length === 0}
|
||||||
|
className="hover:text-red-400 hover:bg-red-900/20"
|
||||||
|
>
|
||||||
|
<Trash2 size={13} />
|
||||||
|
</IconButton>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Cards */}
|
||||||
|
<div className="space-y-2 max-h-64 overflow-y-auto pr-0.5 scrollbar-hide">
|
||||||
|
{processes.length === 0 ? (
|
||||||
|
<div className="flex flex-col items-center justify-center gap-2 text-slate-500 text-sm py-8 border border-dashed border-slate-700 rounded-lg">
|
||||||
|
<span>Nenhum processo adicionado</span>
|
||||||
|
<span className="text-xs">Clique em + para criar</span>
|
||||||
|
</div>
|
||||||
|
) : (
|
||||||
|
processes.map(p => (
|
||||||
|
<ProcessCard
|
||||||
|
key={p.id}
|
||||||
|
process={p}
|
||||||
|
onEdit={onEditProcess}
|
||||||
|
onRemove={removeProcess}
|
||||||
|
/>
|
||||||
|
))
|
||||||
|
)}
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Add button */}
|
||||||
|
{canAdd && (
|
||||||
|
<button
|
||||||
|
onClick={onAddNew}
|
||||||
|
aria-label="Adicionar novo processo"
|
||||||
|
className="mt-2 w-full flex items-center justify-center gap-2 py-2 rounded-lg border border-dashed border-slate-600 text-slate-500 hover:border-blue-500 hover:text-blue-400 text-xs transition-colors"
|
||||||
|
>
|
||||||
|
<Plus size={14} />
|
||||||
|
Adicionar Processo
|
||||||
|
</button>
|
||||||
|
)}
|
||||||
|
</div>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default ProcessList;
|
||||||
@@ -0,0 +1,42 @@
|
|||||||
|
import { useState } from 'react';
|
||||||
|
import { ListTree } from 'lucide-react';
|
||||||
|
import type { Process } from '@core/types';
|
||||||
|
import ProcessList from './ProcessList';
|
||||||
|
import ProcessForm from './ProcessForm';
|
||||||
|
|
||||||
|
const ProcessPanel = () => {
|
||||||
|
const [editingProcess, setEditingProcess] = useState<Process | null>(null);
|
||||||
|
const [showForm, setShowForm] = useState(false);
|
||||||
|
|
||||||
|
const handleEditProcess = (process: Process) => {
|
||||||
|
setEditingProcess(process);
|
||||||
|
setShowForm(true);
|
||||||
|
};
|
||||||
|
|
||||||
|
const handleAddNew = () => {
|
||||||
|
setEditingProcess(null);
|
||||||
|
setShowForm(true);
|
||||||
|
};
|
||||||
|
|
||||||
|
const handleClose = () => {
|
||||||
|
setShowForm(false);
|
||||||
|
setEditingProcess(null);
|
||||||
|
};
|
||||||
|
|
||||||
|
return (
|
||||||
|
<section aria-label="Painel de Processos">
|
||||||
|
<div className="flex items-center gap-2 mb-3 text-slate-300">
|
||||||
|
<ListTree size={18} className="text-blue-400" />
|
||||||
|
<h2 className="font-semibold uppercase text-xs tracking-wider">Processos</h2>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{showForm ? (
|
||||||
|
<ProcessForm editingProcess={editingProcess} onClose={handleClose} />
|
||||||
|
) : (
|
||||||
|
<ProcessList onEditProcess={handleEditProcess} onAddNew={handleAddNew} />
|
||||||
|
)}
|
||||||
|
</section>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default ProcessPanel;
|
||||||
@@ -0,0 +1,44 @@
|
|||||||
|
import type { SchedulingAlgorithm } from '@core/types';
|
||||||
|
import { useProcessStore } from '../../store/processStore';
|
||||||
|
|
||||||
|
const ALGORITHM_OPTIONS: { value: SchedulingAlgorithm; label: string }[] = [
|
||||||
|
{ value: 'FCFS', label: 'FCFS — First Come First Served' },
|
||||||
|
{ value: 'SJF_NP', label: 'SJF — Shortest Job First (NP)' },
|
||||||
|
{ value: 'SJF_P', label: 'SRTF — Shortest Remaining Time (P)' },
|
||||||
|
{ value: 'RR', label: 'RR — Round Robin' },
|
||||||
|
{ value: 'PRIORITY_NP',label: 'Priority (Não-preemptivo)' },
|
||||||
|
{ value: 'PRIORITY_P', label: 'Priority (Preemptivo)' },
|
||||||
|
{ value: 'HRRN', label: 'HRRN — Highest Response Ratio Next' },
|
||||||
|
{ value: 'MULTILEVEL', label: 'Multilevel Queue' },
|
||||||
|
];
|
||||||
|
|
||||||
|
const AlgorithmSelector = () => {
|
||||||
|
const algorithm = useProcessStore(s => s.config.algorithm);
|
||||||
|
const setConfig = useProcessStore(s => s.setConfig);
|
||||||
|
|
||||||
|
return (
|
||||||
|
<div>
|
||||||
|
<label
|
||||||
|
htmlFor="algorithm-select"
|
||||||
|
className="block text-xs text-slate-400 mb-1"
|
||||||
|
>
|
||||||
|
Algoritmo
|
||||||
|
</label>
|
||||||
|
<select
|
||||||
|
id="algorithm-select"
|
||||||
|
value={algorithm}
|
||||||
|
onChange={e => setConfig({ algorithm: e.target.value as SchedulingAlgorithm })}
|
||||||
|
className="w-full rounded-md bg-slate-700 border border-slate-600 text-slate-200 text-sm px-3 py-1.5 focus:outline-none focus:ring-1 focus:ring-blue-500 cursor-pointer"
|
||||||
|
aria-label="Selecionar algoritmo de escalonamento"
|
||||||
|
>
|
||||||
|
{ALGORITHM_OPTIONS.map(opt => (
|
||||||
|
<option key={opt.value} value={opt.value}>
|
||||||
|
{opt.label}
|
||||||
|
</option>
|
||||||
|
))}
|
||||||
|
</select>
|
||||||
|
</div>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default AlgorithmSelector;
|
||||||
@@ -0,0 +1,140 @@
|
|||||||
|
import { useProcessStore } from '../../store/processStore';
|
||||||
|
import type { SchedulingAlgorithm } from '@core/types';
|
||||||
|
|
||||||
|
// Algorithms that require a quantum parameter
|
||||||
|
const QUANTUM_ALGORITHMS = new Set<SchedulingAlgorithm>(['RR', 'MULTILEVEL']);
|
||||||
|
|
||||||
|
// Algorithms where aging (anti-starvation) is applicable
|
||||||
|
const AGING_ALGORITHMS = new Set<SchedulingAlgorithm>(['PRIORITY_NP', 'PRIORITY_P']);
|
||||||
|
|
||||||
|
// Algorithms that are preemptive by definition (used for read-only info only)
|
||||||
|
const PREEMPTIVE_BY_DESIGN = new Set<SchedulingAlgorithm>(['SJF_P', 'RR', 'PRIORITY_P', 'MULTILEVEL']);
|
||||||
|
|
||||||
|
const inputCls = 'w-full rounded-md bg-slate-700 border border-slate-600 text-slate-200 text-sm px-3 py-1.5 focus:outline-none focus:ring-1 focus:ring-blue-500';
|
||||||
|
const labelCls = 'block text-xs text-slate-400 mb-1';
|
||||||
|
|
||||||
|
const ToggleRow = ({
|
||||||
|
id,
|
||||||
|
label,
|
||||||
|
checked,
|
||||||
|
onChange,
|
||||||
|
}: {
|
||||||
|
id: string;
|
||||||
|
label: string;
|
||||||
|
checked: boolean;
|
||||||
|
onChange: (v: boolean) => void;
|
||||||
|
}) => (
|
||||||
|
<div className="flex items-center justify-between">
|
||||||
|
<label htmlFor={id} className="text-xs text-slate-300 cursor-pointer">{label}</label>
|
||||||
|
<button
|
||||||
|
id={id}
|
||||||
|
role="switch"
|
||||||
|
aria-checked={checked}
|
||||||
|
onClick={() => onChange(!checked)}
|
||||||
|
className={`relative inline-flex h-5 w-9 items-center rounded-full transition-colors ${
|
||||||
|
checked ? 'bg-blue-600' : 'bg-slate-600'
|
||||||
|
}`}
|
||||||
|
>
|
||||||
|
<span
|
||||||
|
className={`inline-block h-3.5 w-3.5 rounded-full bg-white shadow transition-transform duration-200 ${
|
||||||
|
checked ? 'translate-x-4' : 'translate-x-1'
|
||||||
|
}`}
|
||||||
|
/>
|
||||||
|
</button>
|
||||||
|
</div>
|
||||||
|
);
|
||||||
|
|
||||||
|
const SchedulerConfig = () => {
|
||||||
|
const config = useProcessStore(s => s.config);
|
||||||
|
const setConfig = useProcessStore(s => s.setConfig);
|
||||||
|
|
||||||
|
const algo = config.algorithm;
|
||||||
|
const showQuantum = QUANTUM_ALGORITHMS.has(algo);
|
||||||
|
const showAging = AGING_ALGORITHMS.has(algo);
|
||||||
|
const isPreemptive = PREEMPTIVE_BY_DESIGN.has(algo);
|
||||||
|
|
||||||
|
return (
|
||||||
|
<div className="space-y-3" data-testid="scheduler-config">
|
||||||
|
|
||||||
|
{/* Read-only preemptive indicator */}
|
||||||
|
<div className="flex items-center justify-between">
|
||||||
|
<span className="text-xs text-slate-400">Tipo de escalonamento</span>
|
||||||
|
<span
|
||||||
|
className={`text-[10px] font-semibold uppercase tracking-wide px-2 py-0.5 rounded border ${
|
||||||
|
isPreemptive
|
||||||
|
? 'bg-amber-500/15 text-amber-400 border-amber-500/30'
|
||||||
|
: 'bg-slate-700 text-slate-400 border-slate-600'
|
||||||
|
}`}
|
||||||
|
data-testid="preemptive-badge"
|
||||||
|
>
|
||||||
|
{isPreemptive ? 'Preemptivo' : 'Não-preemptivo'}
|
||||||
|
</span>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Context Switch */}
|
||||||
|
<div>
|
||||||
|
<label htmlFor="ctx-switch" className={labelCls}>
|
||||||
|
Context Switch (0–10 ticks)
|
||||||
|
</label>
|
||||||
|
<input
|
||||||
|
id="ctx-switch"
|
||||||
|
type="number"
|
||||||
|
min={0}
|
||||||
|
max={10}
|
||||||
|
value={config.contextSwitchTime}
|
||||||
|
onChange={e => setConfig({ contextSwitchTime: Math.min(10, Math.max(0, Number(e.target.value))) })}
|
||||||
|
className={inputCls}
|
||||||
|
aria-label="Tempo de context switch"
|
||||||
|
/>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
{/* Quantum — RR and MULTILEVEL */}
|
||||||
|
{showQuantum && (
|
||||||
|
<div data-testid="quantum-field">
|
||||||
|
<label htmlFor="quantum" className={labelCls}>
|
||||||
|
Quantum (ticks)
|
||||||
|
</label>
|
||||||
|
<input
|
||||||
|
id="quantum"
|
||||||
|
type="number"
|
||||||
|
min={1}
|
||||||
|
value={config.quantum}
|
||||||
|
onChange={e => setConfig({ quantum: Math.max(1, Number(e.target.value)) })}
|
||||||
|
className={inputCls}
|
||||||
|
aria-label="Quantum do Round Robin"
|
||||||
|
/>
|
||||||
|
</div>
|
||||||
|
)}
|
||||||
|
|
||||||
|
{/* Aging — Priority only */}
|
||||||
|
{showAging && (
|
||||||
|
<div className="space-y-2 pt-0.5">
|
||||||
|
<ToggleRow
|
||||||
|
id="aging-toggle"
|
||||||
|
label="Aging (anti-starvation)"
|
||||||
|
checked={config.agingEnabled}
|
||||||
|
onChange={v => setConfig({ agingEnabled: v })}
|
||||||
|
/>
|
||||||
|
{config.agingEnabled && (
|
||||||
|
<div data-testid="aging-interval-field">
|
||||||
|
<label htmlFor="aging-interval" className={labelCls}>
|
||||||
|
Intervalo de Aging (ticks)
|
||||||
|
</label>
|
||||||
|
<input
|
||||||
|
id="aging-interval"
|
||||||
|
type="number"
|
||||||
|
min={1}
|
||||||
|
value={config.agingInterval}
|
||||||
|
onChange={e => setConfig({ agingInterval: Math.max(1, Number(e.target.value)) })}
|
||||||
|
className={inputCls}
|
||||||
|
aria-label="Intervalo de aging"
|
||||||
|
/>
|
||||||
|
</div>
|
||||||
|
)}
|
||||||
|
</div>
|
||||||
|
)}
|
||||||
|
</div>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default SchedulerConfig;
|
||||||
@@ -0,0 +1,19 @@
|
|||||||
|
import { Settings } from 'lucide-react';
|
||||||
|
import AlgorithmSelector from './AlgorithmSelector';
|
||||||
|
import SchedulerConfig from './SchedulerConfig';
|
||||||
|
|
||||||
|
const SchedulerPanel = () => {
|
||||||
|
return (
|
||||||
|
<section aria-label="Painel do Escalonador" className="space-y-3">
|
||||||
|
<div className="flex items-center gap-2 text-slate-300">
|
||||||
|
<Settings size={18} className="text-emerald-400" />
|
||||||
|
<h2 className="font-semibold uppercase text-xs tracking-wider">Escalonador</h2>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<AlgorithmSelector />
|
||||||
|
<SchedulerConfig />
|
||||||
|
</section>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default SchedulerPanel;
|
||||||
@@ -0,0 +1,100 @@
|
|||||||
|
import { describe, it, expect, beforeEach } from 'vitest';
|
||||||
|
import { render, screen } from '@testing-library/react';
|
||||||
|
import userEvent from '@testing-library/user-event';
|
||||||
|
import ControlBar from '../ControlBar/ControlBar';
|
||||||
|
import { useProcessStore } from '../../store/processStore';
|
||||||
|
import { useSimulationStore } from '../../store/simulationStore';
|
||||||
|
import { useUiStore } from '../../store/uiStore';
|
||||||
|
import type { Process } from '@core/types';
|
||||||
|
|
||||||
|
const MOCK_PROCESS: Process = {
|
||||||
|
id: 'p1',
|
||||||
|
name: 'P1',
|
||||||
|
arrivalTime: 0,
|
||||||
|
priority: 5,
|
||||||
|
color: '#60a5fa',
|
||||||
|
bursts: [{ type: 'cpu', duration: 4 }],
|
||||||
|
};
|
||||||
|
|
||||||
|
beforeEach(() => {
|
||||||
|
useProcessStore.setState({ processes: [], config: useProcessStore.getState().config });
|
||||||
|
useSimulationStore.setState({ status: 'idle', ticks: [], engine: null, _processes: [], _config: null });
|
||||||
|
useUiStore.setState({ speed: 1 });
|
||||||
|
});
|
||||||
|
|
||||||
|
describe('ControlBar', () => {
|
||||||
|
it('renders the toolbar with all main controls', () => {
|
||||||
|
render(<ControlBar />);
|
||||||
|
expect(screen.getByRole('toolbar')).toBeInTheDocument();
|
||||||
|
expect(screen.getByTestId('btn-play')).toBeInTheDocument();
|
||||||
|
expect(screen.getByTestId('btn-step')).toBeInTheDocument();
|
||||||
|
expect(screen.getByTestId('btn-reset')).toBeInTheDocument();
|
||||||
|
expect(screen.getByTestId('tick-display')).toBeInTheDocument();
|
||||||
|
expect(screen.getByTestId('speed-select')).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('displays tick 0000 on initial render', () => {
|
||||||
|
render(<ControlBar />);
|
||||||
|
expect(screen.getByTestId('tick-display')).toHaveTextContent('0000');
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows "Pronto" status when idle', () => {
|
||||||
|
render(<ControlBar />);
|
||||||
|
expect(screen.getByText('Pronto')).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('Play button is disabled when no processes are loaded', () => {
|
||||||
|
render(<ControlBar />);
|
||||||
|
expect(screen.getByTestId('btn-play')).toBeDisabled();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('Step button initialises simulation and advances tick', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
useProcessStore.setState({ processes: [MOCK_PROCESS] });
|
||||||
|
render(<ControlBar />);
|
||||||
|
const stepBtn = screen.getByTestId('btn-step');
|
||||||
|
await user.click(stepBtn);
|
||||||
|
expect(screen.getByTestId('tick-display')).toHaveTextContent('0001');
|
||||||
|
});
|
||||||
|
|
||||||
|
it('Play button triggers init and sets status to running', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
useProcessStore.setState({ processes: [MOCK_PROCESS] });
|
||||||
|
render(<ControlBar />);
|
||||||
|
await user.click(screen.getByTestId('btn-play'));
|
||||||
|
expect(useSimulationStore.getState().status).toBe('running');
|
||||||
|
});
|
||||||
|
|
||||||
|
it('Pause button is shown (and plays) when simulation is running', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
useProcessStore.setState({ processes: [MOCK_PROCESS] });
|
||||||
|
render(<ControlBar />);
|
||||||
|
await user.click(screen.getByTestId('btn-play'));
|
||||||
|
expect(screen.getByTestId('btn-pause')).toBeInTheDocument();
|
||||||
|
await user.click(screen.getByTestId('btn-pause'));
|
||||||
|
expect(useSimulationStore.getState().status).toBe('paused');
|
||||||
|
});
|
||||||
|
|
||||||
|
it('changing speed updates uiStore', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
render(<ControlBar />);
|
||||||
|
const speedSelect = screen.getByTestId('speed-select');
|
||||||
|
await user.selectOptions(speedSelect, '2');
|
||||||
|
expect(useUiStore.getState().speed).toBe(2);
|
||||||
|
});
|
||||||
|
|
||||||
|
it('Reset is disabled when status is idle', () => {
|
||||||
|
render(<ControlBar />);
|
||||||
|
expect(screen.getByTestId('btn-reset')).toBeDisabled();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('Reset becomes enabled after simulation starts and returns tick to 0', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
useProcessStore.setState({ processes: [MOCK_PROCESS] });
|
||||||
|
render(<ControlBar />);
|
||||||
|
await user.click(screen.getByTestId('btn-step'));
|
||||||
|
expect(screen.getByTestId('tick-display')).toHaveTextContent('0001');
|
||||||
|
await user.click(screen.getByTestId('btn-reset'));
|
||||||
|
expect(screen.getByTestId('tick-display')).toHaveTextContent('0000');
|
||||||
|
});
|
||||||
|
});
|
||||||
@@ -0,0 +1,100 @@
|
|||||||
|
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
||||||
|
import { render, screen, fireEvent } from '@testing-library/react';
|
||||||
|
import userEvent from '@testing-library/user-event';
|
||||||
|
import ProcessForm from '../ProcessPanel/ProcessForm';
|
||||||
|
import { useProcessStore } from '../../store/processStore';
|
||||||
|
|
||||||
|
// Reset Zustand processStore between tests
|
||||||
|
beforeEach(() => {
|
||||||
|
useProcessStore.setState({ processes: [], config: useProcessStore.getState().config });
|
||||||
|
vi.clearAllMocks();
|
||||||
|
});
|
||||||
|
|
||||||
|
describe('ProcessForm', () => {
|
||||||
|
it('renders the "Novo Processo" form with default fields', () => {
|
||||||
|
render(<ProcessForm onClose={() => {}} />);
|
||||||
|
expect(screen.getByTestId('process-form')).toBeInTheDocument();
|
||||||
|
expect(screen.getByText('Novo Processo')).toBeInTheDocument();
|
||||||
|
expect(screen.getByLabelText('Nome do processo')).toBeInTheDocument();
|
||||||
|
expect(screen.getByLabelText('Tempo de chegada')).toBeInTheDocument();
|
||||||
|
expect(screen.getByLabelText('Prioridade do processo')).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows "Editar Processo" title when editingProcess is provided', () => {
|
||||||
|
const proc = {
|
||||||
|
id: 'p1', name: 'P1', arrivalTime: 0, priority: 5, color: '#fff',
|
||||||
|
bursts: [{ type: 'cpu' as const, duration: 4 }],
|
||||||
|
};
|
||||||
|
render(<ProcessForm editingProcess={proc} onClose={() => {}} />);
|
||||||
|
expect(screen.getByText('Editar Processo')).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows validation error when name is empty', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
render(<ProcessForm onClose={() => {}} />);
|
||||||
|
const nameInput = screen.getByLabelText('Nome do processo');
|
||||||
|
await user.clear(nameInput);
|
||||||
|
const submitBtn = screen.getByRole('button', { name: /Criar/i });
|
||||||
|
await user.click(submitBtn);
|
||||||
|
expect(screen.getByRole('alert')).toBeInTheDocument();
|
||||||
|
expect(screen.getByText(/Nome é obrigatório/i)).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows validation error when arrival time is negative', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
render(<ProcessForm onClose={() => {}} />);
|
||||||
|
const nameInput = screen.getByLabelText('Nome do processo');
|
||||||
|
await user.type(nameInput, 'P1');
|
||||||
|
const arrivalInput = screen.getByLabelText('Tempo de chegada');
|
||||||
|
// fireEvent.change used to reliably set a negative number bypassing HTML min attribute
|
||||||
|
fireEvent.change(arrivalInput, { target: { value: '-1' } });
|
||||||
|
const submitBtn = screen.getByRole('button', { name: /Criar/i });
|
||||||
|
await user.click(submitBtn);
|
||||||
|
expect(screen.getByText(/Arrival Time deve ser ≥ 0/i)).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows validation error for name longer than 8 chars', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
render(<ProcessForm onClose={() => {}} />);
|
||||||
|
const nameInput = screen.getByLabelText('Nome do processo');
|
||||||
|
// Bypass the HTML maxLength attribute via fireEvent to test the JS validation
|
||||||
|
fireEvent.change(nameInput, { target: { value: 'ProcessXXLong' } });
|
||||||
|
await user.click(screen.getByRole('button', { name: /Criar/i }));
|
||||||
|
expect(screen.getByText(/Nome deve ter no máximo 8 caracteres/i)).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('adds a new burst with alternating type when clicking + button', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
render(<ProcessForm onClose={() => {}} />);
|
||||||
|
const addBurstBtn = screen.getByLabelText('Adicionar burst');
|
||||||
|
await user.click(addBurstBtn);
|
||||||
|
// After one CPU burst at start, clicking + adds IO burst
|
||||||
|
// getAllByText with exact matches for the type labels
|
||||||
|
const cpuLabels = screen.getAllByText((_, el) => el?.tagName === 'SPAN' && el.textContent?.trim().toUpperCase() === 'CPU');
|
||||||
|
const ioLabels = screen.getAllByText((_, el) => el?.tagName === 'SPAN' && el.textContent?.trim().toUpperCase() === 'IO');
|
||||||
|
expect(cpuLabels.length).toBeGreaterThanOrEqual(1);
|
||||||
|
expect(ioLabels.length).toBeGreaterThanOrEqual(1);
|
||||||
|
});
|
||||||
|
|
||||||
|
it('calls onClose after successful form submission', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
const onClose = vi.fn();
|
||||||
|
render(<ProcessForm onClose={onClose} />);
|
||||||
|
const nameInput = screen.getByLabelText('Nome do processo');
|
||||||
|
await user.type(nameInput, 'P1');
|
||||||
|
const submitBtn = screen.getByRole('button', { name: /Criar/i });
|
||||||
|
await user.click(submitBtn);
|
||||||
|
expect(onClose).toHaveBeenCalledOnce();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('adds the process to the store after successful submission', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
render(<ProcessForm onClose={() => {}} />);
|
||||||
|
const nameInput = screen.getByLabelText('Nome do processo');
|
||||||
|
await user.type(nameInput, 'Test1');
|
||||||
|
await user.click(screen.getByRole('button', { name: /Criar/i }));
|
||||||
|
const processes = useProcessStore.getState().processes;
|
||||||
|
expect(processes).toHaveLength(1);
|
||||||
|
expect(processes[0]?.name).toBe('Test1');
|
||||||
|
});
|
||||||
|
});
|
||||||
@@ -0,0 +1,123 @@
|
|||||||
|
import { describe, it, expect, beforeEach } from 'vitest';
|
||||||
|
import { render, screen, fireEvent } from '@testing-library/react';
|
||||||
|
import userEvent from '@testing-library/user-event';
|
||||||
|
import SchedulerConfig from '../SchedulerPanel/SchedulerConfig';
|
||||||
|
import { useProcessStore } from '../../store/processStore';
|
||||||
|
import type { SchedulingAlgorithm } from '@core/types';
|
||||||
|
|
||||||
|
const setAlgorithm = (algo: SchedulingAlgorithm) => {
|
||||||
|
useProcessStore.setState(s => ({ config: { ...s.config, algorithm: algo } }));
|
||||||
|
};
|
||||||
|
|
||||||
|
beforeEach(() => {
|
||||||
|
useProcessStore.setState(s => ({
|
||||||
|
config: {
|
||||||
|
...s.config,
|
||||||
|
algorithm: 'FCFS',
|
||||||
|
quantum: 2,
|
||||||
|
contextSwitchTime: 0,
|
||||||
|
isPreemptive: false,
|
||||||
|
agingEnabled: false,
|
||||||
|
agingInterval: 5,
|
||||||
|
},
|
||||||
|
}));
|
||||||
|
});
|
||||||
|
|
||||||
|
describe('SchedulerConfig', () => {
|
||||||
|
it('always shows Context Switch field regardless of algorithm', () => {
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.getByLabelText('Tempo de context switch')).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('always shows read-only preemptive badge', () => {
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.getByTestId('preemptive-badge')).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('badge shows "Não-preemptivo" for FCFS', () => {
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.getByTestId('preemptive-badge')).toHaveTextContent('Não-preemptivo');
|
||||||
|
});
|
||||||
|
|
||||||
|
it('badge shows "Preemptivo" for SJF_P (SRTF)', () => {
|
||||||
|
setAlgorithm('SJF_P');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.getByTestId('preemptive-badge')).toHaveTextContent('Preemptivo');
|
||||||
|
});
|
||||||
|
|
||||||
|
it('badge shows "Não-preemptivo" for SJF_NP (preemptive toggle no longer exists)', () => {
|
||||||
|
setAlgorithm('SJF_NP');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.getByTestId('preemptive-badge')).toHaveTextContent('Não-preemptivo');
|
||||||
|
// Confirm the old interactive preemptive switch is gone
|
||||||
|
expect(screen.queryByRole('switch', { name: /Preemptivo/i })).not.toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('does NOT show Quantum field for FCFS', () => {
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.queryByTestId('quantum-field')).not.toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows Quantum field when algorithm is RR', () => {
|
||||||
|
setAlgorithm('RR');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.getByTestId('quantum-field')).toBeInTheDocument();
|
||||||
|
expect(screen.getByLabelText('Quantum do Round Robin')).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows Quantum field when algorithm is MULTILEVEL', () => {
|
||||||
|
setAlgorithm('MULTILEVEL');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.getByTestId('quantum-field')).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('does NOT show Quantum field for SJF_NP', () => {
|
||||||
|
setAlgorithm('SJF_NP');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.queryByTestId('quantum-field')).not.toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows Aging toggle for PRIORITY_NP', () => {
|
||||||
|
setAlgorithm('PRIORITY_NP');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.getByRole('switch', { name: /Aging/i })).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows Aging toggle for PRIORITY_P', () => {
|
||||||
|
setAlgorithm('PRIORITY_P');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.getByRole('switch', { name: /Aging/i })).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('shows Aging interval field only when aging is enabled', async () => {
|
||||||
|
const user = userEvent.setup();
|
||||||
|
setAlgorithm('PRIORITY_NP');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.queryByTestId('aging-interval-field')).not.toBeInTheDocument();
|
||||||
|
const agingToggle = screen.getByRole('switch', { name: /Aging/i });
|
||||||
|
await user.click(agingToggle);
|
||||||
|
expect(screen.getByTestId('aging-interval-field')).toBeInTheDocument();
|
||||||
|
expect(screen.getByLabelText('Intervalo de aging')).toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('updates the store when Quantum field is changed', () => {
|
||||||
|
setAlgorithm('RR');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
const quantumInput = screen.getByLabelText('Quantum do Round Robin');
|
||||||
|
fireEvent.change(quantumInput, { target: { value: '5' } });
|
||||||
|
expect(useProcessStore.getState().config.quantum).toBe(5);
|
||||||
|
});
|
||||||
|
|
||||||
|
it('does NOT show Aging toggle for FCFS', () => {
|
||||||
|
setAlgorithm('FCFS');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.queryByRole('switch', { name: /Aging/i })).not.toBeInTheDocument();
|
||||||
|
});
|
||||||
|
|
||||||
|
it('does NOT show Aging toggle for HRRN', () => {
|
||||||
|
setAlgorithm('HRRN');
|
||||||
|
render(<SchedulerConfig />);
|
||||||
|
expect(screen.queryByRole('switch', { name: /Aging/i })).not.toBeInTheDocument();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
@@ -0,0 +1,30 @@
|
|||||||
|
import { clsx } from 'clsx';
|
||||||
|
|
||||||
|
type BadgeVariant = 'cpu' | 'io' | 'balanced' | 'slate';
|
||||||
|
|
||||||
|
interface BadgeProps {
|
||||||
|
variant?: BadgeVariant;
|
||||||
|
children: React.ReactNode;
|
||||||
|
className?: string;
|
||||||
|
}
|
||||||
|
|
||||||
|
const variantClasses: Record<BadgeVariant, string> = {
|
||||||
|
cpu: 'bg-emerald-500/20 text-emerald-400 border border-emerald-500/30',
|
||||||
|
io: 'bg-cyan-500/20 text-cyan-400 border border-cyan-500/30',
|
||||||
|
balanced: 'bg-violet-500/20 text-violet-400 border border-violet-500/30',
|
||||||
|
slate: 'bg-slate-700 text-slate-400 border border-slate-600',
|
||||||
|
};
|
||||||
|
|
||||||
|
const Badge = ({ variant = 'slate', children, className }: BadgeProps) => (
|
||||||
|
<span
|
||||||
|
className={clsx(
|
||||||
|
'inline-flex items-center rounded px-1.5 py-0.5 text-[10px] font-semibold uppercase tracking-wide',
|
||||||
|
variantClasses[variant],
|
||||||
|
className,
|
||||||
|
)}
|
||||||
|
>
|
||||||
|
{children}
|
||||||
|
</span>
|
||||||
|
);
|
||||||
|
|
||||||
|
export default Badge;
|
||||||
@@ -0,0 +1,51 @@
|
|||||||
|
import { type ButtonHTMLAttributes, type ReactNode } from 'react';
|
||||||
|
import { clsx } from 'clsx';
|
||||||
|
|
||||||
|
interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
|
||||||
|
children: ReactNode;
|
||||||
|
variant?: 'default' | 'primary' | 'danger' | 'ghost';
|
||||||
|
size?: 'sm' | 'md';
|
||||||
|
label: string;
|
||||||
|
}
|
||||||
|
|
||||||
|
const variantClasses = {
|
||||||
|
default: 'bg-slate-700 hover:bg-slate-600 text-slate-200 border-slate-600',
|
||||||
|
primary: 'bg-blue-600 hover:bg-blue-500 text-white border-blue-500',
|
||||||
|
danger: 'bg-red-600/80 hover:bg-red-500 text-white border-red-500',
|
||||||
|
ghost: 'bg-transparent hover:bg-slate-700 text-slate-400 hover:text-slate-200 border-transparent',
|
||||||
|
};
|
||||||
|
|
||||||
|
const sizeClasses = {
|
||||||
|
sm: 'h-7 w-7 text-sm',
|
||||||
|
md: 'h-9 w-9 text-base',
|
||||||
|
};
|
||||||
|
|
||||||
|
const IconButton = ({
|
||||||
|
children,
|
||||||
|
variant = 'default',
|
||||||
|
size = 'md',
|
||||||
|
label,
|
||||||
|
className,
|
||||||
|
disabled,
|
||||||
|
...rest
|
||||||
|
}: IconButtonProps) => {
|
||||||
|
return (
|
||||||
|
<button
|
||||||
|
aria-label={label}
|
||||||
|
title={label}
|
||||||
|
disabled={disabled}
|
||||||
|
className={clsx(
|
||||||
|
'inline-flex items-center justify-center rounded-lg border transition-colors duration-150 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-400',
|
||||||
|
'disabled:opacity-40 disabled:cursor-not-allowed',
|
||||||
|
variantClasses[variant],
|
||||||
|
sizeClasses[size],
|
||||||
|
className,
|
||||||
|
)}
|
||||||
|
{...rest}
|
||||||
|
>
|
||||||
|
{children}
|
||||||
|
</button>
|
||||||
|
);
|
||||||
|
};
|
||||||
|
|
||||||
|
export default IconButton;
|
||||||
@@ -0,0 +1,32 @@
|
|||||||
|
import type { BurstSegment } from '@core/types';
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Classifies a process as CPU Bound, I/O Bound, or Balanced
|
||||||
|
* based on declared burst segments (used for preview in ProcessCard).
|
||||||
|
*/
|
||||||
|
export function classifyBound(bursts: BurstSegment[]): 'CPU Bound' | 'I/O Bound' | 'Balanced' {
|
||||||
|
const cpuTotal = bursts.filter(b => b.type === 'cpu').reduce((a, b) => a + b.duration, 0);
|
||||||
|
const ioTotal = bursts.filter(b => b.type === 'io').reduce((a, b) => a + b.duration, 0);
|
||||||
|
const total = cpuTotal + ioTotal;
|
||||||
|
if (total === 0) return 'Balanced';
|
||||||
|
const cpuRatio = cpuTotal / total;
|
||||||
|
const ioRatio = ioTotal / total;
|
||||||
|
if (cpuRatio >= 0.65) return 'CPU Bound';
|
||||||
|
if (ioRatio >= 0.65) return 'I/O Bound';
|
||||||
|
return 'Balanced';
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Generate a short unique id */
|
||||||
|
export function generateId(): string {
|
||||||
|
return Math.random().toString(36).slice(2, 9);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Random vivid HEX color */
|
||||||
|
const PALETTE = [
|
||||||
|
'#60a5fa','#34d399','#f472b6','#fb923c','#a78bfa',
|
||||||
|
'#38bdf8','#facc15','#4ade80','#f87171','#c084fc',
|
||||||
|
];
|
||||||
|
let _paletteIndex = 0;
|
||||||
|
export function nextColor(): string {
|
||||||
|
return PALETTE[_paletteIndex++ % PALETTE.length];
|
||||||
|
}
|
||||||
@@ -0,0 +1,281 @@
|
|||||||
|
import { describe, it, expect } from "vitest";
|
||||||
|
import { SimulationEngine } from "../engine";
|
||||||
|
import type { Process, SchedulerConfig } from "../types";
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Helpers
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
const cfg = (overrides: Partial<SchedulerConfig> = {}): SchedulerConfig => ({
|
||||||
|
algorithm: "FCFS",
|
||||||
|
quantum: 2,
|
||||||
|
contextSwitchTime: 0,
|
||||||
|
isPreemptive: false,
|
||||||
|
agingEnabled: false,
|
||||||
|
agingInterval: 5,
|
||||||
|
...overrides,
|
||||||
|
});
|
||||||
|
|
||||||
|
const p = (
|
||||||
|
id: string,
|
||||||
|
arrivalTime: number,
|
||||||
|
bursts: { type: "cpu" | "io"; duration: number }[],
|
||||||
|
priority = 5,
|
||||||
|
): Process => ({
|
||||||
|
id,
|
||||||
|
name: id.toUpperCase(),
|
||||||
|
arrivalTime,
|
||||||
|
priority,
|
||||||
|
color: "#fff",
|
||||||
|
bursts,
|
||||||
|
});
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// CT-01: FCFS Basic
|
||||||
|
// Input: P1(arrival=0, CPU:4), P2(arrival=1, CPU:3), P3(arrival=2, CPU:1)
|
||||||
|
// Expected Gantt: P1(0-4), P2(4-7), P3(7-8)
|
||||||
|
// P1: response=0, turnaround=4, waiting=0
|
||||||
|
// P2: response=3, turnaround=6, waiting=3
|
||||||
|
// P3: response=5, turnaround=6, waiting=5
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
describe("CT-01: FCFS Basic", () => {
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 4 }]),
|
||||||
|
p("p2", 1, [{ type: "cpu", duration: 3 }]),
|
||||||
|
p("p3", 2, [{ type: "cpu", duration: 1 }]),
|
||||||
|
];
|
||||||
|
|
||||||
|
it("produces correct Gantt sequence", () => {
|
||||||
|
const engine = new SimulationEngine(processes, cfg());
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
|
||||||
|
// ticks[i].tick should equal i
|
||||||
|
expect(ticks.length).toBe(8);
|
||||||
|
|
||||||
|
// P1 runs ticks 0–3
|
||||||
|
for (let i = 0; i <= 3; i++) {
|
||||||
|
expect(ticks[i]?.cpuProcess).toBe("p1");
|
||||||
|
}
|
||||||
|
// P2 runs ticks 4–6
|
||||||
|
for (let i = 4; i <= 6; i++) {
|
||||||
|
expect(ticks[i]?.cpuProcess).toBe("p2");
|
||||||
|
}
|
||||||
|
// P3 runs tick 7
|
||||||
|
expect(ticks[7]?.cpuProcess).toBe("p3");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("sets correct finishTick values", () => {
|
||||||
|
const engine = new SimulationEngine(processes, cfg());
|
||||||
|
engine.runAll();
|
||||||
|
const rts = engine.runtimeStates;
|
||||||
|
const rt1 = rts.find((r) => r.processId === "p1")!;
|
||||||
|
const rt2 = rts.find((r) => r.processId === "p2")!;
|
||||||
|
const rt3 = rts.find((r) => r.processId === "p3")!;
|
||||||
|
|
||||||
|
expect(rt1.finishTick).toBe(4);
|
||||||
|
expect(rt2.finishTick).toBe(7);
|
||||||
|
expect(rt3.finishTick).toBe(8);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("computes correct per-process metrics", () => {
|
||||||
|
const engine = new SimulationEngine(processes, cfg());
|
||||||
|
engine.runAll();
|
||||||
|
const rts = engine.runtimeStates;
|
||||||
|
const rt1 = rts.find((r) => r.processId === "p1")!;
|
||||||
|
const rt2 = rts.find((r) => r.processId === "p2")!;
|
||||||
|
const rt3 = rts.find((r) => r.processId === "p3")!;
|
||||||
|
|
||||||
|
// P1: arrivalTick=0, startTick=0, finishTick=4
|
||||||
|
expect(rt1.startTick).toBe(0);
|
||||||
|
expect(rt1.waitingTime).toBe(0);
|
||||||
|
// turnaround = 4 - 0 = 4; waiting = 4 - 4 - 0 = 0
|
||||||
|
expect(rt1.finishTick! - rt1.arrivalTick).toBe(4); // turnaround
|
||||||
|
|
||||||
|
// P2: arrivalTick=1, startTick=4, finishTick=7
|
||||||
|
expect(rt2.startTick).toBe(4);
|
||||||
|
expect(rt2.waitingTime).toBe(3); // waited ticks 1,2,3
|
||||||
|
// response = 4 - 1 = 3
|
||||||
|
expect(rt2.startTick! - rt2.arrivalTick).toBe(3);
|
||||||
|
|
||||||
|
// P3: arrivalTick=2, startTick=7, finishTick=8
|
||||||
|
expect(rt3.startTick).toBe(7);
|
||||||
|
expect(rt3.waitingTime).toBe(5); // waited ticks 2,3,4,5,6
|
||||||
|
expect(rt3.startTick! - rt3.arrivalTick).toBe(5); // response
|
||||||
|
expect(rt3.finishTick! - rt3.arrivalTick).toBe(6); // turnaround
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// CT-02: Round Robin (quantum=2)
|
||||||
|
// Input: P1,P2,P3 all arrival=0; CPU:5, CPU:3, CPU:1
|
||||||
|
// Expected: P1(0-2), P2(2-4), P3(4-5), P1(5-7), P2(7-8), P1(8-9)
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
describe("CT-02: Round Robin (quantum=2)", () => {
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 5 }]),
|
||||||
|
p("p2", 0, [{ type: "cpu", duration: 3 }]),
|
||||||
|
p("p3", 0, [{ type: "cpu", duration: 1 }]),
|
||||||
|
];
|
||||||
|
|
||||||
|
it("produces correct Gantt sequence", () => {
|
||||||
|
const engine = new SimulationEngine(processes, cfg({ algorithm: "RR", quantum: 2 }));
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
|
||||||
|
expect(ticks.length).toBe(9);
|
||||||
|
|
||||||
|
const cpu = ticks.map((t) => t.cpuProcess);
|
||||||
|
expect(cpu[0]).toBe("p1");
|
||||||
|
expect(cpu[1]).toBe("p1");
|
||||||
|
expect(cpu[2]).toBe("p2");
|
||||||
|
expect(cpu[3]).toBe("p2");
|
||||||
|
expect(cpu[4]).toBe("p3");
|
||||||
|
expect(cpu[5]).toBe("p1");
|
||||||
|
expect(cpu[6]).toBe("p1");
|
||||||
|
expect(cpu[7]).toBe("p2");
|
||||||
|
expect(cpu[8]).toBe("p1");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("computes waiting times", () => {
|
||||||
|
const engine = new SimulationEngine(processes, cfg({ algorithm: "RR", quantum: 2 }));
|
||||||
|
engine.runAll();
|
||||||
|
const rts = engine.runtimeStates;
|
||||||
|
const rt1 = rts.find((r) => r.processId === "p1")!;
|
||||||
|
const rt2 = rts.find((r) => r.processId === "p2")!;
|
||||||
|
const rt3 = rts.find((r) => r.processId === "p3")!;
|
||||||
|
|
||||||
|
// P1: turnaround=9, cpuTime=5, ioTime=0 → waiting=4
|
||||||
|
expect(rt1.waitingTime).toBe(4);
|
||||||
|
// P2: finishTick=8, arrival=0 → turnaround=8; cpuTime=3 → waiting=5
|
||||||
|
expect(rt2.waitingTime).toBe(5);
|
||||||
|
// P3: finishTick=5, arrival=0 → turnaround=5; cpuTime=1 → waiting=4
|
||||||
|
expect(rt3.waitingTime).toBe(4);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// CT-04: SRTF Preemption
|
||||||
|
// P1(arrival=0, CPU:8), P2(arrival=1, CPU:4)
|
||||||
|
// P1 runs tick 0, P2 preempts at tick 1 (P2 remaining=4 < P1 remaining=7)
|
||||||
|
// P2 finishes tick 5 (runs ticks 1-4), P1 resumes ticks 5-11, finishes tick 12
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
describe("CT-04: SRTF Preemption", () => {
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 8 }]),
|
||||||
|
p("p2", 1, [{ type: "cpu", duration: 4 }]),
|
||||||
|
];
|
||||||
|
|
||||||
|
it("P2 preempts P1 at tick 1", () => {
|
||||||
|
const engine = new SimulationEngine(processes, cfg({ algorithm: "SJF_P", isPreemptive: true }));
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
|
||||||
|
expect(ticks[0]?.cpuProcess).toBe("p1"); // tick 0: P1 running
|
||||||
|
expect(ticks[1]?.cpuProcess).toBe("p2"); // tick 1: P2 preempts
|
||||||
|
expect(ticks[2]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[3]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[4]?.cpuProcess).toBe("p2"); // tick 4: P2 last tick
|
||||||
|
});
|
||||||
|
|
||||||
|
it("P2 finishes at tick 5 and P1 resumes", () => {
|
||||||
|
const engine = new SimulationEngine(processes, cfg({ algorithm: "SJF_P", isPreemptive: true }));
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
const rts = engine.runtimeStates;
|
||||||
|
const rt2 = rts.find((r) => r.processId === "p2")!;
|
||||||
|
const rt1 = rts.find((r) => r.processId === "p1")!;
|
||||||
|
|
||||||
|
expect(rt2.finishTick).toBe(5);
|
||||||
|
expect(rt1.finishTick).toBe(12);
|
||||||
|
// P1 resumes at tick 5
|
||||||
|
expect(ticks[5]?.cpuProcess).toBe("p1");
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// General engine behaviour
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
describe("SimulationEngine general", () => {
|
||||||
|
it("isFinished returns false mid-run, true after runAll", () => {
|
||||||
|
const engine = new SimulationEngine(
|
||||||
|
[p("p1", 0, [{ type: "cpu", duration: 3 }])],
|
||||||
|
cfg(),
|
||||||
|
);
|
||||||
|
expect(engine.isFinished).toBe(false);
|
||||||
|
engine.step();
|
||||||
|
expect(engine.isFinished).toBe(false);
|
||||||
|
engine.runAll();
|
||||||
|
expect(engine.isFinished).toBe(true);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("step() after isFinished throws", () => {
|
||||||
|
const engine = new SimulationEngine(
|
||||||
|
[p("p1", 0, [{ type: "cpu", duration: 1 }])],
|
||||||
|
cfg(),
|
||||||
|
);
|
||||||
|
engine.runAll();
|
||||||
|
expect(() => engine.step()).toThrow();
|
||||||
|
});
|
||||||
|
|
||||||
|
it("runAll() and repeated step() produce same tick sequence", () => {
|
||||||
|
const procs = [
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 3 }]),
|
||||||
|
p("p2", 1, [{ type: "cpu", duration: 2 }]),
|
||||||
|
];
|
||||||
|
const e1 = new SimulationEngine(procs, cfg());
|
||||||
|
const e2 = new SimulationEngine(procs, cfg());
|
||||||
|
|
||||||
|
const fromRunAll = e1.runAll();
|
||||||
|
const fromStep: ReturnType<typeof e2.step>[] = [];
|
||||||
|
while (!e2.isFinished) fromStep.push(e2.step());
|
||||||
|
|
||||||
|
expect(fromRunAll).toEqual(fromStep);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("process with I/O: transitions through Waiting state", () => {
|
||||||
|
const engine = new SimulationEngine(
|
||||||
|
[p("p1", 0, [{ type: "cpu", duration: 2 }, { type: "io", duration: 2 }, { type: "cpu", duration: 1 }])],
|
||||||
|
cfg(),
|
||||||
|
);
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
const states = ticks.map((t) => t.states["p1"]);
|
||||||
|
// Running for 2, Waiting for 2, Running for 1
|
||||||
|
expect(states[0]).toBe("Running");
|
||||||
|
expect(states[1]).toBe("Running");
|
||||||
|
expect(states[2]).toBe("Waiting");
|
||||||
|
expect(states[3]).toBe("Waiting");
|
||||||
|
expect(states[4]).toBe("Running");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("process arriving after simulation starts is correctly scheduled", () => {
|
||||||
|
const engine = new SimulationEngine(
|
||||||
|
[
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 3 }]),
|
||||||
|
p("p2", 5, [{ type: "cpu", duration: 2 }]),
|
||||||
|
],
|
||||||
|
cfg(),
|
||||||
|
);
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
// P1 finishes at tick 3; CPU idle 3,4; P2 arrives at 5
|
||||||
|
expect(ticks[4]?.cpuProcess).toBeNull(); // tick 4: idle
|
||||||
|
expect(ticks[5]?.cpuProcess).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("context switch inserts idle ticks between processes", () => {
|
||||||
|
const engine = new SimulationEngine(
|
||||||
|
[
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 2 }]),
|
||||||
|
p("p2", 0, [{ type: "cpu", duration: 2 }]),
|
||||||
|
],
|
||||||
|
cfg({ algorithm: "FCFS", contextSwitchTime: 1 }),
|
||||||
|
);
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
// P1 runs ticks 0-1, context switch tick 2, P2 runs ticks 3-4
|
||||||
|
expect(ticks[0]?.cpuProcess).toBe("p1");
|
||||||
|
expect(ticks[1]?.cpuProcess).toBe("p1");
|
||||||
|
expect(ticks[2]?.contextSwitching).toBe(true);
|
||||||
|
expect(ticks[2]?.cpuProcess).toBeNull();
|
||||||
|
expect(ticks[3]?.cpuProcess).toBe("p2");
|
||||||
|
});
|
||||||
|
});
|
||||||
@@ -0,0 +1,54 @@
|
|||||||
|
import { describe, it, expect } from "vitest";
|
||||||
|
import { fcfs } from "../algorithms/fcfs";
|
||||||
|
import type { ProcessRuntime } from "../types";
|
||||||
|
|
||||||
|
function makeRt(id: string, arrivalTick: number): ProcessRuntime {
|
||||||
|
return {
|
||||||
|
processId: id, state: "Ready", remainingBurst: 4, burstIndex: 0,
|
||||||
|
arrivalTick, startTick: null, finishTick: null,
|
||||||
|
waitingTime: 0, cpuTime: 0, ioTime: 0, responseTime: null,
|
||||||
|
quantumRemaining: 2, currentPriority: 5,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
const config = { algorithm: "FCFS" as const, quantum: 2, contextSwitchTime: 0, isPreemptive: false, agingEnabled: false, agingInterval: 5 };
|
||||||
|
|
||||||
|
describe("FCFS select()", () => {
|
||||||
|
it("returns null for empty queue", () => {
|
||||||
|
expect(fcfs.select([], config)).toBeNull();
|
||||||
|
});
|
||||||
|
|
||||||
|
it("returns single process", () => {
|
||||||
|
const rt = makeRt("p1", 0);
|
||||||
|
expect(fcfs.select([rt], config)).toBe(rt);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("returns earliest-arriving process", () => {
|
||||||
|
const r1 = makeRt("p1", 5);
|
||||||
|
const r2 = makeRt("p2", 2);
|
||||||
|
const r3 = makeRt("p3", 8);
|
||||||
|
expect(fcfs.select([r1, r2, r3], config)?.processId).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("tiebreaks by processId lexicographic", () => {
|
||||||
|
const r1 = makeRt("p2", 0);
|
||||||
|
const r2 = makeRt("p1", 0);
|
||||||
|
expect(fcfs.select([r1, r2], config)?.processId).toBe("p1");
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("FCFS shouldPreempt()", () => {
|
||||||
|
it("always returns false", () => {
|
||||||
|
const a = makeRt("p1", 0);
|
||||||
|
const b = makeRt("p2", 0);
|
||||||
|
expect(fcfs.shouldPreempt(a, b, config)).toBe(false);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("FCFS isQuantumExpired()", () => {
|
||||||
|
it("always returns false", () => {
|
||||||
|
const rt = makeRt("p1", 0);
|
||||||
|
rt.quantumRemaining = 0;
|
||||||
|
expect(fcfs.isQuantumExpired(rt, config)).toBe(false);
|
||||||
|
});
|
||||||
|
});
|
||||||
@@ -0,0 +1,83 @@
|
|||||||
|
import { describe, it, expect } from "vitest";
|
||||||
|
import { hrrn } from "../algorithms/hrrn";
|
||||||
|
import { SimulationEngine } from "../engine";
|
||||||
|
import type { Process, ProcessRuntime, SchedulerConfig } from "../types";
|
||||||
|
|
||||||
|
function makeRt(id: string, remainingBurst: number, waitingTime: number, arrivalTick = 0): ProcessRuntime {
|
||||||
|
return {
|
||||||
|
processId: id, state: "Ready", remainingBurst, burstIndex: 0,
|
||||||
|
arrivalTick, startTick: null, finishTick: null,
|
||||||
|
waitingTime, cpuTime: 0, ioTime: 0, responseTime: null,
|
||||||
|
quantumRemaining: 2, currentPriority: 5,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
const config: SchedulerConfig = {
|
||||||
|
algorithm: "HRRN", quantum: 2, contextSwitchTime: 0,
|
||||||
|
isPreemptive: false, agingEnabled: false, agingInterval: 5,
|
||||||
|
};
|
||||||
|
|
||||||
|
const p = (id: string, arrival: number, cpuDuration: number): Process => ({
|
||||||
|
id, name: id, arrivalTime: arrival, priority: 5, color: "#fff",
|
||||||
|
bursts: [{ type: "cpu", duration: cpuDuration }],
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("HRRN select()", () => {
|
||||||
|
it("returns null for empty queue", () => {
|
||||||
|
expect(hrrn.select([], config)).toBeNull();
|
||||||
|
});
|
||||||
|
|
||||||
|
it("picks process with highest response ratio", () => {
|
||||||
|
// ratio = (waitingTime + burstTime) / burstTime
|
||||||
|
// P1: (0 + 8) / 8 = 1.0
|
||||||
|
// P2: (6 + 3) / 3 = 3.0 ← highest
|
||||||
|
// P3: (2 + 5) / 5 = 1.4
|
||||||
|
const r1 = makeRt("p1", 8, 0);
|
||||||
|
const r2 = makeRt("p2", 3, 6);
|
||||||
|
const r3 = makeRt("p3", 5, 2);
|
||||||
|
expect(hrrn.select([r1, r2, r3], config)?.processId).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("tiebreaks equal ratio by arrival then id", () => {
|
||||||
|
// Both ratio = (4 + 4) / 4 = 2.0
|
||||||
|
const r1 = makeRt("p2", 4, 4, 1); // arrives at 1
|
||||||
|
const r2 = makeRt("p1", 4, 4, 2); // arrives at 2
|
||||||
|
expect(hrrn.select([r1, r2], config)?.processId).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("shouldPreempt always false", () => {
|
||||||
|
const a = makeRt("p1", 4, 0);
|
||||||
|
const b = makeRt("p2", 4, 10);
|
||||||
|
expect(hrrn.shouldPreempt(a, b, config)).toBe(false);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("HRRN integration", () => {
|
||||||
|
it("long-waiting short process wins over fresh long process", () => {
|
||||||
|
// P1 arrives at 0 with CPU:8 — occupies CPU first
|
||||||
|
// P2 arrives at 0 with CPU:4, waits for 8 ticks
|
||||||
|
// After P1 finishes: P2 has been waiting → ratio for P2 is high
|
||||||
|
// (No other choice here, but validates engine runs HRRN correctly)
|
||||||
|
const processes = [p("p1", 0, 4), p("p2", 4, 2)];
|
||||||
|
const engine = new SimulationEngine(processes, config);
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
// P1 runs ticks 0-3, P2 arrives at tick 4 and runs immediately
|
||||||
|
expect(ticks[4]?.cpuProcess).toBe("p2");
|
||||||
|
expect(engine.isFinished).toBe(true);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("HRRN selects high-ratio process over long process that just arrived", () => {
|
||||||
|
// P1(arrival=0, CPU:10) starts running
|
||||||
|
// P2(arrival=1, CPU:2), P3(arrival=1, CPU:8) both arrive at tick 1
|
||||||
|
// When P1 finishes, P2 has waited longer relative to its burst → wins HRRN
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, 3), // short; finishes tick 3
|
||||||
|
p("p2", 0, 6), // medium; waits 3 ticks → ratio = (3+6)/6 = 1.5
|
||||||
|
p("p3", 0, 2), // short; waits 3 ticks → ratio = (3+2)/2 = 2.5 ← wins
|
||||||
|
];
|
||||||
|
const engine = new SimulationEngine(processes, config);
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
// After P1 (ticks 0-2), P3 should win (ratio 2.5 > 1.5)
|
||||||
|
expect(ticks[3]?.cpuProcess).toBe("p3");
|
||||||
|
});
|
||||||
|
});
|
||||||
@@ -0,0 +1,163 @@
|
|||||||
|
import { describe, it, expect } from "vitest";
|
||||||
|
import { computeProcessMetrics, computeGlobalMetrics, classifyBound } from "../metrics";
|
||||||
|
import { SimulationEngine } from "../engine";
|
||||||
|
import type { Process, SchedulerConfig } from "../types";
|
||||||
|
|
||||||
|
const cfg = (overrides: Partial<SchedulerConfig> = {}): SchedulerConfig => ({
|
||||||
|
algorithm: "FCFS",
|
||||||
|
quantum: 2,
|
||||||
|
contextSwitchTime: 0,
|
||||||
|
isPreemptive: false,
|
||||||
|
agingEnabled: false,
|
||||||
|
agingInterval: 5,
|
||||||
|
...overrides,
|
||||||
|
});
|
||||||
|
|
||||||
|
const p = (id: string, arrivalTime: number, bursts: { type: "cpu" | "io"; duration: number }[]): Process => ({
|
||||||
|
id, name: id, arrivalTime, priority: 5, color: "#fff", bursts,
|
||||||
|
});
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// CT-03: Bound classification (static, on declared bursts)
|
||||||
|
// P1: CPU:8, IO:1, CPU:1 → cpuRatio = 9/10 = 90% → CPU Bound
|
||||||
|
// P2: CPU:1, IO:8, CPU:1 → cpuRatio = 2/10 = 20% → I/O Bound
|
||||||
|
// P3: CPU:4, IO:2, CPU:4 → cpuRatio = 8/10 = 80% → CPU Bound
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
describe("CT-03: classifyBound", () => {
|
||||||
|
it("P1 (CPU:8,IO:1,CPU:1) → CPU Bound", () => {
|
||||||
|
expect(classifyBound([{ type: "cpu", duration: 8 }, { type: "io", duration: 1 }, { type: "cpu", duration: 1 }]))
|
||||||
|
.toBe("CPU Bound");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("P2 (CPU:1,IO:8,CPU:1) → I/O Bound", () => {
|
||||||
|
expect(classifyBound([{ type: "cpu", duration: 1 }, { type: "io", duration: 8 }, { type: "cpu", duration: 1 }]))
|
||||||
|
.toBe("I/O Bound");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("P3 (CPU:4,IO:2,CPU:4) → CPU Bound", () => {
|
||||||
|
expect(classifyBound([{ type: "cpu", duration: 4 }, { type: "io", duration: 2 }, { type: "cpu", duration: 4 }]))
|
||||||
|
.toBe("CPU Bound");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("balanced process (CPU:5,IO:5) → Balanced", () => {
|
||||||
|
expect(classifyBound([{ type: "cpu", duration: 5 }, { type: "io", duration: 5 }]))
|
||||||
|
.toBe("Balanced");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("CPU-only process → CPU Bound", () => {
|
||||||
|
expect(classifyBound([{ type: "cpu", duration: 10 }])).toBe("CPU Bound");
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// computeProcessMetrics
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
describe("computeProcessMetrics", () => {
|
||||||
|
it("throws for non-terminated process", () => {
|
||||||
|
const engine = new SimulationEngine(
|
||||||
|
[p("p1", 0, [{ type: "cpu", duration: 5 }])],
|
||||||
|
cfg(),
|
||||||
|
);
|
||||||
|
engine.step(); // tick 0, not finished
|
||||||
|
const rt = engine.runtimeStates[0]!;
|
||||||
|
expect(() => computeProcessMetrics(rt)).toThrow();
|
||||||
|
});
|
||||||
|
|
||||||
|
it("CT-01 P1: response=0, turnaround=4, waiting=0, cpuTime=4", () => {
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 4 }]),
|
||||||
|
p("p2", 1, [{ type: "cpu", duration: 3 }]),
|
||||||
|
p("p3", 2, [{ type: "cpu", duration: 1 }]),
|
||||||
|
];
|
||||||
|
const engine = new SimulationEngine(processes, cfg());
|
||||||
|
engine.runAll();
|
||||||
|
const rt1 = engine.runtimeStates.find((r) => r.processId === "p1")!;
|
||||||
|
const m = computeProcessMetrics(rt1);
|
||||||
|
|
||||||
|
expect(m.responseTime).toBe(0);
|
||||||
|
expect(m.turnaroundTime).toBe(4);
|
||||||
|
expect(m.waitingTime).toBe(0);
|
||||||
|
expect(m.cpuTime).toBe(4);
|
||||||
|
expect(m.ioTime).toBe(0);
|
||||||
|
expect(m.boundType).toBe("CPU Bound");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("CT-01 P2: response=3, turnaround=6, waiting=3", () => {
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 4 }]),
|
||||||
|
p("p2", 1, [{ type: "cpu", duration: 3 }]),
|
||||||
|
p("p3", 2, [{ type: "cpu", duration: 1 }]),
|
||||||
|
];
|
||||||
|
const engine = new SimulationEngine(processes, cfg());
|
||||||
|
engine.runAll();
|
||||||
|
const rt2 = engine.runtimeStates.find((r) => r.processId === "p2")!;
|
||||||
|
const m = computeProcessMetrics(rt2);
|
||||||
|
|
||||||
|
expect(m.responseTime).toBe(3);
|
||||||
|
expect(m.turnaroundTime).toBe(6);
|
||||||
|
expect(m.waitingTime).toBe(3);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("process with I/O: correct ioTime, boundType", () => {
|
||||||
|
const engine = new SimulationEngine(
|
||||||
|
[p("p1", 0, [{ type: "cpu", duration: 2 }, { type: "io", duration: 8 }, { type: "cpu", duration: 2 }])],
|
||||||
|
cfg(),
|
||||||
|
);
|
||||||
|
engine.runAll();
|
||||||
|
const rt = engine.runtimeStates[0]!;
|
||||||
|
const m = computeProcessMetrics(rt);
|
||||||
|
expect(m.cpuTime).toBe(4);
|
||||||
|
expect(m.ioTime).toBe(8);
|
||||||
|
expect(m.boundType).toBe("I/O Bound");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("cpuUtilization: CPU-only → 100%", () => {
|
||||||
|
const engine = new SimulationEngine(
|
||||||
|
[p("p1", 0, [{ type: "cpu", duration: 4 }])],
|
||||||
|
cfg(),
|
||||||
|
);
|
||||||
|
engine.runAll();
|
||||||
|
const rt = engine.runtimeStates[0]!;
|
||||||
|
const m = computeProcessMetrics(rt);
|
||||||
|
expect(m.cpuUtilization).toBe(100);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// computeGlobalMetrics
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
describe("computeGlobalMetrics", () => {
|
||||||
|
it("CT-01 global metrics", () => {
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 4 }]),
|
||||||
|
p("p2", 1, [{ type: "cpu", duration: 3 }]),
|
||||||
|
p("p3", 2, [{ type: "cpu", duration: 1 }]),
|
||||||
|
];
|
||||||
|
const engine = new SimulationEngine(processes, cfg());
|
||||||
|
engine.runAll();
|
||||||
|
const rts = engine.runtimeStates;
|
||||||
|
const pMetrics = rts.map(computeProcessMetrics);
|
||||||
|
const g = computeGlobalMetrics(pMetrics, engine.currentTick + 1);
|
||||||
|
|
||||||
|
// Avg response: (0 + 3 + 5) / 3 = 8/3 ≈ 2.667
|
||||||
|
expect(g.avgResponseTime).toBeCloseTo(8 / 3, 5);
|
||||||
|
// Avg turnaround: (4 + 6 + 6) / 3 = 16/3 ≈ 5.333
|
||||||
|
expect(g.avgTurnaroundTime).toBeCloseTo(16 / 3, 5);
|
||||||
|
// Avg waiting: (0 + 3 + 5) / 3 = 8/3 ≈ 2.667
|
||||||
|
expect(g.avgWaitingTime).toBeCloseTo(8 / 3, 5);
|
||||||
|
// Throughput: 3 processes / 8 ticks = 0.375
|
||||||
|
expect(g.cpuThroughput).toBeCloseTo(3 / 8, 5);
|
||||||
|
// CPU utilization: (4+3+1)/8 * 100 = 100%
|
||||||
|
expect(g.cpuUtilization).toBeCloseTo(100, 5);
|
||||||
|
expect(g.totalSimulationTime).toBe(8);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("handles empty metrics array", () => {
|
||||||
|
const g = computeGlobalMetrics([], 0);
|
||||||
|
expect(g.avgResponseTime).toBe(0);
|
||||||
|
expect(g.cpuUtilization).toBe(0);
|
||||||
|
});
|
||||||
|
});
|
||||||
@@ -0,0 +1,118 @@
|
|||||||
|
import { describe, it, expect } from "vitest";
|
||||||
|
import { priorityNp, priorityP } from "../algorithms/priority";
|
||||||
|
import { SimulationEngine } from "../engine";
|
||||||
|
import type { Process, ProcessRuntime, SchedulerConfig } from "../types";
|
||||||
|
|
||||||
|
function makeRt(id: string, priority: number, arrivalTick = 0): ProcessRuntime {
|
||||||
|
return {
|
||||||
|
processId: id, state: "Ready", remainingBurst: 4, burstIndex: 0,
|
||||||
|
arrivalTick, startTick: null, finishTick: null,
|
||||||
|
waitingTime: 0, cpuTime: 0, ioTime: 0, responseTime: null,
|
||||||
|
quantumRemaining: 2, currentPriority: priority,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
const cfgNp: SchedulerConfig = {
|
||||||
|
algorithm: "PRIORITY_NP", quantum: 2, contextSwitchTime: 0,
|
||||||
|
isPreemptive: false, agingEnabled: false, agingInterval: 5,
|
||||||
|
};
|
||||||
|
const cfgP: SchedulerConfig = {
|
||||||
|
algorithm: "PRIORITY_P", quantum: 2, contextSwitchTime: 0,
|
||||||
|
isPreemptive: true, agingEnabled: false, agingInterval: 5,
|
||||||
|
};
|
||||||
|
|
||||||
|
const p = (id: string, arrival: number, priority: number, cpuDuration: number): Process => ({
|
||||||
|
id, name: id, arrivalTime: arrival, priority, color: "#fff",
|
||||||
|
bursts: [{ type: "cpu", duration: cpuDuration }],
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("PRIORITY_NP select()", () => {
|
||||||
|
it("picks lowest priority number (highest priority)", () => {
|
||||||
|
const r1 = makeRt("p1", 5);
|
||||||
|
const r2 = makeRt("p2", 2);
|
||||||
|
const r3 = makeRt("p3", 8);
|
||||||
|
expect(priorityNp.select([r1, r2, r3], cfgNp)?.processId).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("tiebreaks by arrival then id", () => {
|
||||||
|
const r1 = makeRt("p2", 3, 2);
|
||||||
|
const r2 = makeRt("p1", 3, 5); // p1 arrives later
|
||||||
|
expect(priorityNp.select([r1, r2], cfgNp)?.processId).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("shouldPreempt always false", () => {
|
||||||
|
const a = makeRt("p1", 5);
|
||||||
|
const b = makeRt("p2", 1);
|
||||||
|
expect(priorityNp.shouldPreempt(a, b, cfgNp)).toBe(false);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("PRIORITY_P shouldPreempt()", () => {
|
||||||
|
it("preempts when candidate has higher priority (lower number)", () => {
|
||||||
|
const current = makeRt("p1", 5);
|
||||||
|
const candidate = makeRt("p2", 2);
|
||||||
|
expect(priorityP.shouldPreempt(current, candidate, cfgP)).toBe(true);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("does NOT preempt on equal priority", () => {
|
||||||
|
const current = makeRt("p1", 3);
|
||||||
|
const candidate = makeRt("p2", 3);
|
||||||
|
expect(priorityP.shouldPreempt(current, candidate, cfgP)).toBe(false);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("does NOT preempt when current has higher priority", () => {
|
||||||
|
const current = makeRt("p1", 2);
|
||||||
|
const candidate = makeRt("p2", 5);
|
||||||
|
expect(priorityP.shouldPreempt(current, candidate, cfgP)).toBe(false);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("Priority NP integration", () => {
|
||||||
|
it("selects highest-priority process regardless of arrival", () => {
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, 5, 3), // low priority
|
||||||
|
p("p2", 0, 1, 3), // high priority
|
||||||
|
];
|
||||||
|
const engine = new SimulationEngine(processes, cfgNp);
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
// P2 (priority 1) should run first
|
||||||
|
expect(ticks[0]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[1]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[2]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[3]?.cpuProcess).toBe("p1");
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("Priority P + aging", () => {
|
||||||
|
it("aging decrements currentPriority for waiting processes", () => {
|
||||||
|
// P1 priority=1 runs first; P2 priority=10 waits
|
||||||
|
// After agingInterval=2 ticks, P2's priority should drop
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, 1, 10), // runs for 10 ticks
|
||||||
|
p("p2", 0, 10, 5), // waits, aging should help
|
||||||
|
];
|
||||||
|
const engine = new SimulationEngine(processes, {
|
||||||
|
...cfgNp, algorithm: "PRIORITY_NP", agingEnabled: true, agingInterval: 2,
|
||||||
|
});
|
||||||
|
engine.step(); // tick 0
|
||||||
|
engine.step(); // tick 1
|
||||||
|
engine.step(); // tick 2 — aging fires (tick % 2 === 0), P2 priority 10→9
|
||||||
|
const rts = engine.runtimeStates;
|
||||||
|
const rt2 = rts.find((r) => r.processId === "p2")!;
|
||||||
|
expect(rt2.currentPriority).toBe(9);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("aging does not reduce priority below 1", () => {
|
||||||
|
const processes = [p("p1", 0, 1, 5)];
|
||||||
|
// Construct a runtime with priority already at 1 and test the engine handles it
|
||||||
|
const engine = new SimulationEngine(processes, {
|
||||||
|
...cfgNp, agingEnabled: true, agingInterval: 1,
|
||||||
|
});
|
||||||
|
// Run a few ticks — priority should never go below 1
|
||||||
|
for (let i = 0; i < 5; i++) {
|
||||||
|
if (!engine.isFinished) engine.step();
|
||||||
|
}
|
||||||
|
const rt = engine.runtimeStates[0]!;
|
||||||
|
expect(rt.currentPriority).toBeGreaterThanOrEqual(1);
|
||||||
|
});
|
||||||
|
});
|
||||||
@@ -0,0 +1,116 @@
|
|||||||
|
import { describe, it, expect } from "vitest";
|
||||||
|
import { rr } from "../algorithms/rr";
|
||||||
|
import { SimulationEngine } from "../engine";
|
||||||
|
import type { Process, ProcessRuntime, SchedulerConfig } from "../types";
|
||||||
|
|
||||||
|
function makeRt(id: string, quantumRemaining = 2): ProcessRuntime {
|
||||||
|
return {
|
||||||
|
processId: id, state: "Running", remainingBurst: 4, burstIndex: 0,
|
||||||
|
arrivalTick: 0, startTick: 0, finishTick: null,
|
||||||
|
waitingTime: 0, cpuTime: 0, ioTime: 0, responseTime: null,
|
||||||
|
quantumRemaining, currentPriority: 5,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
const config: SchedulerConfig = {
|
||||||
|
algorithm: "RR", quantum: 2, contextSwitchTime: 0,
|
||||||
|
isPreemptive: false, agingEnabled: false, agingInterval: 5,
|
||||||
|
};
|
||||||
|
|
||||||
|
const p = (id: string, arrival: number, cpuDuration: number): Process => ({
|
||||||
|
id, name: id, arrivalTime: arrival, priority: 5, color: "#fff",
|
||||||
|
bursts: [{ type: "cpu", duration: cpuDuration }],
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("RR select()", () => {
|
||||||
|
it("returns front of queue (FIFO)", () => {
|
||||||
|
const r1: ProcessRuntime = { ...makeRt("p1"), state: "Ready" };
|
||||||
|
const r2: ProcessRuntime = { ...makeRt("p2"), state: "Ready" };
|
||||||
|
expect(rr.select([r1, r2], config)?.processId).toBe("p1");
|
||||||
|
expect(rr.select([r2, r1], config)?.processId).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("returns null for empty queue", () => {
|
||||||
|
expect(rr.select([], config)).toBeNull();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("RR isQuantumExpired()", () => {
|
||||||
|
it("returns true when quantumRemaining <= 0", () => {
|
||||||
|
expect(rr.isQuantumExpired(makeRt("p1", 0), config)).toBe(true);
|
||||||
|
expect(rr.isQuantumExpired(makeRt("p1", -1), config)).toBe(true);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("returns false when quantum not yet exhausted", () => {
|
||||||
|
expect(rr.isQuantumExpired(makeRt("p1", 1), config)).toBe(false);
|
||||||
|
expect(rr.isQuantumExpired(makeRt("p1", 2), config)).toBe(false);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("RR shouldPreempt()", () => {
|
||||||
|
it("always returns false (preemption via quantum expiry only)", () => {
|
||||||
|
const a = makeRt("p1");
|
||||||
|
const b = makeRt("p2");
|
||||||
|
expect(rr.shouldPreempt(a, b, config)).toBe(false);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// CT-02 integration
|
||||||
|
describe("CT-02: Round Robin integration", () => {
|
||||||
|
it("produces correct Gantt: P1(0-2),P2(2-4),P3(4-5),P1(5-7),P2(7-8),P1(8-9)", () => {
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, 5),
|
||||||
|
p("p2", 0, 3),
|
||||||
|
p("p3", 0, 1),
|
||||||
|
];
|
||||||
|
const engine = new SimulationEngine(processes, config);
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
const cpu = ticks.map((t) => t.cpuProcess);
|
||||||
|
|
||||||
|
expect(cpu).toHaveLength(9);
|
||||||
|
expect(cpu[0]).toBe("p1");
|
||||||
|
expect(cpu[1]).toBe("p1");
|
||||||
|
expect(cpu[2]).toBe("p2");
|
||||||
|
expect(cpu[3]).toBe("p2");
|
||||||
|
expect(cpu[4]).toBe("p3");
|
||||||
|
expect(cpu[5]).toBe("p1");
|
||||||
|
expect(cpu[6]).toBe("p1");
|
||||||
|
expect(cpu[7]).toBe("p2");
|
||||||
|
expect(cpu[8]).toBe("p1");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("process finishing before quantum exhausted does not rotate", () => {
|
||||||
|
const engine = new SimulationEngine(
|
||||||
|
[p("p1", 0, 1), p("p2", 0, 3)],
|
||||||
|
config,
|
||||||
|
);
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
// P1 finishes at tick 1 (1 < quantum 2), P2 gets CPU immediately
|
||||||
|
expect(ticks[0]?.cpuProcess).toBe("p1");
|
||||||
|
expect(ticks[1]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[2]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[3]?.cpuProcess).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("process returning from I/O enters tail of queue", () => {
|
||||||
|
// P1: CPU:1 → IO:1 → CPU:1; P2: CPU:3
|
||||||
|
// With quantum=2: P1 runs tick 0, goes to IO; P2 runs ticks 1-2,3 (or until P1 returns)
|
||||||
|
// P1 IO done at tick 2, enters tail → P2 finishes first if still running
|
||||||
|
const processes: Process[] = [
|
||||||
|
{ id: "p1", name: "P1", arrivalTime: 0, priority: 5, color: "#fff", bursts: [{ type: "cpu", duration: 1 }, { type: "io", duration: 2 }, { type: "cpu", duration: 1 }] },
|
||||||
|
{ id: "p2", name: "P2", arrivalTime: 0, priority: 5, color: "#fff", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
];
|
||||||
|
const engine = new SimulationEngine(processes, config);
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
const rts = engine.runtimeStates;
|
||||||
|
// Both should terminate
|
||||||
|
expect(rts.every((r) => r.state === "Terminated")).toBe(true);
|
||||||
|
// P1's second CPU burst should happen after P2 gets at least one quantum
|
||||||
|
const rt2 = rts.find((r) => r.processId === "p2")!;
|
||||||
|
const rt1 = rts.find((r) => r.processId === "p1")!;
|
||||||
|
// P2 has 3 CPU ticks and P1 re-enters after IO — verify both complete
|
||||||
|
expect(rt2.cpuTime).toBe(3);
|
||||||
|
expect(rt1.cpuTime).toBe(2);
|
||||||
|
void ticks; // used for debugging if needed
|
||||||
|
});
|
||||||
|
});
|
||||||
@@ -0,0 +1,94 @@
|
|||||||
|
import { describe, it, expect } from "vitest";
|
||||||
|
import { sjfNp, srtf } from "../algorithms/sjf";
|
||||||
|
import { SimulationEngine } from "../engine";
|
||||||
|
import type { Process, ProcessRuntime, SchedulerConfig } from "../types";
|
||||||
|
|
||||||
|
function makeRt(id: string, remainingBurst: number, arrivalTick = 0): ProcessRuntime {
|
||||||
|
return {
|
||||||
|
processId: id, state: "Ready", remainingBurst, burstIndex: 0,
|
||||||
|
arrivalTick, startTick: null, finishTick: null,
|
||||||
|
waitingTime: 0, cpuTime: 0, ioTime: 0, responseTime: null,
|
||||||
|
quantumRemaining: 2, currentPriority: 5,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
const config: SchedulerConfig = {
|
||||||
|
algorithm: "SJF_NP", quantum: 2, contextSwitchTime: 0,
|
||||||
|
isPreemptive: false, agingEnabled: false, agingInterval: 5,
|
||||||
|
};
|
||||||
|
|
||||||
|
const p = (id: string, arrival: number, bursts: { type: "cpu" | "io"; duration: number }[]): Process => ({
|
||||||
|
id, name: id, arrivalTime: arrival, priority: 5, color: "#fff", bursts,
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("SJF_NP select()", () => {
|
||||||
|
it("returns null for empty queue", () => {
|
||||||
|
expect(sjfNp.select([], config)).toBeNull();
|
||||||
|
});
|
||||||
|
|
||||||
|
it("picks shortest remaining burst", () => {
|
||||||
|
const r1 = makeRt("p1", 8);
|
||||||
|
const r2 = makeRt("p2", 3);
|
||||||
|
const r3 = makeRt("p3", 5);
|
||||||
|
expect(sjfNp.select([r1, r2, r3], config)?.processId).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("tiebreaks equal burst by arrival then id", () => {
|
||||||
|
const r1 = makeRt("p2", 4, 1);
|
||||||
|
const r2 = makeRt("p1", 4, 2);
|
||||||
|
// p2 arrives earlier
|
||||||
|
expect(sjfNp.select([r1, r2], config)?.processId).toBe("p2");
|
||||||
|
});
|
||||||
|
|
||||||
|
it("shouldPreempt always false", () => {
|
||||||
|
const a = makeRt("p1", 4);
|
||||||
|
const b = makeRt("p2", 2);
|
||||||
|
expect(sjfNp.shouldPreempt(a, b, config)).toBe(false);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
describe("SRTF shouldPreempt()", () => {
|
||||||
|
it("preempts when candidate has strictly smaller burst", () => {
|
||||||
|
const current = makeRt("p1", 7);
|
||||||
|
const candidate = makeRt("p2", 4);
|
||||||
|
expect(srtf.shouldPreempt(current, candidate, config)).toBe(true);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("does NOT preempt on equal remaining burst", () => {
|
||||||
|
const current = makeRt("p1", 4);
|
||||||
|
const candidate = makeRt("p2", 4);
|
||||||
|
expect(srtf.shouldPreempt(current, candidate, config)).toBe(false);
|
||||||
|
});
|
||||||
|
|
||||||
|
it("does NOT preempt when current has smaller burst", () => {
|
||||||
|
const current = makeRt("p1", 3);
|
||||||
|
const candidate = makeRt("p2", 6);
|
||||||
|
expect(srtf.shouldPreempt(current, candidate, config)).toBe(false);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// CT-04 integration via engine
|
||||||
|
describe("CT-04: SRTF Preemption (integration)", () => {
|
||||||
|
it("P2 preempts P1 at tick 1, finishes tick 5, P1 finishes tick 12", () => {
|
||||||
|
const processes = [
|
||||||
|
p("p1", 0, [{ type: "cpu", duration: 8 }]),
|
||||||
|
p("p2", 1, [{ type: "cpu", duration: 4 }]),
|
||||||
|
];
|
||||||
|
const engine = new SimulationEngine(processes, {
|
||||||
|
...config, algorithm: "SJF_P",
|
||||||
|
});
|
||||||
|
const ticks = engine.runAll();
|
||||||
|
const rts = engine.runtimeStates;
|
||||||
|
|
||||||
|
expect(ticks[0]?.cpuProcess).toBe("p1");
|
||||||
|
expect(ticks[1]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[2]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[3]?.cpuProcess).toBe("p2");
|
||||||
|
expect(ticks[4]?.cpuProcess).toBe("p2");
|
||||||
|
|
||||||
|
const rt2 = rts.find((r) => r.processId === "p2")!;
|
||||||
|
const rt1 = rts.find((r) => r.processId === "p1")!;
|
||||||
|
expect(rt2.finishTick).toBe(5);
|
||||||
|
expect(rt1.finishTick).toBe(12);
|
||||||
|
});
|
||||||
|
});
|
||||||
@@ -0,0 +1,21 @@
|
|||||||
|
import type { SchedulerAlgorithm } from "./index";
|
||||||
|
import { tiebreak } from "./utils";
|
||||||
|
|
||||||
|
/**
|
||||||
|
* FCFS — First Come, First Served
|
||||||
|
* Non-preemptive. Selects the process with earliest arrival; tiebreak by id.
|
||||||
|
*/
|
||||||
|
export const fcfs: SchedulerAlgorithm = {
|
||||||
|
select(readyQueue) {
|
||||||
|
if (readyQueue.length === 0) return null;
|
||||||
|
return [...readyQueue].sort(tiebreak)[0] ?? null;
|
||||||
|
},
|
||||||
|
|
||||||
|
shouldPreempt() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
|
||||||
|
isQuantumExpired() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
};
|
||||||
@@ -0,0 +1,33 @@
|
|||||||
|
import type { ProcessRuntime } from "../types";
|
||||||
|
import type { SchedulerAlgorithm } from "./index";
|
||||||
|
import { tiebreak } from "./utils";
|
||||||
|
|
||||||
|
function hrrnRatio(rt: ProcessRuntime): number {
|
||||||
|
// ratio = (waitingTime + burstTime) / burstTime
|
||||||
|
// remainingBurst > 0 is guaranteed for processes in the ready queue
|
||||||
|
if (rt.remainingBurst <= 0) return Infinity;
|
||||||
|
return (rt.waitingTime + rt.remainingBurst) / rt.remainingBurst;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* HRRN — Highest Response Ratio Next
|
||||||
|
* Non-preemptive. Balances waiting time and burst length to prevent starvation.
|
||||||
|
*/
|
||||||
|
export const hrrn: SchedulerAlgorithm = {
|
||||||
|
select(readyQueue) {
|
||||||
|
if (readyQueue.length === 0) return null;
|
||||||
|
return [...readyQueue].sort((a, b) => {
|
||||||
|
const ratioDiff = hrrnRatio(b) - hrrnRatio(a); // descending
|
||||||
|
if (ratioDiff !== 0) return ratioDiff;
|
||||||
|
return tiebreak(a, b);
|
||||||
|
})[0] ?? null;
|
||||||
|
},
|
||||||
|
|
||||||
|
shouldPreempt() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
|
||||||
|
isQuantumExpired() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
};
|
||||||
@@ -0,0 +1,59 @@
|
|||||||
|
import type { ProcessRuntime, SchedulerConfig, SchedulingAlgorithm } from "../types";
|
||||||
|
import { fcfs } from "./fcfs";
|
||||||
|
import { sjfNp, srtf } from "./sjf";
|
||||||
|
import { rr } from "./rr";
|
||||||
|
import { priorityNp, priorityP } from "./priority";
|
||||||
|
import { hrrn } from "./hrrn";
|
||||||
|
import { multilevel } from "./multilevel";
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// SchedulerAlgorithm interface
|
||||||
|
// All implementations must be pure (no mutation of the queue).
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export interface SchedulerAlgorithm {
|
||||||
|
/**
|
||||||
|
* Select the best process to dispatch from the ready queue.
|
||||||
|
* Returns null if the queue is empty.
|
||||||
|
* Must NOT mutate the array; the engine handles removal.
|
||||||
|
*/
|
||||||
|
select(
|
||||||
|
readyQueue: readonly ProcessRuntime[],
|
||||||
|
config: SchedulerConfig,
|
||||||
|
): ProcessRuntime | null;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* For preemptive algorithms: should the currently-running process
|
||||||
|
* be replaced by `candidate`?
|
||||||
|
* Called only when cpuProcess != null and a candidate exists.
|
||||||
|
*/
|
||||||
|
shouldPreempt(
|
||||||
|
current: ProcessRuntime,
|
||||||
|
candidate: ProcessRuntime,
|
||||||
|
config: SchedulerConfig,
|
||||||
|
): boolean;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* RR only: has the process exhausted its quantum?
|
||||||
|
* For all other algorithms this must return false.
|
||||||
|
*/
|
||||||
|
isQuantumExpired(
|
||||||
|
runtime: ProcessRuntime,
|
||||||
|
config: SchedulerConfig,
|
||||||
|
): boolean;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Dispatch table — engine looks up algorithm by name
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export const algorithms: Record<SchedulingAlgorithm, SchedulerAlgorithm> = {
|
||||||
|
FCFS: fcfs,
|
||||||
|
SJF_NP: sjfNp,
|
||||||
|
SJF_P: srtf,
|
||||||
|
RR: rr,
|
||||||
|
PRIORITY_NP: priorityNp,
|
||||||
|
PRIORITY_P: priorityP,
|
||||||
|
HRRN: hrrn,
|
||||||
|
MULTILEVEL: multilevel,
|
||||||
|
};
|
||||||
@@ -0,0 +1,19 @@
|
|||||||
|
import type { SchedulerAlgorithm } from "./index";
|
||||||
|
|
||||||
|
/**
|
||||||
|
* MULTILEVEL — Multilevel Queue (stub)
|
||||||
|
* Not yet implemented. Deferred to a later phase.
|
||||||
|
*/
|
||||||
|
export const multilevel: SchedulerAlgorithm = {
|
||||||
|
select() {
|
||||||
|
throw new Error("MULTILEVEL scheduling is not yet implemented");
|
||||||
|
},
|
||||||
|
|
||||||
|
shouldPreempt() {
|
||||||
|
throw new Error("MULTILEVEL scheduling is not yet implemented");
|
||||||
|
},
|
||||||
|
|
||||||
|
isQuantumExpired() {
|
||||||
|
throw new Error("MULTILEVEL scheduling is not yet implemented");
|
||||||
|
},
|
||||||
|
};
|
||||||
@@ -0,0 +1,49 @@
|
|||||||
|
import type { ProcessRuntime } from "../types";
|
||||||
|
import type { SchedulerAlgorithm } from "./index";
|
||||||
|
import { tiebreak } from "./utils";
|
||||||
|
|
||||||
|
function prioritySort(a: ProcessRuntime, b: ProcessRuntime): number {
|
||||||
|
// Lower number = higher priority
|
||||||
|
if (a.currentPriority !== b.currentPriority)
|
||||||
|
return a.currentPriority - b.currentPriority;
|
||||||
|
return tiebreak(a, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Priority Non-Preemptive
|
||||||
|
* Selects process with lowest priority number; does not interrupt running process.
|
||||||
|
*/
|
||||||
|
export const priorityNp: SchedulerAlgorithm = {
|
||||||
|
select(readyQueue) {
|
||||||
|
if (readyQueue.length === 0) return null;
|
||||||
|
return [...readyQueue].sort(prioritySort)[0] ?? null;
|
||||||
|
},
|
||||||
|
|
||||||
|
shouldPreempt() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
|
||||||
|
isQuantumExpired() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Priority Preemptive
|
||||||
|
* Preempts running process if a higher-priority (lower number) process arrives.
|
||||||
|
* Aging is applied by the engine — currentPriority decrements over time.
|
||||||
|
*/
|
||||||
|
export const priorityP: SchedulerAlgorithm = {
|
||||||
|
select(readyQueue) {
|
||||||
|
if (readyQueue.length === 0) return null;
|
||||||
|
return [...readyQueue].sort(prioritySort)[0] ?? null;
|
||||||
|
},
|
||||||
|
|
||||||
|
shouldPreempt(current, candidate) {
|
||||||
|
return candidate.currentPriority < current.currentPriority;
|
||||||
|
},
|
||||||
|
|
||||||
|
isQuantumExpired() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
};
|
||||||
@@ -0,0 +1,22 @@
|
|||||||
|
import type { SchedulerAlgorithm } from "./index";
|
||||||
|
|
||||||
|
/**
|
||||||
|
* RR — Round Robin
|
||||||
|
* FIFO queue with a configurable quantum.
|
||||||
|
* select() returns the front of the queue (insertion-order maintained by engine).
|
||||||
|
* Preemption is driven by quantum expiry, not by a better candidate.
|
||||||
|
*/
|
||||||
|
export const rr: SchedulerAlgorithm = {
|
||||||
|
select(readyQueue) {
|
||||||
|
return readyQueue[0] ?? null;
|
||||||
|
},
|
||||||
|
|
||||||
|
// RR does not preempt based on candidate priority; quantum expiry handles it.
|
||||||
|
shouldPreempt() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
|
||||||
|
isQuantumExpired(runtime) {
|
||||||
|
return runtime.quantumRemaining <= 0;
|
||||||
|
},
|
||||||
|
};
|
||||||
@@ -0,0 +1,48 @@
|
|||||||
|
import type { ProcessRuntime } from "../types";
|
||||||
|
import type { SchedulerAlgorithm } from "./index";
|
||||||
|
import { tiebreak } from "./utils";
|
||||||
|
|
||||||
|
function sjfSort(a: ProcessRuntime, b: ProcessRuntime): number {
|
||||||
|
if (a.remainingBurst !== b.remainingBurst)
|
||||||
|
return a.remainingBurst - b.remainingBurst;
|
||||||
|
return tiebreak(a, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* SJF Non-Preemptive — Shortest Job First
|
||||||
|
* Selects the process with the smallest remaining burst; no preemption.
|
||||||
|
*/
|
||||||
|
export const sjfNp: SchedulerAlgorithm = {
|
||||||
|
select(readyQueue) {
|
||||||
|
if (readyQueue.length === 0) return null;
|
||||||
|
return [...readyQueue].sort(sjfSort)[0] ?? null;
|
||||||
|
},
|
||||||
|
|
||||||
|
shouldPreempt() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
|
||||||
|
isQuantumExpired() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* SRTF — Shortest Remaining Time First (SJF Preemptive)
|
||||||
|
* At each tick, preempts if a ready process has strictly smaller remainingBurst.
|
||||||
|
* Equal remaining burst → no preemption (avoids unnecessary context switches).
|
||||||
|
*/
|
||||||
|
export const srtf: SchedulerAlgorithm = {
|
||||||
|
select(readyQueue) {
|
||||||
|
if (readyQueue.length === 0) return null;
|
||||||
|
return [...readyQueue].sort(sjfSort)[0] ?? null;
|
||||||
|
},
|
||||||
|
|
||||||
|
shouldPreempt(current, candidate) {
|
||||||
|
return candidate.remainingBurst < current.remainingBurst;
|
||||||
|
},
|
||||||
|
|
||||||
|
isQuantumExpired() {
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
};
|
||||||
@@ -0,0 +1,11 @@
|
|||||||
|
import type { ProcessRuntime } from "../types";
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Shared tiebreak helper (all algorithms use this)
|
||||||
|
// Primary: arrivalTick ASC Secondary: processId lexicographic ASC
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export function tiebreak(a: ProcessRuntime, b: ProcessRuntime): number {
|
||||||
|
if (a.arrivalTick !== b.arrivalTick) return a.arrivalTick - b.arrivalTick;
|
||||||
|
return a.processId.localeCompare(b.processId);
|
||||||
|
}
|
||||||
@@ -0,0 +1,270 @@
|
|||||||
|
import type {
|
||||||
|
Process,
|
||||||
|
ProcessRuntime,
|
||||||
|
SchedulerConfig,
|
||||||
|
SimTick,
|
||||||
|
StateLabel,
|
||||||
|
} from "./types";
|
||||||
|
import { algorithms } from "./algorithms/index";
|
||||||
|
import type { SchedulerAlgorithm } from "./algorithms/index";
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// SimulationEngine
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export class SimulationEngine {
|
||||||
|
private readonly _processes: Process[];
|
||||||
|
private readonly _config: SchedulerConfig;
|
||||||
|
private readonly _algorithm: SchedulerAlgorithm;
|
||||||
|
|
||||||
|
private _tick: number; // starts at -1; incremented at top of step()
|
||||||
|
private _runtimes: Map<string, ProcessRuntime>;
|
||||||
|
private _cpuProcess: ProcessRuntime | null;
|
||||||
|
private _readyQueue: ProcessRuntime[]; // ordered array (FIFO for RR)
|
||||||
|
private _ioQueue: ProcessRuntime[];
|
||||||
|
private _contextSwitchRemaining: number;
|
||||||
|
private _prevCpuProcessId: string | null; // track context switch detection
|
||||||
|
|
||||||
|
constructor(processes: Process[], config: SchedulerConfig) {
|
||||||
|
if (processes.length === 0) throw new Error("At least one process required");
|
||||||
|
this._processes = processes;
|
||||||
|
this._config = config;
|
||||||
|
this._algorithm = algorithms[config.algorithm];
|
||||||
|
this._tick = -1;
|
||||||
|
this._cpuProcess = null;
|
||||||
|
this._readyQueue = [];
|
||||||
|
this._ioQueue = [];
|
||||||
|
this._contextSwitchRemaining = 0;
|
||||||
|
this._prevCpuProcessId = null;
|
||||||
|
this._runtimes = new Map(processes.map((p) => [p.id, initRuntime(p, config)]));
|
||||||
|
}
|
||||||
|
|
||||||
|
// ----------------------------------------------------------
|
||||||
|
// Public API
|
||||||
|
// ----------------------------------------------------------
|
||||||
|
|
||||||
|
/** Advance one tick; return snapshot of that tick. */
|
||||||
|
step(): SimTick {
|
||||||
|
if (this.isFinished) throw new Error("Simulation is already finished");
|
||||||
|
|
||||||
|
this._tick++;
|
||||||
|
|
||||||
|
// 1. Arrivals
|
||||||
|
for (const p of this._processes) {
|
||||||
|
const rt = this._runtimes.get(p.id)!;
|
||||||
|
if (p.arrivalTime === this._tick && rt.state === "New") {
|
||||||
|
this._transition(rt, "Ready");
|
||||||
|
this._readyQueue.push(rt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 2. Preemption & Quantum Check (from previous tick's state)
|
||||||
|
if (this._cpuProcess !== null && this._readyQueue.length > 0) {
|
||||||
|
const candidate = this._algorithm.select(this._readyQueue, this._config);
|
||||||
|
if (
|
||||||
|
candidate !== null &&
|
||||||
|
this._algorithm.shouldPreempt(this._cpuProcess, candidate, this._config)
|
||||||
|
) {
|
||||||
|
const cpu = this._cpuProcess;
|
||||||
|
this._transition(cpu, "Ready");
|
||||||
|
this._readyQueue.push(cpu);
|
||||||
|
this._cpuProcess = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 3. Dispatch / Context Switch
|
||||||
|
if (this._contextSwitchRemaining > 0) {
|
||||||
|
// Doing context switch this tick
|
||||||
|
// We don't dispatch.
|
||||||
|
} else {
|
||||||
|
if (this._cpuProcess === null && this._readyQueue.length > 0) {
|
||||||
|
const next = this._algorithm.select(this._readyQueue, this._config);
|
||||||
|
if (next !== null) {
|
||||||
|
const idx = this._readyQueue.indexOf(next);
|
||||||
|
if (idx !== -1) this._readyQueue.splice(idx, 1);
|
||||||
|
|
||||||
|
if (
|
||||||
|
this._config.contextSwitchTime > 0 &&
|
||||||
|
this._prevCpuProcessId !== null &&
|
||||||
|
this._prevCpuProcessId !== next.processId
|
||||||
|
) {
|
||||||
|
this._readyQueue.unshift(next);
|
||||||
|
this._contextSwitchRemaining = this._config.contextSwitchTime;
|
||||||
|
this._prevCpuProcessId = next.processId;
|
||||||
|
} else {
|
||||||
|
if (next.startTick === null) next.startTick = this._tick;
|
||||||
|
next.quantumRemaining = this._config.quantum;
|
||||||
|
this._transition(next, "Running");
|
||||||
|
this._prevCpuProcessId = next.processId;
|
||||||
|
this._cpuProcess = next;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 4. Take Snapshot representing what happens DURING this tick
|
||||||
|
const snapshot = this._snapshot();
|
||||||
|
|
||||||
|
// 5. Passage of Time (Simulate execution for 1 tick)
|
||||||
|
if (this._contextSwitchRemaining > 0) {
|
||||||
|
this._contextSwitchRemaining--;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (this._cpuProcess !== null) {
|
||||||
|
const cpu = this._cpuProcess;
|
||||||
|
cpu.remainingBurst--;
|
||||||
|
cpu.cpuTime++;
|
||||||
|
cpu.quantumRemaining--;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (const rt of this._ioQueue) {
|
||||||
|
rt.remainingBurst--;
|
||||||
|
rt.ioTime++;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (const rt of this._readyQueue) {
|
||||||
|
rt.waitingTime++;
|
||||||
|
}
|
||||||
|
|
||||||
|
// 6. Aging (Priority)
|
||||||
|
if (
|
||||||
|
this._config.agingEnabled &&
|
||||||
|
this._tick > 0 &&
|
||||||
|
this._tick % this._config.agingInterval === 0
|
||||||
|
) {
|
||||||
|
for (const rt of this._readyQueue) {
|
||||||
|
rt.currentPriority = Math.max(1, rt.currentPriority - 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 7. Process completions / transition to next state for NEXT tick
|
||||||
|
if (this._cpuProcess !== null) {
|
||||||
|
const cpu = this._cpuProcess;
|
||||||
|
if (cpu.remainingBurst === 0) {
|
||||||
|
this._advanceBurst(cpu);
|
||||||
|
const process = this._processes.find((p) => p.id === cpu.processId)!;
|
||||||
|
const nextBurst = process.bursts[cpu.burstIndex];
|
||||||
|
if (nextBurst !== undefined && nextBurst.type === "io") {
|
||||||
|
this._transition(cpu, "Waiting");
|
||||||
|
this._ioQueue.push(cpu);
|
||||||
|
} else if (nextBurst !== undefined && nextBurst.type === "cpu") {
|
||||||
|
this._transition(cpu, "Ready");
|
||||||
|
this._readyQueue.push(cpu);
|
||||||
|
} else {
|
||||||
|
this._transition(cpu, "Terminated");
|
||||||
|
cpu.finishTick = this._tick + 1;
|
||||||
|
}
|
||||||
|
this._cpuProcess = null;
|
||||||
|
} else if (this._algorithm.isQuantumExpired(cpu, this._config)) {
|
||||||
|
this._transition(cpu, "Ready");
|
||||||
|
this._readyQueue.push(cpu);
|
||||||
|
this._cpuProcess = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// IO completions
|
||||||
|
const nextIoQueue: ProcessRuntime[] = [];
|
||||||
|
for (const rt of this._ioQueue) {
|
||||||
|
if (rt.remainingBurst === 0) {
|
||||||
|
this._advanceBurst(rt);
|
||||||
|
const process = this._processes.find((p) => p.id === rt.processId)!;
|
||||||
|
if (rt.burstIndex < process.bursts.length) {
|
||||||
|
this._transition(rt, "Ready");
|
||||||
|
this._readyQueue.push(rt);
|
||||||
|
} else {
|
||||||
|
this._transition(rt, "Terminated");
|
||||||
|
rt.finishTick = this._tick + 1;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
nextIoQueue.push(rt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
this._ioQueue = nextIoQueue;
|
||||||
|
|
||||||
|
return snapshot;
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Run to completion; return all tick snapshots. */
|
||||||
|
runAll(): SimTick[] {
|
||||||
|
const results: SimTick[] = [];
|
||||||
|
while (!this.isFinished) {
|
||||||
|
results.push(this.step());
|
||||||
|
if (results.length > 10_000) {
|
||||||
|
throw new Error("Simulation exceeded 10,000 ticks — check for infinite loop");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return results;
|
||||||
|
}
|
||||||
|
|
||||||
|
get isFinished(): boolean {
|
||||||
|
for (const rt of this._runtimes.values()) {
|
||||||
|
if (rt.state !== "Terminated") return false;
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
get currentTick(): number {
|
||||||
|
return this._tick;
|
||||||
|
}
|
||||||
|
|
||||||
|
get runtimeStates(): ProcessRuntime[] {
|
||||||
|
return Array.from(this._runtimes.values());
|
||||||
|
}
|
||||||
|
|
||||||
|
// ----------------------------------------------------------
|
||||||
|
// Private helpers
|
||||||
|
// ----------------------------------------------------------
|
||||||
|
|
||||||
|
private _transition(rt: ProcessRuntime, state: StateLabel): void {
|
||||||
|
rt.state = state;
|
||||||
|
}
|
||||||
|
|
||||||
|
private _advanceBurst(rt: ProcessRuntime): void {
|
||||||
|
rt.burstIndex++;
|
||||||
|
const process = this._processes.find((p) => p.id === rt.processId)!;
|
||||||
|
const nextBurst = process.bursts[rt.burstIndex];
|
||||||
|
rt.remainingBurst = nextBurst !== undefined ? nextBurst.duration : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
private _snapshot(): SimTick {
|
||||||
|
const states: Record<string, StateLabel> = {};
|
||||||
|
for (const [id, rt] of this._runtimes) {
|
||||||
|
states[id] = rt.state;
|
||||||
|
}
|
||||||
|
const contextSwitching = this._contextSwitchRemaining > 0;
|
||||||
|
return {
|
||||||
|
tick: this._tick,
|
||||||
|
cpuProcess: contextSwitching ? null : (this._cpuProcess?.processId ?? null),
|
||||||
|
ioProcesses: this._ioQueue.map((rt) => rt.processId),
|
||||||
|
readyQueue: this._readyQueue.map((rt) => rt.processId),
|
||||||
|
states,
|
||||||
|
contextSwitching,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Helper: initialise a ProcessRuntime from a Process
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
function initRuntime(p: Process, config: SchedulerConfig): ProcessRuntime {
|
||||||
|
const firstBurst = p.bursts[0];
|
||||||
|
if (firstBurst === undefined || firstBurst.type !== "cpu") {
|
||||||
|
throw new Error(`Process ${p.id}: first burst must be a CPU burst`);
|
||||||
|
}
|
||||||
|
return {
|
||||||
|
processId: p.id,
|
||||||
|
state: "New",
|
||||||
|
remainingBurst: firstBurst.duration,
|
||||||
|
burstIndex: 0,
|
||||||
|
arrivalTick: p.arrivalTime,
|
||||||
|
startTick: null,
|
||||||
|
finishTick: null,
|
||||||
|
waitingTime: 0,
|
||||||
|
cpuTime: 0,
|
||||||
|
ioTime: 0,
|
||||||
|
responseTime: null,
|
||||||
|
quantumRemaining: config.quantum,
|
||||||
|
currentPriority: p.priority,
|
||||||
|
};
|
||||||
|
}
|
||||||
@@ -0,0 +1,107 @@
|
|||||||
|
import type {
|
||||||
|
GlobalMetrics,
|
||||||
|
ProcessMetrics,
|
||||||
|
ProcessRuntime,
|
||||||
|
} from "./types";
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Per-process metrics
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export function computeProcessMetrics(rt: ProcessRuntime): ProcessMetrics {
|
||||||
|
if (rt.startTick === null || rt.finishTick === null) {
|
||||||
|
throw new Error(
|
||||||
|
`Cannot compute metrics for process ${rt.processId}: not yet terminated`,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
const turnaroundTime = rt.finishTick - rt.arrivalTick;
|
||||||
|
const waitingTime = turnaroundTime - rt.cpuTime - rt.ioTime;
|
||||||
|
const responseTime = rt.startTick - rt.arrivalTick;
|
||||||
|
const cpuUtilization =
|
||||||
|
turnaroundTime > 0 ? (rt.cpuTime / turnaroundTime) * 100 : 0;
|
||||||
|
|
||||||
|
const total = rt.cpuTime + rt.ioTime;
|
||||||
|
const cpuRatio = total > 0 ? rt.cpuTime / total : 1;
|
||||||
|
const ioRatio = total > 0 ? rt.ioTime / total : 0;
|
||||||
|
|
||||||
|
let boundType: "CPU Bound" | "I/O Bound" | "Balanced";
|
||||||
|
if (cpuRatio >= 0.65) {
|
||||||
|
boundType = "CPU Bound";
|
||||||
|
} else if (ioRatio >= 0.65) {
|
||||||
|
boundType = "I/O Bound";
|
||||||
|
} else {
|
||||||
|
boundType = "Balanced";
|
||||||
|
}
|
||||||
|
|
||||||
|
return {
|
||||||
|
processId: rt.processId,
|
||||||
|
arrivalTime: rt.arrivalTick,
|
||||||
|
startTick: rt.startTick,
|
||||||
|
finishTick: rt.finishTick,
|
||||||
|
responseTime,
|
||||||
|
turnaroundTime,
|
||||||
|
waitingTime,
|
||||||
|
cpuTime: rt.cpuTime,
|
||||||
|
ioTime: rt.ioTime,
|
||||||
|
cpuUtilization,
|
||||||
|
boundType,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Global metrics (across all completed processes)
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export function computeGlobalMetrics(
|
||||||
|
metrics: ProcessMetrics[],
|
||||||
|
totalTicks: number,
|
||||||
|
): GlobalMetrics {
|
||||||
|
if (metrics.length === 0) {
|
||||||
|
return {
|
||||||
|
avgResponseTime: 0,
|
||||||
|
avgTurnaroundTime: 0,
|
||||||
|
avgWaitingTime: 0,
|
||||||
|
cpuThroughput: 0,
|
||||||
|
cpuUtilization: 0,
|
||||||
|
totalSimulationTime: totalTicks,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
const mean = (values: number[]) =>
|
||||||
|
values.reduce((a, b) => a + b, 0) / values.length;
|
||||||
|
|
||||||
|
const totalCpuTime = metrics.reduce((s, m) => s + m.cpuTime, 0);
|
||||||
|
|
||||||
|
return {
|
||||||
|
avgResponseTime: mean(metrics.map((m) => m.responseTime)),
|
||||||
|
avgTurnaroundTime: mean(metrics.map((m) => m.turnaroundTime)),
|
||||||
|
avgWaitingTime: mean(metrics.map((m) => m.waitingTime)),
|
||||||
|
cpuThroughput: metrics.length / totalTicks,
|
||||||
|
cpuUtilization: totalTicks > 0 ? (totalCpuTime / totalTicks) * 100 : 0,
|
||||||
|
totalSimulationTime: totalTicks,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Classify process by declared burst ratios (static, pre-simulation)
|
||||||
|
// Used in the process list preview badge.
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export function classifyBound(
|
||||||
|
bursts: { type: "cpu" | "io"; duration: number }[],
|
||||||
|
): "CPU Bound" | "I/O Bound" | "Balanced" {
|
||||||
|
let cpu = 0;
|
||||||
|
let io = 0;
|
||||||
|
for (const b of bursts) {
|
||||||
|
if (b.type === "cpu") cpu += b.duration;
|
||||||
|
else io += b.duration;
|
||||||
|
}
|
||||||
|
const total = cpu + io;
|
||||||
|
if (total === 0) return "Balanced";
|
||||||
|
const cpuRatio = cpu / total;
|
||||||
|
const ioRatio = io / total;
|
||||||
|
if (cpuRatio >= 0.65) return "CPU Bound";
|
||||||
|
if (ioRatio >= 0.65) return "I/O Bound";
|
||||||
|
return "Balanced";
|
||||||
|
}
|
||||||
@@ -0,0 +1,80 @@
|
|||||||
|
import type { Process, SchedulerConfig } from "./types";
|
||||||
|
|
||||||
|
export interface Preset {
|
||||||
|
name: string;
|
||||||
|
description: string;
|
||||||
|
processes: Process[];
|
||||||
|
config: SchedulerConfig;
|
||||||
|
}
|
||||||
|
|
||||||
|
const defaultConfig = (
|
||||||
|
overrides: Partial<SchedulerConfig> = {},
|
||||||
|
): SchedulerConfig => ({
|
||||||
|
algorithm: "FCFS",
|
||||||
|
quantum: 2,
|
||||||
|
contextSwitchTime: 0,
|
||||||
|
isPreemptive: false,
|
||||||
|
agingEnabled: false,
|
||||||
|
agingInterval: 5,
|
||||||
|
...overrides,
|
||||||
|
});
|
||||||
|
|
||||||
|
export const presets: Preset[] = [
|
||||||
|
{
|
||||||
|
name: "classic_fcfs",
|
||||||
|
description: "4 simple processes, no I/O — demonstrates FCFS order",
|
||||||
|
processes: [
|
||||||
|
{ id: "p1", name: "P1", arrivalTime: 0, priority: 5, color: "#4FC3F7", bursts: [{ type: "cpu", duration: 5 }] },
|
||||||
|
{ id: "p2", name: "P2", arrivalTime: 1, priority: 5, color: "#81C784", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
{ id: "p3", name: "P3", arrivalTime: 2, priority: 5, color: "#FFB74D", bursts: [{ type: "cpu", duration: 1 }] },
|
||||||
|
{ id: "p4", name: "P4", arrivalTime: 3, priority: 5, color: "#F06292", bursts: [{ type: "cpu", duration: 7 }] },
|
||||||
|
],
|
||||||
|
config: defaultConfig({ algorithm: "FCFS" }),
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "rr_demo",
|
||||||
|
description: "5 processes with quantum 3 — Round Robin rotation",
|
||||||
|
processes: [
|
||||||
|
{ id: "p1", name: "P1", arrivalTime: 0, priority: 5, color: "#4FC3F7", bursts: [{ type: "cpu", duration: 6 }] },
|
||||||
|
{ id: "p2", name: "P2", arrivalTime: 0, priority: 5, color: "#81C784", bursts: [{ type: "cpu", duration: 4 }] },
|
||||||
|
{ id: "p3", name: "P3", arrivalTime: 1, priority: 5, color: "#FFB74D", bursts: [{ type: "cpu", duration: 5 }] },
|
||||||
|
{ id: "p4", name: "P4", arrivalTime: 2, priority: 5, color: "#F06292", bursts: [{ type: "cpu", duration: 2 }] },
|
||||||
|
{ id: "p5", name: "P5", arrivalTime: 3, priority: 5, color: "#CE93D8", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
],
|
||||||
|
config: defaultConfig({ algorithm: "RR", quantum: 3 }),
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "starvation",
|
||||||
|
description: "High-priority processes starve P5 — demonstrates Priority NP starvation",
|
||||||
|
processes: [
|
||||||
|
{ id: "p1", name: "P1", arrivalTime: 0, priority: 1, color: "#4FC3F7", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
{ id: "p2", name: "P2", arrivalTime: 1, priority: 1, color: "#81C784", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
{ id: "p3", name: "P3", arrivalTime: 2, priority: 1, color: "#FFB74D", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
{ id: "p4", name: "P4", arrivalTime: 3, priority: 1, color: "#F06292", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
{ id: "p5", name: "P5", arrivalTime: 0, priority: 10, color: "#CE93D8", bursts: [{ type: "cpu", duration: 5 }] },
|
||||||
|
],
|
||||||
|
config: defaultConfig({ algorithm: "PRIORITY_NP" }),
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "aging_fix",
|
||||||
|
description: "Same starvation scenario fixed with aging",
|
||||||
|
processes: [
|
||||||
|
{ id: "p1", name: "P1", arrivalTime: 0, priority: 1, color: "#4FC3F7", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
{ id: "p2", name: "P2", arrivalTime: 1, priority: 1, color: "#81C784", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
{ id: "p3", name: "P3", arrivalTime: 2, priority: 1, color: "#FFB74D", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
{ id: "p4", name: "P4", arrivalTime: 3, priority: 1, color: "#F06292", bursts: [{ type: "cpu", duration: 3 }] },
|
||||||
|
{ id: "p5", name: "P5", arrivalTime: 0, priority: 10, color: "#CE93D8", bursts: [{ type: "cpu", duration: 5 }] },
|
||||||
|
],
|
||||||
|
config: defaultConfig({ algorithm: "PRIORITY_P", isPreemptive: true, agingEnabled: true, agingInterval: 3 }),
|
||||||
|
},
|
||||||
|
{
|
||||||
|
name: "io_heavy",
|
||||||
|
description: "Mixed CPU-bound and I/O-bound processes",
|
||||||
|
processes: [
|
||||||
|
{ id: "p1", name: "P1", arrivalTime: 0, priority: 5, color: "#4FC3F7", bursts: [{ type: "cpu", duration: 6 }, { type: "io", duration: 1 }, { type: "cpu", duration: 2 }] },
|
||||||
|
{ id: "p2", name: "P2", arrivalTime: 0, priority: 5, color: "#81C784", bursts: [{ type: "cpu", duration: 1 }, { type: "io", duration: 8 }, { type: "cpu", duration: 1 }] },
|
||||||
|
{ id: "p3", name: "P3", arrivalTime: 2, priority: 5, color: "#FFB74D", bursts: [{ type: "cpu", duration: 4 }, { type: "io", duration: 2 }, { type: "cpu", duration: 4 }] },
|
||||||
|
],
|
||||||
|
config: defaultConfig({ algorithm: "SJF_P", isPreemptive: true }),
|
||||||
|
},
|
||||||
|
];
|
||||||
@@ -0,0 +1,103 @@
|
|||||||
|
// ============================================================
|
||||||
|
// Core types — Process Scheduler Simulator
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export type SchedulingAlgorithm =
|
||||||
|
| "FCFS"
|
||||||
|
| "SJF_NP"
|
||||||
|
| "SJF_P"
|
||||||
|
| "RR"
|
||||||
|
| "PRIORITY_NP"
|
||||||
|
| "PRIORITY_P"
|
||||||
|
| "MULTILEVEL"
|
||||||
|
| "HRRN";
|
||||||
|
|
||||||
|
// --------------- Static process definition ------------------
|
||||||
|
|
||||||
|
export interface BurstSegment {
|
||||||
|
type: "cpu" | "io";
|
||||||
|
duration: number; // must be ≥ 1
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface Process {
|
||||||
|
id: string;
|
||||||
|
name: string;
|
||||||
|
arrivalTime: number; // tick of arrival (≥ 0)
|
||||||
|
priority: number; // 1 (highest) – 10 (lowest); default 5
|
||||||
|
color: string; // HEX color for Gantt display
|
||||||
|
bursts: BurstSegment[]; // must start (and end) with a CPU burst
|
||||||
|
}
|
||||||
|
|
||||||
|
// --------------- Scheduler configuration --------------------
|
||||||
|
|
||||||
|
export interface SchedulerConfig {
|
||||||
|
algorithm: SchedulingAlgorithm;
|
||||||
|
quantum: number; // for RR (default 2)
|
||||||
|
contextSwitchTime: number; // overhead between processes (default 0)
|
||||||
|
isPreemptive: boolean; // applicable to SJF and Priority
|
||||||
|
agingEnabled: boolean; // prevent starvation in Priority scheduling
|
||||||
|
agingInterval: number; // ticks in Ready before priority-- (min 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
// --------------- Runtime state ------------------------------
|
||||||
|
|
||||||
|
export type StateLabel =
|
||||||
|
| "New" // before arrivalTime
|
||||||
|
| "Ready" // in ready queue, waiting for CPU
|
||||||
|
| "Running" // executing CPU burst
|
||||||
|
| "Waiting" // executing I/O burst
|
||||||
|
| "Terminated"; // finished all bursts
|
||||||
|
|
||||||
|
export interface ProcessRuntime {
|
||||||
|
// ---- spec fields ----
|
||||||
|
processId: string;
|
||||||
|
state: StateLabel;
|
||||||
|
remainingBurst: number; // ticks left in current burst
|
||||||
|
burstIndex: number; // index into Process.bursts
|
||||||
|
arrivalTick: number; // tick when process first entered Ready
|
||||||
|
startTick: number | null; // tick of first Running state
|
||||||
|
finishTick: number | null; // tick when process Terminated
|
||||||
|
waitingTime: number; // accumulated ticks in Ready
|
||||||
|
cpuTime: number; // accumulated ticks in Running
|
||||||
|
ioTime: number; // accumulated ticks in Waiting
|
||||||
|
responseTime: number | null; // startTick - arrivalTick (set once)
|
||||||
|
// ---- engine-internal fields ----
|
||||||
|
quantumRemaining: number; // remaining quantum for RR; reset on dispatch
|
||||||
|
currentPriority: number; // mutable via aging; starts = Process.priority
|
||||||
|
}
|
||||||
|
|
||||||
|
// --------------- Tick snapshot ------------------------------
|
||||||
|
|
||||||
|
export interface SimTick {
|
||||||
|
tick: number;
|
||||||
|
cpuProcess: string | null; // processId running on CPU (null if idle)
|
||||||
|
ioProcesses: string[]; // processIds in I/O
|
||||||
|
readyQueue: string[]; // processIds in ready queue (in queue order)
|
||||||
|
states: Record<string, StateLabel>; // all processId → state
|
||||||
|
contextSwitching: boolean; // true during context-switch overhead
|
||||||
|
}
|
||||||
|
|
||||||
|
// --------------- Metrics ------------------------------------
|
||||||
|
|
||||||
|
export interface ProcessMetrics {
|
||||||
|
processId: string;
|
||||||
|
arrivalTime: number;
|
||||||
|
startTick: number;
|
||||||
|
finishTick: number;
|
||||||
|
responseTime: number;
|
||||||
|
turnaroundTime: number;
|
||||||
|
waitingTime: number;
|
||||||
|
cpuTime: number;
|
||||||
|
ioTime: number;
|
||||||
|
cpuUtilization: number; // cpuTime / turnaroundTime * 100
|
||||||
|
boundType: "CPU Bound" | "I/O Bound" | "Balanced";
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface GlobalMetrics {
|
||||||
|
avgResponseTime: number;
|
||||||
|
avgTurnaroundTime: number;
|
||||||
|
avgWaitingTime: number;
|
||||||
|
cpuThroughput: number; // processes completed / total ticks
|
||||||
|
cpuUtilization: number; // Σ cpuTime / totalTicks * 100
|
||||||
|
totalSimulationTime: number;
|
||||||
|
}
|
||||||
@@ -0,0 +1,50 @@
|
|||||||
|
import { useState, useCallback } from "react";
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Generic hook for reading/writing typed values to localStorage.
|
||||||
|
*
|
||||||
|
* Returns [value, setValue, removeValue].
|
||||||
|
* Read/write errors are silently ignored.
|
||||||
|
*/
|
||||||
|
export function useLocalStorage<T>(
|
||||||
|
key: string,
|
||||||
|
initialValue: T,
|
||||||
|
): readonly [T, (value: T | ((prev: T) => T)) => void, () => void] {
|
||||||
|
const [storedValue, setStoredValue] = useState<T>(() => {
|
||||||
|
try {
|
||||||
|
const item = window.localStorage.getItem(key);
|
||||||
|
return item !== null ? (JSON.parse(item) as T) : initialValue;
|
||||||
|
} catch {
|
||||||
|
return initialValue;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
const setValue = useCallback(
|
||||||
|
(value: T | ((prev: T) => T)) => {
|
||||||
|
setStoredValue((prev) => {
|
||||||
|
const next =
|
||||||
|
typeof value === "function"
|
||||||
|
? (value as (prev: T) => T)(prev)
|
||||||
|
: value;
|
||||||
|
try {
|
||||||
|
window.localStorage.setItem(key, JSON.stringify(next));
|
||||||
|
} catch {
|
||||||
|
// ignore write errors (e.g. private mode quota exceeded)
|
||||||
|
}
|
||||||
|
return next;
|
||||||
|
});
|
||||||
|
},
|
||||||
|
[key],
|
||||||
|
);
|
||||||
|
|
||||||
|
const removeValue = useCallback(() => {
|
||||||
|
try {
|
||||||
|
window.localStorage.removeItem(key);
|
||||||
|
} catch {
|
||||||
|
// ignore
|
||||||
|
}
|
||||||
|
setStoredValue(initialValue);
|
||||||
|
}, [key, initialValue]);
|
||||||
|
|
||||||
|
return [storedValue, setValue, removeValue] as const;
|
||||||
|
}
|
||||||
@@ -0,0 +1,50 @@
|
|||||||
|
import { useEffect, useRef } from "react";
|
||||||
|
import { useSimulationStore } from "../store/simulationStore";
|
||||||
|
import { useUiStore } from "../store/uiStore";
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Drives the simulation animation loop using requestAnimationFrame.
|
||||||
|
* Call once at the app root. Returns nothing — side-effect only.
|
||||||
|
*
|
||||||
|
* Tick interval = 1000 / speed (ms).
|
||||||
|
* The loop is active only while status === "running".
|
||||||
|
*/
|
||||||
|
export function useSimulation(): void {
|
||||||
|
const status = useSimulationStore((s) => s.status);
|
||||||
|
const stepOnce = useSimulationStore((s) => s.stepOnce);
|
||||||
|
const speed = useUiStore((s) => s.speed);
|
||||||
|
|
||||||
|
const rafRef = useRef<number | undefined>(undefined);
|
||||||
|
const lastTickTime = useRef<number>(0);
|
||||||
|
|
||||||
|
useEffect(() => {
|
||||||
|
if (status !== "running") {
|
||||||
|
if (rafRef.current !== undefined) {
|
||||||
|
cancelAnimationFrame(rafRef.current);
|
||||||
|
rafRef.current = undefined;
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
const interval = 1000 / speed;
|
||||||
|
|
||||||
|
const loop = (timestamp: number) => {
|
||||||
|
if (timestamp - lastTickTime.current >= interval) {
|
||||||
|
lastTickTime.current = timestamp;
|
||||||
|
stepOnce();
|
||||||
|
}
|
||||||
|
rafRef.current = requestAnimationFrame(loop);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Reset timing so the first tick fires immediately after play
|
||||||
|
lastTickTime.current = 0;
|
||||||
|
rafRef.current = requestAnimationFrame(loop);
|
||||||
|
|
||||||
|
return () => {
|
||||||
|
if (rafRef.current !== undefined) {
|
||||||
|
cancelAnimationFrame(rafRef.current);
|
||||||
|
rafRef.current = undefined;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}, [status, speed, stepOnce]);
|
||||||
|
}
|
||||||
@@ -0,0 +1,20 @@
|
|||||||
|
@import "tailwindcss";
|
||||||
|
|
||||||
|
@theme {
|
||||||
|
--color-state-new: #475569; /* slate-600 */
|
||||||
|
--color-state-ready: #f59e0b; /* amber-500 */
|
||||||
|
--color-state-running: #10b981; /* emerald-500 */
|
||||||
|
--color-state-waiting: #06b6d4; /* cyan-500 */
|
||||||
|
--color-state-terminated: #94a3b8; /* slate-400 */
|
||||||
|
--color-state-ctx: #ef4444; /* red-500 */
|
||||||
|
}
|
||||||
|
|
||||||
|
@layer utilities {
|
||||||
|
.scrollbar-hide::-webkit-scrollbar {
|
||||||
|
display: none;
|
||||||
|
}
|
||||||
|
.scrollbar-hide {
|
||||||
|
-ms-overflow-style: none;
|
||||||
|
scrollbar-width: none;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,10 @@
|
|||||||
|
import { StrictMode } from 'react';
|
||||||
|
import { createRoot } from 'react-dom/client';
|
||||||
|
import './index.css';
|
||||||
|
import App from './App';
|
||||||
|
|
||||||
|
createRoot(document.getElementById('root')!).render(
|
||||||
|
<StrictMode>
|
||||||
|
<App />
|
||||||
|
</StrictMode>
|
||||||
|
);
|
||||||
@@ -0,0 +1,62 @@
|
|||||||
|
import { create } from "zustand";
|
||||||
|
import { persist } from "zustand/middleware";
|
||||||
|
import type { Process, SchedulerConfig } from "@core/types";
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Defaults
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
const DEFAULT_CONFIG: SchedulerConfig = {
|
||||||
|
algorithm: "FCFS",
|
||||||
|
quantum: 2,
|
||||||
|
contextSwitchTime: 0,
|
||||||
|
isPreemptive: false,
|
||||||
|
agingEnabled: false,
|
||||||
|
agingInterval: 5,
|
||||||
|
};
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Store
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
interface ProcessStore {
|
||||||
|
processes: Process[];
|
||||||
|
config: SchedulerConfig;
|
||||||
|
|
||||||
|
addProcess: (p: Process) => void;
|
||||||
|
updateProcess: (id: string, updates: Partial<Process>) => void;
|
||||||
|
removeProcess: (id: string) => void;
|
||||||
|
clearProcesses: () => void;
|
||||||
|
setConfig: (updates: Partial<SchedulerConfig>) => void;
|
||||||
|
loadPreset: (processes: Process[], config: SchedulerConfig) => void;
|
||||||
|
}
|
||||||
|
|
||||||
|
export const useProcessStore = create<ProcessStore>()(
|
||||||
|
persist(
|
||||||
|
(set) => ({
|
||||||
|
processes: [],
|
||||||
|
config: DEFAULT_CONFIG,
|
||||||
|
|
||||||
|
addProcess: (p) =>
|
||||||
|
set((s) => ({ processes: [...s.processes, p] })),
|
||||||
|
|
||||||
|
updateProcess: (id, updates) =>
|
||||||
|
set((s) => ({
|
||||||
|
processes: s.processes.map((p) =>
|
||||||
|
p.id === id ? { ...p, ...updates } : p,
|
||||||
|
),
|
||||||
|
})),
|
||||||
|
|
||||||
|
removeProcess: (id) =>
|
||||||
|
set((s) => ({ processes: s.processes.filter((p) => p.id !== id) })),
|
||||||
|
|
||||||
|
clearProcesses: () => set({ processes: [] }),
|
||||||
|
|
||||||
|
setConfig: (updates) =>
|
||||||
|
set((s) => ({ config: { ...s.config, ...updates } })),
|
||||||
|
|
||||||
|
loadPreset: (processes, config) => set({ processes, config }),
|
||||||
|
}),
|
||||||
|
{ name: "pss:session" },
|
||||||
|
),
|
||||||
|
);
|
||||||
@@ -0,0 +1,69 @@
|
|||||||
|
import { create } from "zustand";
|
||||||
|
import { SimulationEngine } from "@core/engine";
|
||||||
|
import type { Process, SchedulerConfig, SimTick } from "@core/types";
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Types
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export type SimStatus = "idle" | "running" | "paused" | "finished";
|
||||||
|
|
||||||
|
interface SimulationStore {
|
||||||
|
status: SimStatus;
|
||||||
|
ticks: SimTick[];
|
||||||
|
// Mutable engine instance — reactivity comes from ticks[] and status, not engine itself
|
||||||
|
engine: SimulationEngine | null;
|
||||||
|
// Saved so reset() can recreate the engine without coupling to processStore
|
||||||
|
_processes: Process[];
|
||||||
|
_config: SchedulerConfig | null;
|
||||||
|
|
||||||
|
init: (processes: Process[], config: SchedulerConfig) => void;
|
||||||
|
stepOnce: () => void;
|
||||||
|
play: () => void;
|
||||||
|
pause: () => void;
|
||||||
|
reset: () => void;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Store
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export const useSimulationStore = create<SimulationStore>()((set, get) => ({
|
||||||
|
status: "idle",
|
||||||
|
ticks: [],
|
||||||
|
engine: null,
|
||||||
|
_processes: [],
|
||||||
|
_config: null,
|
||||||
|
|
||||||
|
init: (processes, config) => {
|
||||||
|
const engine = new SimulationEngine(processes, config);
|
||||||
|
set({
|
||||||
|
engine,
|
||||||
|
ticks: [],
|
||||||
|
status: "paused",
|
||||||
|
_processes: processes,
|
||||||
|
_config: config,
|
||||||
|
});
|
||||||
|
},
|
||||||
|
|
||||||
|
stepOnce: () => {
|
||||||
|
const { engine, ticks, status } = get();
|
||||||
|
if (!engine || engine.isFinished || status === "finished") return;
|
||||||
|
const tick = engine.step();
|
||||||
|
set({
|
||||||
|
ticks: [...ticks, tick],
|
||||||
|
status: engine.isFinished ? "finished" : status,
|
||||||
|
});
|
||||||
|
},
|
||||||
|
|
||||||
|
play: () => set({ status: "running" }),
|
||||||
|
|
||||||
|
pause: () => set({ status: "paused" }),
|
||||||
|
|
||||||
|
reset: () => {
|
||||||
|
const { _processes, _config } = get();
|
||||||
|
if (_processes.length === 0 || _config === null) return;
|
||||||
|
const engine = new SimulationEngine(_processes, _config);
|
||||||
|
set({ engine, ticks: [], status: "paused" });
|
||||||
|
},
|
||||||
|
}));
|
||||||
@@ -0,0 +1,28 @@
|
|||||||
|
import { create } from "zustand";
|
||||||
|
import { persist } from "zustand/middleware";
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Speed options
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
export const SPEED_OPTIONS = [0.25, 0.5, 1, 2, 4] as const;
|
||||||
|
export type SpeedOption = (typeof SPEED_OPTIONS)[number];
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// Store
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
interface UiStore {
|
||||||
|
speed: number;
|
||||||
|
setSpeed: (speed: number) => void;
|
||||||
|
}
|
||||||
|
|
||||||
|
export const useUiStore = create<UiStore>()(
|
||||||
|
persist(
|
||||||
|
(set) => ({
|
||||||
|
speed: 1,
|
||||||
|
setSpeed: (speed) => set({ speed }),
|
||||||
|
}),
|
||||||
|
{ name: "pss:ui" },
|
||||||
|
),
|
||||||
|
);
|
||||||
@@ -0,0 +1 @@
|
|||||||
|
import '@testing-library/jest-dom';
|
||||||
@@ -0,0 +1,26 @@
|
|||||||
|
{
|
||||||
|
"compilerOptions": {
|
||||||
|
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
|
||||||
|
"target": "ES2022",
|
||||||
|
"useDefineForClassFields": true,
|
||||||
|
"lib": ["ES2022", "DOM", "DOM.Iterable"],
|
||||||
|
"module": "ESNext",
|
||||||
|
"skipLibCheck": true,
|
||||||
|
"moduleResolution": "bundler",
|
||||||
|
"allowImportingTsExtensions": true,
|
||||||
|
"isolatedModules": true,
|
||||||
|
"moduleDetection": "force",
|
||||||
|
"noEmit": true,
|
||||||
|
"jsx": "react-jsx",
|
||||||
|
"strict": true,
|
||||||
|
"noUncheckedIndexedAccess": true,
|
||||||
|
"noUnusedLocals": true,
|
||||||
|
"noUnusedParameters": true,
|
||||||
|
"paths": {
|
||||||
|
"@core/*": ["./src/core/*"],
|
||||||
|
"@components/*": ["./src/components/*"],
|
||||||
|
"@store/*": ["./src/store/*"]
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"include": ["src"]
|
||||||
|
}
|
||||||
@@ -0,0 +1,7 @@
|
|||||||
|
{
|
||||||
|
"files": [],
|
||||||
|
"references": [
|
||||||
|
{ "path": "./tsconfig.app.json" },
|
||||||
|
{ "path": "./tsconfig.node.json" }
|
||||||
|
]
|
||||||
|
}
|
||||||
@@ -0,0 +1,18 @@
|
|||||||
|
{
|
||||||
|
"compilerOptions": {
|
||||||
|
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
|
||||||
|
"target": "ES2022",
|
||||||
|
"lib": ["ES2022"],
|
||||||
|
"module": "ESNext",
|
||||||
|
"skipLibCheck": true,
|
||||||
|
"moduleResolution": "bundler",
|
||||||
|
"allowImportingTsExtensions": true,
|
||||||
|
"isolatedModules": true,
|
||||||
|
"moduleDetection": "force",
|
||||||
|
"noEmit": true,
|
||||||
|
"strict": true,
|
||||||
|
"noUnusedLocals": true,
|
||||||
|
"noUnusedParameters": true
|
||||||
|
},
|
||||||
|
"include": ["vite.config.ts"]
|
||||||
|
}
|
||||||
@@ -0,0 +1,25 @@
|
|||||||
|
/// <reference types="vitest" />
|
||||||
|
import { defineConfig } from "vite";
|
||||||
|
import react from "@vitejs/plugin-react";
|
||||||
|
import tailwindcss from "@tailwindcss/vite";
|
||||||
|
import path from "path";
|
||||||
|
|
||||||
|
export default defineConfig({
|
||||||
|
plugins: [react(), tailwindcss()],
|
||||||
|
test: {
|
||||||
|
globals: true,
|
||||||
|
environment: "jsdom",
|
||||||
|
setupFiles: "./src/test/setup.ts",
|
||||||
|
coverage: {
|
||||||
|
provider: "v8",
|
||||||
|
include: ["src/core/**", "src/components/**"],
|
||||||
|
},
|
||||||
|
},
|
||||||
|
resolve: {
|
||||||
|
alias: {
|
||||||
|
"@core": path.resolve(__dirname, "./src/core"),
|
||||||
|
"@components": path.resolve(__dirname, "./src/components"),
|
||||||
|
"@store": path.resolve(__dirname, "./src/store"),
|
||||||
|
},
|
||||||
|
},
|
||||||
|
});
|
||||||
Reference in new issue
Block a user