Documente Academic
Documente Profesional
Documente Cultură
Tpicos
(mutex) Utilidade
Preveno de problema de condio de disputa em regies
crticas
Requisitos para a implementao de excluso mtua
1- Nunca duas entidades podem estar simultaneamente em suas
regies crticas
2- Deve ser independente da quantidade e desempenho dos
processadores
3- Nenhuma entidade fora da regio crtica pode ter a
exclusividade desta
4- Nenhuma entidade deve esperar eternamente para entrar em
sua regio crtica
lock() [ ou enter_region() ]
Garante a exclusividade da regio crtica no ponto de entrada da ... ...
regio lock() lock()
// Iniciao dinmica
Interface de mutex em Pthreads pthread_mutex_t mymutex;
int pthread_mutex_init (pthread_mutex_t *mymutex,
pthread_mutexattr_t *attr);
// Primitivas
int pthread_mutex_init (pthread_mutex_t *mutex,
pthread_mutexattr_t *attr)
int pthread_mutex_lock (pthread_mutex_t *mymutex)
int pthread_mutex_unlock (pthread_mutex_t *mymutex)
int pthread_mutex_trylock (pthread_mutex_t *mymutex)
Exercicio
(1) Modifique o programa mythread.c para proteger a
varivel i contra condio de disputa utilizando
primitivas mutex pthreads.
Exerccio
(2) Compile o programa mythread.c utilizando a
biblioteca libpthread:
cc -o mythread mythread.c lpthread
Exerccio
#include <pthread.h>
pthread_mutex_t mutex;
int i=0;
imprimir_msg(char *nome)
{
while (i<10)
{
Implementao de Mutex
pthread_mutex_lock(&mutex);
i++;
printf("Thread %s - %d\n", nome, i);
pthread_mutex_unlock(&mutex);
sleep(2);
}
printf("Thread %s terminado \n", nome);
}
int main()
{
pthread_t thread1;
pthread_t thread2;
pthread_mutex_init(&mutex,NULL);
printf("Programa de teste de pthreads \n");
printf("Disparando primeiro thread\n");
pthread_create(&thread1, NULL, (void*) imprimir_msg,"thread_1");
printf("Disparando segundo thread\n");
pthread_create(&thread2, NULL, (void*) imprimir_msg,"thread_2");
pthread_join(thread1,NULL);
pthread_join(thread2,NULL);
printf("Terminando processo");
}
Implementao de Mutex
... ...
Descrio while (TRUE) while (TRUE)
Alterna o acesso regio crtica entre duas entidades { {
realiza outras atividades realiza outras atividades
Totalmente em software
Utiliza espera ociosa // lock() // lock()
while (turn!=0); while (turn!=1);
... ...
Desvantagem: regio_critica regio_critica
Viola requisito #3 (Nenhuma entidade fora da regio crtica ... ...
pode ter a exclusividade desta) // unlock() // unlock()
turn=1; turn=0;
Vlida para somente duas entidades (processos/threads)
} }
Utiliza espera ociosa
Soluo de Peterson
Objetivo
Implementao de excluso mtua
Descrio
Totalmente em software
Utiliza espera ociosa
Desvantagem
Exemplo mostrado a seguir vlido somente para 2 entidades
Soluo de Peterson
int turn; // Duas entidades:
int interested[2]; // Entidade 0
// Entidade 1
Instruo Test-And-Set-Lock
Objetivo
Primitiva de baixo nvel para implementao de sincronizao
Descrio
Mutex usando recursos de hardware:
Instruo especial da CPU
Instruo Test-And-Set-Lock Operao
(varivel_memria) registrador (leitura)
1 (varivel_memria) (escrita)
Instruo atmica (indivisvel)
As operaes de leitura da varivel e alterao (escrita) do valor
ocorrem em uma nica instruo. No existe possibilidade de ocorrer
interrupo entre estas operaes.
Acesso atmico memria
Em sistemas multirprocessadores garantido que o acesso memria
(leitura/escrita) seja atmico, ou seja, no seja interrompido entre as
operaes de leitura e escrita
Instruo Test-And-Set-Lock
Exemplo:
Implementao de excluso mtua utilizando TST
var uma varivel alocada na memria
Problema da
Inverso de Prioridade
lock: TST register,(var) # register var; var 1
CMP register,#0 # register == 0?
JNE lock # se register != 0, loop
RET # retorna
Exerccio
(4) Em relao ao problema do produtor-consumidor, faa
um esboo de soluo do problema sem levar em
considerao as condies de disputa.
Exerccios
Produtor
1 Consumidor
1
Produtor
2
Fila Consumidor
Produtor 2
3
Exerccio Exerccio
Primeiro esboo de soluo sem levar em considerao as (b) Em relao ao problema do produtor-consumidor,
condies de disputa analise o cdigo, identifique as condies de disputa e
defina as regies crticas.
Produtor:
Repetir Dica: Inicie pela identificao dos recursos que so compartilhados entre as
Produzir(E); entidades.
InserirFila(F,E);
Consumidor:
Repetir
E = RetirarFila(F);
Processar(E);
Exerccio Exerccio
Identificao das condies de disputa: (c) Em relao ao problema do produtor-consumidor,
identifique necessidades de sincronizao de espera
Condio de disputa
por recursos.
Produtor:
Quais so os recursos que podem eventualmente no
Repetir
estar disponvel exigindo sua espera pela entidade?
Produzir(E);
InserirFila(F,E);
Dica:
Identifique em quais situaes a entidade deve aguardar por recursos estarem
Condio de disputa disponveis. Estes recursos provavelmente so disputados pelas entidades!
Consumidor:
Neste caso especfico, existem 2 recursos: um importante para os produtores e
Repetir outro importante para os consumidores
E = RetirarFila(F); Fila:
Processar(E); recurso compartilhado
pode ser acessado de
forma concorrente
Exerccio Exerccio
Identificao das necessidades de sincronizao de (d) Altere o esboo do programa a fim de
espera por recursos: contornar o problema de espera por recursos
(no se preocupe com condio de disputa, por
enquanto).
Produtor slots livres
problema: quando no existem slots livres na fila
Exerccio Exerccio
Identificao dos pontos de Alterao do programa (sem levar em considerao eventuais
esperar por recursos condies de disputa)
Exerccio Exerccio
(e) Em relao ao problema do produtor-consumidor, Alterao do programa (sem levar em considerao eventuais
condies de disputa)
apresente uma soluo para o problema utilizando
primitivas de excluso mtua.
Produtor:
Repetir
Produzir(E); Condio de disputa
Enquanto FilaCheia(F)
Aguardar;
InserirFila(F,E);
Consumidor:
Repetir Condio de disputa
Enquanto FilaVazia(F)
aguardar;
E = RetirarFila(F);
Processar(E);
Exerccio Exerccio
Primeiro esboo: proteo das regies crticas (f) Em relao ao problema do produtor-consumidor,
Produtor: baseado no esboo da soluo apresentada responda:
Repetir
Produzir(E);
lock(); (a) O produtor, quando possui um item produzido e a fila est
Enquanto FilaCheia(F) cheia o que ocorre?
Aguardar;
InserirFila(F,E);
unlock();
(b) O consumidor, quando deseja retirar um item da fila e a fila
est vazia o que ocorre?
Consumidor:
Repetir
(c) Qual o problema que ocorre nestas situaes no qual no
lock();
Enquanto FilaVazia(F)
existem recursos disponveis?
aguardar;
E = RetirarFila(F);
unlock();
Processar(E);
Exerccio Exerccio
Primeiro esboo: proteo das regies crticas Segundo esboo:
Produtor:
Repetir Produtor() Consumidor()
Produzir(E); { {
lock(); Problemas: repetir repetir
Enquanto FilaCheia(F) { {
Aguardar; (1) Deadlock quando produtor Produzir(E); lock();
InserirFila(F,E); encontra fila cheia lock(); enquanto FilaVazia(F)
unlock(); enquanto FilaCheia(F) {
(2) Deadlock quando consumidor { unlock();
encontra fila vazia
Consumidor: unlock(); lock();
Repetir lock(); }
lock(); } E = RetirarFila(F);
Enquanto FilaVazia(F) InserirFila(F,E); unlock();
aguardar; unlock(); Processar(E);
E = RetirarFila(F); } }
unlock(); } }
Processar(E);
Exerccio Exerccio
(g) Em relao ao problema do produtor-consumidor, (5) O problema do produtor-consumidor pode ser
analise sua soluo e responda: implementado utilizando-se um nico buffer
sincronizado por primitivas de excluso mtua.
(a) A implementao funciona com mltiplos produtores e
mltiplos consumidores?
Produtor
1
(b) Suponha que o sistema seja monoprocessador. Qual tipo de Consumidor
primitiva a mais recomendada: espera ociosa ou 1
bloqueante? Porque?
Produtor
2
(c) Suponha que o sistema seja multiprocessador. Qual tipo de
primitiva a mais recomendada: espera ociosa ou Consumidor
bloqueante? Porque? 2
Produtor
3
Exerccio
O programa prodcons_buffer.c mostra uma implementao da
soluo do problema do produtor-consumidor utilizando-se um
nico buffer sincronizado por primitivas de excluso mtua.