Política de escalonamento do sistema operacional
Tags: programming, computerscience, performance, codenewbie
Published: 2022-08-08 05:23:19

Antes de você me perguntar o que é esse negócio de nome complexo, não entre em pânico, esse é um conhecimento fundamental para todo desenvolvedor e é extremamente simples de ser absorvido. Venha comigo nessa leitura rápida que é só sucesso!d

Nos tempos de hoje estamos tão acostumados com a multiprogramação que temos a forte impressão de que um dispositivo eletrônico pode realizar diversas tarefas ao mesmo tempo. Em parte, isso é verdade, uma vez que até um celular “simplinho” de entrada hoje em dia possui 8 núcleos, quem nunca ouviu os termos dual-core, quad-core, octa-core? Nem sempre a capacidade de processamento foi abundante dessa forma, e até hoje temos dispositivos de capacidade reduzida que funcionam com apenas um núcleo e uma mísera thread de processamento, mas como isso é possível?

Eu sei que quando você viu o título desse artigo já veio pensando no seu Windows ou no seu Linux, e você não está errado. É fato que todo sistema operacional necessita de uma política de escalonamento para funcionar, mas precisamos lembrar que dispositivos mais simples que computadores também dependem de sistemas operacionais pra funcionar.

Pegue as smart-TVs, celulares, caixas de som como exemplo de dispositivos que tem um sistema operacional rodando e consequentemente possuem uma política de escalonamento adequada para suas capacidades reduzidas.

_Tá bom, celulares não são tão reduzidos assim, mas eu sei que você está me entendendo._

O seu celular, computador, sua TV, seu Smartwatch não ficam travados enquanto realizam alguma tarefa porque seus sistemas contam com duas rotinas (algoritmos executados repetidamente enquanto o sistema está ligado) que trabalham arduamente para que isso não aconteça, esses algoritmos têm nome, se chamam **Scheduler** e **Dispatcher**, é com eles que você dá “pití” quando seu PC gamer trava.

Apesar do nome gringo embaçado, você pode traduzir Scheduler para Escalonador e Dispatcher para Expedidor.

O escalonador conta o tempo que cada programa pode usar o processador, é o algoritmo escalonador o responsável por aplicar a política de escalonamento (_Dããnrr_).

A partir daqui chamarei programa de processo pra ficar mais fiel aos termos, um processo é um programa carregado na memória, ou seja, um programa que está aberto, mesmo que em segundo plano.

Já o expedidor é responsável por tirar um processo da execução do processador e registrar onde o mesmo parou, chamamos esse registro de: contexto do processo. Essa mudança entre os processos é conhecida como chaveamento de contexto.

Mas Antônio, **o que é, afinal de contas, a política de escalonamento?**

É simples!

> É um conjunto de critérios utilizados pelo escalonador para determinar qual processo irá utilizar o processador.
 
#### Mas que critérios? Alguns deles são:

##### • Utilização do processador
> Quantidade de tempo em que o processo está utilizando o processador para realizar alguma tarefa.

##### • Throughput
> Quantidade de processos que são executados em um determinado período de tempo.

##### • Tempo de processador
> Tempo de uso que um processo precisar utilizar o processador para CONCLUIR sua tarefa.

##### • Tempo de espera
> Tempo que que o processo permanece na fila até ganhar o processador.

##### • Tempo de turnaround
> Tempo total de execução de um programa, da criação do processo até sua finalização.

##### • Tempo de resposta
> O tempo que existe entre a requisição de um usuário e a resposta do sistema.

###### _Fácil né? Eu também não achei a primeira vez que vi, então sem pânico kkkk_.

---

Antes de eu falar sobre algumas políticas aplicadas em diferentes sistemas operacionais, eu esqueci de comentar que existem dois tipos de sistemas, **os não-preemptivos** e os **preemptivos**.

Lá vem o doido com palavra estranha de novo, mas calma,

> Preempção é o termo dado a quando um processo sofre uma interrupção e é substituído por outro, quando o expedidor faz o chaveamento de contexto, ou seja, quando ele troca um processo por outro, isso é chamado de preempção.

Como os sistemas não-preemptivos são consideravelmente diferentes dos preemptivos, irei abordas suas políticas de escalonamento separadamente, começando pelos nãopreemptivos que acabam sendo mais simples e acarretando problemas ÓBVIOS quere veremos a seguir.

Então vamos nessa!

---

## **Políticas de escalonamento não-preemptivas**

---

### **FIFO – First-In-First-Out (O primeiro a entrar é o primeiro a sair)**
ou
### **FCFS – First-Come-First-Served (o primeiro a vir é o primeiro servido)**

Essa política de escalonamento é baseada em uma fila simples, onde cada processo após criado vai pra fila de execução e quando ganha acesso ao processador utiliza-o pelo tempo que for necessário, caso o processo entre em estado de espera por conta de alguma operação de entrada e saída ele retorna ao final da fila quando mudar para o estado de pronto. Um problema é que não pode prever quanto tempo um processo irá utilizar o processador, para além disso, processos CPU-Bound (processos que usam mais processador do que disco) acabam por ser privilegiados na utilização do processador.

### **SJB – Shortest-Job-First (Menor trabalho primeiro)**

Muito parecido com o FIFO essa política de escalonamento tem como diferença o fato de que o processo que ganha o processador é o que precisar de menor tempo de uso, isso leva a uma redução do tempo médio de turnaround dos processos, mas traz como consequência que processos que dependam de um maior tempo de uso da CPU acabem sofrendo starvation (inanição é quando um processo fica parado na fila e nunca é processado). Existe uma versão preemptiva dessa política conhecida como Shortest-Remaining-Time (menor tempo restante).

### **Cooperativo**

Nesta política de escalonamento, um processo em execução pode voluntariamente liberar o processador caso verifique que há mensagens de outros processos requisitando a utilização. Esta política de escalonamento foi implementada nos primeiros sistemas multitarefas da família Windows e tem como principal problema o fato de que caso um processo não verifique a fila de processos ele acaba ocupando o processador até que termine tudo que está fazendo.

Deu pra entender?

Agora irei abordar as políticas preemptivas, que apesar de serem mais eficientes, acabam tendo uma implementação muito mais complexa do que as citadas anteriormente. Lembre-se, sempre que um processo sofre preempção o sistema precisa salvar seu contexto antes de mandá-lo de volta para a fila de execução.

---

## **Políticas de escalonamento preemptivas**

---

### **Circular – Round-Robin**


Nesta política cada processo ao ser criado vai para a fila de execução, quando ganha o processador esse processo tem um período de tempo para utilizá-lo, esse período é chamado de time-slice (fatia de tempo) e normalmente é um valor entre 10 e 100 milissegundos. Apesar de garantir que nenhum processo sofra starvation, processos CPU-Bound são beneficiados, por utilizarem toda a sua fatia de tempo enquanto processos I/O-Bound (processos que utilizam mais o disco do que o processador) entram em estado de espera e acabam utilizando menos processador. Existe uma versão desta política que visa corrigir este problema, é conhecida como Circular Virtual, neste caso, os processos que entram em espera são postos em uma fila de pronto auxiliar e nesta fila são escalonados antes dos demais processos, o tempo de processador que recebem é a fatia de tempo da fila comum menos o tempo que utilizaram antes de entrar em espera.

### **Prioridades**

Nesta política os processos são escalonados seguindo uma ordem baseada em prioridades de execução, onde o processo que será escalonado é o que tiver maior prioridade, em casos de processos com a mesma prioridade o sistema de fila é aplicado. Existem sistemas com prioridades estáticas e sistemas com prioridades dinâmicas. Um dos problemas desta política é que processos com baixa prioridade podem acabar sofrendo starvation, em sistemas de prioridade dinâmica esse problema é corrigido através de um método chamado aging, que é quando o sistema operacional incrementa a prioridade de sistemas que estão esperando muito na fila de pronto.

### **Circular com Prioridades**

Nesta política o processo escalonado é aquele com maior prioridade, ele pode ser executado até que gaste sua fatia de tempo ou que outro processo com mais prioridade entre na fila. Para evitar que processos I/O-Bound sejam prejudicados como ocorre na política de escalonamento circular simples, processos desse tipo recebem maior prioridade e os CPU-Bound são executados enquanto os I/O-Bound realizam operações de I/O.

### **Múltiplas Filas – multilevel queue**

Nesta política mais de uma política pode ser aplicada, várias filas de pronto são criadas e tem determinada prioridade, os processos são escalonados por prioridade, a diferença é que dependendo da fila em que se encontram podem ou não sofrer preempção dependendo de como o sistema foi implementado. Um dos problemas desta política é que os processos não podem mudar de filas e por conta disso, podem acabar não sendo processados da melhor forma caso mudem seu comportamento durante a execução.

### **Múltiplas Filas com Realimentação – multilevel feedback queue**

Semelhante a política anterior a diferença aqui é que o sistema operacional pode mudar processos de fila quando necessário, também ocorre que nas filas de maior prioridade, apesar de ganharem o processador antes das demais, tem seus tempos de escalonamento inversamente proporcionais a sua prioridade, ou seja, nas filas de menor prioridade os processos podem usar o processador por mais tempo antes de sofrer preempção por tempo.

---

Essas são algumas das políticas aplicadas por diferentes sistemas, se você chegou até aqui um pouco abalado, não sofra, são conceitos um tanto quanto complexos para serem entendidos no seu primeiro contato, tenha certeza de que as coisas vão ficar muito mais difíceis kkk, brincadeira (ou não).

Se você chegou até aqui, meus sinceros agradecimentos, sei que não sou um mestre da produção textual e agradeço sua compreensão.

No mais, peço perdão pelas palhaçadas no meio do texto, fiz um esforço pra deixar esse conteúdo mais leve.

Caso tenha se interessado pelo conteúdo e queira se aprofundar, a maior parte desse artigo foi escrito com base no livro:

-Arquitetura de Sistemas Operacionais, de Francis Berger Machado e Luiz Paulo Maia, 5ª edição

Se você quiser terminar de explodir a sua cabeça, fique com a leitura mais densa de:

-Sistemas Operacionais Modernos, de Andrew S. Tanembaum, 4ª edição