A. Carissimi -17-mar-11

(1)

c a - U FRGS

Exclusão mútua

Sistemas Operacionais II

Instituto de Informáti c

Aula 03

O problema da aula passada... (1ª tentativa)

•

Fazer um programa para determinar os números primos existentes entre 1 e 10¹⁰. Se dispõe de uma máquina com 10 processadores (pagamento por minuto de processamento).

•

Solução: dividir o espaço de cálculo entre os 10 processadores, uma thread para cada um

Instituto de Informática -UFRGS

•

Problema?

Sistemas Operacionais II 2

A. Carissimi -17-mar-11

void primos (int i) { int block = power(10,9);

int j;

for (j = (i*block)+1; j <= (i+1)*block; j++) if (isPrime(j))

print(j);

}

Há muitos mais números primos entre 1 e 10⁹do que entre 2x10⁹+1 e 3x10⁹. Lembrem-se dos pintores!!

O problema da aula passada... (2ª tentativa)

•

^{Versão 2:}

•

Criar um contador para identificar um número a ser analisado e cada thread lê e incrementa esse contador

int counter = 0; //Global compartilhada entre threads int incCounter(void) {

tuto de Informática -UFRGS rissimi -17-mar-11

{ return counter++;

}

void primos (void) { int i;

int limit = power(10,10);

while (i < limit) { i = incCounter();

if (isPrime(i)) print(i);

}

Problemas?

Valores inconsistentes para counter...

Thread A supondo counter=10 Thread B

MOV R,COUNTER (R=10)

MOV R,COUNTER (R=10) INC R (R=11) MOV COUNTER,R (R=11) (cálculo do primo)

( p )

MOV R,COUNTER (R=11) INC R (R=12) MOV COUNTER,R (R=12) (cálculo do primo) MOV R,COUNTER (R=12) INC R (R=13) MOV COUNTER,R (R=13) INC R (R=11)

MOV COUNTER,R (R=11)

Incrementar counter exige duas operações em um objeto compartilhado: ler e escrever!

(2)

Introdução

•

Unidades de execução: processo ou thread

•

Existe concorrência sempre que houver mais de uma unidade de execução no sistema

•

Concorrem (disputam) pelo recurso CPU (pelo menos)

•

Execução pode ser:

•

Independente

•

Colaborativa: duas ou mais unidades de execução interagem para realizar uma tarefa

! necessitam comunicar ou sincronizar com seus pares

•

Programação concorrente assíncrona

•

Atividades podem ser interrompidas sem aviso prévio e de forma não determinística

IMPORTANTE: O discurso é válido tanto para processos como para threads

Estado de um programa sequencial

•

Estado: valores das variáveis em um instante de tempo

•

Explícitas: declaradas pelo programador

•

Implícitas: contador de programa, apontador de pilha, etc

•

Um processo:

•

Estado inicial

! S₀→S₁→S₂→ .... →S_n

! Comando ≡ sequência de uma ou mais ações atômicas

! Ação atômica examina ou modifica estados sem interferências

! Instruções de máquina são indivisíveis

! Ninguém “enxerga” estados intermediários

Estados de um programa concorrente

•

Programa concorrente com dois processos

•

P₁: S₀→S₁→S₂→ .... →S_n

•

P₂: S’₀→S’₁→S’₂→ .... →S’_n

•

Combinações de entrelaçamentos são inúmeras!! →Histórico

•

Alguns entrelaçamentos podem ser indesejáveis

g ç p j

•

Objetivo:

•

Reduzir o número de históricos possíveis eliminando os indesejáveis

•

Como fazer?

•

Sincronização de processos

•

Exclusão mútua

•

Composição de ações de forma a evitar entrelaçamentos indesejáveis

! Leva a resultados inconsistentes

•

Conceito de seção crítica

! Cconjunto de ações de um processo que não podem ser intercaladas com as ações (sobre o mesmo conjunto) de outro processo

•

Condicional

•

“atrasar” a execução de um processo até que uma condição seja satisfeita

(3)

Escalonamento e propriedades

•

Propriedades de programas concorrentes:

•

Safety: programa nunca entra em um estado indejesável

•

Liveness: programa chegará a um estado desejável

•

^Livenessestá associado a fairness

•

Um processo terá a oportunidade de executar independemente

p p p

do que outros processos fazem

•

Escalonador é que determina que é o próximo a ser executado

Modelo de processador

•

Tipos básicos de dados são armazenados em memória e lidos ou escritos de forma atômica

•

Valores são manipulados em registradores

•

Cada processo tem seu conjunto de registradores (lógico)

•

Chaveamento de contexto

•

Valores intermediários de expressões complexas são armazenados em registradores ou em posições privativas de memória (pilha)

Avaliações de expressões

•

Uma expressão eé vista como atômica se:

•

Não referencia variáveis alteradas por outros processos

! Ninguém altera valores que edepende

•

Nenhum processo “enxerga” valores temporários

tuto de Informática -UFRGS

•

Referência crítica:

•

Variável em uma expressão eque pode ser modificada por outro processo

rissimi -17-mar-11

x = e

Propriedade at most once

•

Pode existir no máximo uma variável compartilhada e ele pode ser referenciada no máximo uma vez

•

Uma atribuição x = e satisfaz a propriedade at most oncese

•

A expressão epossui no máximo uma referência crítica e o valor xnão é lido por outro processo

•

A expressão enão possui referência crítica e xpode ser lido por outro processo

rissimi -17-mar-11

Valores lidos dependerão da ordem de execução, mas serão sempre valores válidos!

(4)

Propriedade at most once: exemplos

int x = 0; y = 0;

co x = x + 1;

// y = y + 1;

oc

int x = 0; y = 0;

co x = y + 1;

// y = x + 1;

oc

Sem referências críticas Cada expressão possui uma referência NOK OK

int x = 0; y = 0;

co x = y + 1;

// y = y + 1;

oc

Construção co-ocsegue notação do livro do Andrews.

Sem referências críticas

Um processo faz referência a y, mas xnão é lido por outro processo. O valor final de xpode ser 1 ou 2, e o valor final de yé sempre 1.

Cada expressão possui uma referência crítica e cada processo atribui a uma variável lida pelo outro. Os valores de x e y podem ser 1 e 2, 2 e 1 ou 1 e 1 (inválido).

OK

Primitiva de sincronização: await (Andrews)

•

Executa o comando S de forma indivisível (atômica) somente quando a expressão B (boolean) for verdadeira

•

Forma genérica que expressa exclusão mútua e sincronização

< await (B) S;>

•

Para expressar apenas:

•

exclusão mútua: omite o await(B)

! Operador de atomicidade é “<“ e “>”

•

sincronização condicional: omite o S;

void reserveSeat(Position p) {

}

Exemplos de uso da primitiva <await(B) S;>

•

Ação atômica incondicional: < S;>

•

Aquela que não contém uma condição

! <x = x+ 1; y = y+1; >

•

Ação atômica condicional: < await (B); >

•

Exemplo:

p

! < await (count >0) ;>

•

SE a expressão booleana B atender apropriedadeat-most- onceé possível implementar <await (B); > como while (not B);

Solução para problema seção crítica: exclusão mútua

•

Garantir acesso exclusivo de uma thread* à seção crítica

•

Se uma thread*está executando instruções da seção crítica, outra thread*é impedida de entrar até que a primeira saia

! É o que se denomina de exclusão mútua

•

Resulta em uma serializaçãono acesso

Instituto de Informática -UFRGS A. Carissimi -17-mar-11

•

Primitivas para exclusão mútua: enter_EMeexit_EM

Exit_EM Enter_EM

Seção crítica

(5)

O problema da aula passada... (3ª tentativa)

•

Versão 3:

•

Proteger counterdos acessos concorrentes

int counter = 0; //Global compartilhada entre threads int incCounter(void) {

{ return <counter++;>

}

void primos (void) { int i;

int limit = power(10,10);

while (i < limit) { i = incCounter();

if (isPrime(i)) print(i);

}

Problemas?

Sincronização condicional

•

Situação em que um processo (thread) só pode prosseguir se uma determinada condição for válida

•

Exemplo clássico: produtor-consumidor

•

Situação comum em várias situações: buffer de comunicação, filas de impressão, etc...

•

Princípio:

! Produtor “produz” itens enquanto tiver capacidade de armazenamento.

! Não pode exceder a sua capacidade

! Consumidor “consome” itens enquanto houver disponibilidade

! Não pode consumir o que não existe

•

Variações: nprodutores, mconsumidores, buffer unitário, buffer ilimitado, etc..

Exemplo: produtor-consumidor para cópia de vetores

int buf, p =0, c = 0;

process producer{

int a[n];

while ( p < n ) {

buf = a[p];

p = p +1;

while ( not (p == c) );

Já que B referencia uma variável

} }

Process consumer{

int b[n];

while ( c < n ) {

b[c] = buf;

c = c + 1;

} }

Já que B referencia uma variável alterada por outro processo (at most once).

Espera ocupada ou busy await!!

Livelock = o programa executa, mas não vai a lugar nenhum!! (imagem figurativa!)

Como implementar operações atômicas?

•

Sem suporte de mecanismos de hardware, i.é., em software puro

•

Algoritmo de Dekker

•

Algoritmo de Peterson

•

Algoritmo de Lamport

•

Com suporte de mecanismos de hardware

p

•

Baseado em habilitação/desabilitação de interrupções

•

Instruções atômicas (teste-and-setou swap)

rissimi -17-mar-11

(6)

Leituras adicionais

•

G. R. Andrews Multithreaded, Parallel and Distributed Programming, Addison Wesley, 2000.

•

Capítulo 2 (seções 2.1 a 2.5 e 2.8)

Exemplo: cópia de vetores

int but, p =0, c = 0;

process producer{

int a[n];

while ( p < n ) if( p == c) { buf = a[p];

p = p +1;

Sistemas Operacionais II

} }

Process consumer{

int b[n];

while ( c < n ) if (p > c ) {

b[c] = buf;

c = c + 1;

} }