# 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 |