Gestão da CPU - Escalonamento

Toda esta apresentação é uma

adaptação/tradução/versão do

curso de Abraham

Silberschatz

Gestão da CPU - Escalonamento

•

Conceitos Básicos

•

Critérios de Escalonamento

•

Algoritmos de Escalonamento

•

Escalonamento de Threads

•

Exemplos de Sistemas Operacionais

Objetivos

•

Introdução ao Escalonamento de CPU, o qual

é a base dos sistemas operacionais

multiprogramáveis.

•

Descrição de vários algoritmos de

Escalonamento de CPU.

•

Critérios para a seleção de qual dos algoritmos

Conceitos Básicos

•

Máxima utilização da CPU é obtida com

multiprogramação

•

Ciclo CPU e de E/S

–

Execução de

processos - fase de execução da CPU e

espera por E/S

Gráfico de um ciclo de CPU

Escalonamento de CPU

•

Seleciona dentre os processos na memória em

estado

pronto

, e aloca a CPU para um deles.

•

Decisões de escalonamento da CPU ocorrem quando

um processo:

1. Muda do estado executando para esperando.

2. Muda do estado executando para pronto.

3. Muda do estado esperando para pronto.

4. Termina.

•

Escalonamento nas condições 1 e 4

é

não-preemptivo.

Despachante - D

ispatcher

•

O despachante é o módulo que fornece o controle da

CPU ao processo selecionado pelo escalonador da

CPU. Envolve:

Troca de contexto

Mudança para o modo usuário

Deslocamento para o endereço que reinícia o programa do usuário.

•

Latência do Despacho é tempo gasto pelo

Critérios para o Escalonamento

• Utilização da CPU – manter a CPU ocupada a maior parte

do tempo

• Produtividade (Throughput) – número de processos que

completam sua execução por uma unidade de tempo.

• Tempo de Processamento (Turnaround) – quantidade de tempo para executar um processo

• Tempo de Espera pela CPU – quantidade de tempo que

um processo esteve esperando na fila de processos prontos.

• Tempo de Resposta – intervalo de tempo entre o envio de

Algoritmos de Otimização para o Escalonamento

•

Máxima utilização de CPU

•

Máximo Desempenho/Produtividade

•

Mínimo tempo de processamento

•

Mínimo tempo de espera

Primeiro a requisitar é o primeiro a ser servido First-Come,First-Served (FCFS)

Processo Tempo de Rajada

P₁ 24 P₂ 3 P₃ 3

• Suponha que os processos chegam na ordem: P1 , P2 , P3

• Diagrama de Gantt para a alocação é

• Tempo de espera para P₁ = 0; P₂ = 24; P₃ = 27

• Tempo de espera médio é = (0 + 24 + 27)/3 = 17

P₁ P₂ P₃

24 27 30

Continuando o Escalonamento FCFS

Suponhamos que os processos cheguem na ordem:

P₂ , P₃ , P₁

• O gráfico de Gantt para o escalonamento fica:

• Os tempos de espera são P₁ = 6;P₂ = 0_; P₃ = 3

• Tempo de espera médio = (6 + 0 + 3)/3 = 3

• Bem melhor que o caso anterior.

• Efeito Comboio: processos curtos e após processos longos

P 1 P 3 P 2 6

3 30

Escalonamento do JOB mais Curto/Menor Primeiro (SJF)

• É associado com cada processo a duração da sua próxima

rajada de uso da CPU. O uso dessas durações é para escalonar o processo com o menor tempo.

• SJF é ótimo já que permite o menor tempo médio de espera para um um conjunto de processos.

Exemplo SJF

Processo Tempo de Chegada Tempo de Rajada

P₁ 0.0 6

P₂ 2.0 8

P₃ 4.0 7

P₄ 5.0 3

• Gráfico de Grantt para o Escalonamento SJF

• Tempo médio de espera = (3 + 16 + 9 + 0) / 4 = 7

P_{4 P} P₃

1

3 ₁₆

0 9

P₂

Determinando a duração da próxima fase de uso da CPU (rajada).

•

Pode somente determinar a duração.

•

Pode ser calculada com a duração de uso da CPU na

fase anterior, usando médias exponenciais.

CPU

da

utilização

próxima

a

para

previsto

valor

2.

CPU

de

rajada

e

da

atual

1.















n

tempo

nésima

t



1



.

1 n n

n



t













Previsão do tempo

Exemplos de média exponencial

α = 0

 tn+1 = tn

 História recente não é levada em consideração. α =1

• tn+1 = tn

• Somente a duração da fase de uso da CPU mais recente conta.

Se a fórmula for expandida, temos:

tn+1 = α tn+(1 - α) α tn -1 + …

+(1 - α )j α t_n -1 + …

+(1 - α )n=1 t_n t₀

Escalonamento por prioridade

• Um número de prioridade (inteiro) é associado com cada processo

• A CPU é alocada para o processo com a maior prioridade (menor inteiro geralmente maior prioridade).

– Preemptivo

– Não-preemptivo

• SJF é um escalonador com prioridade, no qual a prioridade é a previsão

da próxima fase de uso da CPU.

• Problema do Starvation (penúria-inanição) – processos de baixa

prioridade podem nunca executar.

• Solução pelo Aging (envelhecimento) – ao passar do tempo,

Escalonamento Round Robin (RR)

• Cada processo recebe uma pequena unidade de tempo de CPU (quantum), usualmente 10-100 milissegundos. Depois de transcorrido este tempo, o processo é retirado da CPU

(Preempção) e adicionado ao fim da fila de processos prontos. • Se existem n processos na fila de processos prontos e o

quantum é q, então cada processo obtém 1/n do tempo da CPU em blocos de no máximo q unidades de tempo de uma vez.

– Nenhum processo espera mais do que (n-1)q unidades de tempo.

• Desempenho

– q alto ⇒ FIFO

Exemplo de RR com um Quantum = 4

Processo Tempo de Rajada

P

24

P

3

P

3

•

O gráfico de Grantt é:

P₁ P₂ P₃ P₁ P₁ P₁ P₁ P₁

Utilização de várias filas para alocação da CPU

• Fila de processos prontos é particionada em filas separadas:

– primeiro plano - foreground (interativo)

– segundo plano - background (batch)

• Cada fila tem seu próprio algoritmo de escalonamento,

– Foreground - interativo – (RR)

– Background - batch – Primeiro a requerer, Primeiro a ser servido (FCFS)

• Escalonamento deve ser realizado entre as filas.

– Escalonamento de prioridade fixa; Ex.: a fila de processos (Background/foreground)

interativos pode ter prioridade absoluta sobre a fila de processos batch. Possibilidade de starvation (inanição).

Múltiplas filas com Feedback

• Um processo pode se mover entre as várias filas;

envelhecimento (aging) pode ser implementado desta forma.

• Escalonamento com múltiplas filas e transferências entre as filas é, exercido, a saber, por:

– Número de filas

– Algoritmos de escalonamento para cada fila

– Método usado para determinar quando transferir um

processo para uma fila de prioridade mais alta

– Método usado para determinar quando transferir um processo para uma fila de prioridade mais baixa

Exemplo de múltiplas filas com Feedback

•

Três filas:

– Q0 – RR com quantum de 8 milissegundos – Q1 –RR com quantum 16 milissegundos – Q2 – FCFS

•

Escalonamento

– Um novo job entra na fila Q0 a qual utiliza FCFS. Quando ele ganha a CPU, job recebe 8 milissegundos. Se ele não finalizar em 8 milissegundos, o job é movido para a fila Q1. – Na fila Q1 o job é de novo servido por FCFS e recebe 16

Escalonamento de Threads

•

Distinção entre thread do usuário e do

kernel-thread.

•

Muitas-para-um e o modelo muitas-para-muitas

para executar em LWP. Escolamento local.

•

Escalonamento Global

–

Como o kernel decide

Escalonamento de Pthread

•

API permitem especificar entre PCS or SCS

durante a criação da thread.

–

PTHREAD SCOPE PROCESS escalona usando o

escalonamento PCS.

–

PTHREAD SCOPE SYSTEM escalona utilizando o

Escalonamento Pthread API

#include <pthread.h> #include <stdio.h>

#define NUM THREADS 5

int main(int argc, char *argv[])

{

int i;

pthread t tid[NUM THREADS]; pthread attr t attr;

/* get the default attributes */ pthread attr init(&attr);

/* set the scheduling algorithm to PROCESS or SYSTEM */ pthread attr setscope(&attr, PTHREAD SCOPE SYSTEM); /* set the scheduling policy - FIFO, RT, or OTHER */

pthread attr setschedpolicy(&attr, SCHED OTHER); /* create the threads */

for (i = 0; i < NUM THREADS; i++)

/* now join on each thread */

for (i = 0; i < NUM THREADS; i++) pthread join(tid[i], NULL); }

/* Each thread will begin control in this function */ void *runner(void *param)

{

printf("I am a thread\n"); pthread exit(0);

}

Escalonamento com múltiplos processadores

• Escalonamento de CPU é mais complexo quando muitos processadores estão disponíveis

• Processadores homogêneos em um multiprocessador Compartilhamento de Carga (Load sharing)

• Multiprocessamento assimétrico – somente um

processador acessa as estruturas de dados do sistema, aliviando a necessidade de compartilhamento de dados • A afinidade com o processador - processo tem

afinidade com processador no qual ele está sendo executado

Processadores Multicore

•

Recentemente foram colocados múltiplos

cores em um mesmo chip físico.

•

CPU ficou mais rápida e consome menos

energia.

•

Multiplas threads por core também foram

implementadas.

Exemplos de Sistemas Operacionais

•

Escalonamento

–

Solaris

–

Windows XP

Escalonamento Linux

• Dois algoritmos: tempo compartilhado e tempo real. • Tempo Compartilhado

– Baseado em créditos com prioridades – processos com mais créditos são escalonados primeiro. O crédito é subtraído na ocorrência de interrupções de tempo. Quando crédito = 0, outro processo é escolhido

– Quando todos os processos tem crédito = 0, ocorre um

recredenciamento baseado em fatores como prioridade e história

• Tempo Real

– Tempo Real Flexível (soft real-time)

– compatível com Posix.1b – duas classes

Escalonamento Java Thread

•

JVM usa um algoritmo de escalonamento

preemptivo e baseado em prioridades

•

Fila FIFO é usada se existem muitas threads

•

JVM escalona a thread para executar quando:

1. A Thread alocada a CPU atualmente sai do estado executando

2. Um Thread de prioridade mais alta entra no estado executando

•

* Nota

–

a JVM não especifica quando threads são

tempo compartilhado ou não

Time-Slicing

–

Tempo Compartilhado

•

Como a JVM não garante tempo compartilado, o

método yield() pode ser utilizado:

while (true) {

// realiza uma tarefa com uso intenso de CPU . . .

Thread.yield(); }

•

Dessa forma libera o controle para outra thread de