Relatório do Módulo 5

Alexandre Trentini Nunes da Silveira

Novembro de 2007

1 Introdução
Nesse módulo foi construido um sistema de semáforos para controlar os acessos a áreas
críticas do programa, para isso foi adicionado a biblioteca uma estrutura chamada semaphore_t
e 4 funções que manipulam o semáforo, task_semcreate, task_semdestroy, task_semup e
task_semdown.
A segunda parte do módulo foi uma aplicação desse semáforo em um problema clás-
sico do produtor-consumidor onde temos 3 produtores e 2 consumidores produzindo e consu-
mindo valores inteiros aleatórios em um buffer de 5 vagas.

2 O Semaphore_T
O semaphore_t é estrutura do semáforo, ele possui basicamente 4 atributos, um número
id que o identifica, um contador, uma fila de tarefas e seu status (pronto ou terminado). Todos
são inicializados na função task_semcreate.

typedef struct semaphore_t

{
int id ;
int counter;
struct task_t *queue;
int status;
} semaphore_t;

3 o construtor e o destrutor do semáforo

A função task_semcreate é responsável pela criação do semáforo, ela recebe como
parâmetro o semáforo que deve ser inicializado e o contador para esse semáforo, inicializa o
status como PRONTO e a fila como vazia e retorna 0 se tudo ocorreu bem, se algum erro foi
detectado, retorna um valor negativo.
A função task_semdestroy é responsável por terminar o semáforo, basicamente ele
retira todas as tarefas da fila de suspensos do semáforo e devolve-as à fila de prontas e altera o
status do semáforo para TERMINADO.

1
4 o UP e o DOWN
A função task_semdown é responsável por testar se o semáforo está abaixado, primei-
ramente decrementa o contador do semáforo e testa se o contador é maior que 0, se estiver em
0 ou menos significa que o semáforo está abaixado então suspende a tarefa que tentou alcançar
o semáforo colocando-a na fila de tarefas suspensas do semáforo e retorna ao dispatcher, se o
semáforo não estiver abaixado então a tarefa continua sua execução normalmente.
A função task_semup é responsável por erguer novamente o semáforo, incrementa o
seu contador e se o contador ainda estiver menor ou igual a 0 significa que existem tarefas para
serem acordadas de novo da fila do semáforo, então acorda a primeira tarefa que entrou na fila,
com uma política FIFO.

5 Diagrama de tempo da execução

6 Conclusão
Nesse módulo implementamos uma ferramenta importante de sincronização em nossa
biblioteca, os semáforos, que são largamente utilizados em várias situações especialmente entre
várias threads concorrentes que querem mexer em uma mesma área crítica.
No segundo exercício do módulo foi implementado um caso clássico de uso desses
semáforos, um problema de produtor-consumidor, onde temos um buffer limitado de vagas (5
vagas), temos 3 produtores de valores inteiros e 2 consumidores, cada produtor ou consumidor
pode acessar o buffer um de cada vez, o produtor não pode produzir mais inteiros do que o
número de vagas disponíveis e o consumidor não pode consumir caso não tenha nenhum item
no buffer.
Para isso foram utilizados 3 semáforos, um para o buffer de vagas, outro que controla
o acesso ao buffer, e outro controlando o número de ítens que estão nas vagas, o contador de
vagas começa com 5, pois temos 5 espaços disponíveis no começo do processo, o de acesso ao
buffer inicia com 1, pois somente 1 tarefa pode acessar o buffer de cada vez e o semáforo de
ítens inicia com 0, pois inicialmente não existe nenhum ítem a ser consumido no buffer.
Cabe a cada tarefa manipular esses semáforos de forma correta, os produtores testam se
existem vágas disponíveis e se o acesso ao buffer está liberado, então produz um ítem, levanta o
semáforo de ítens indicando que um ítem foi produzido e levanta o semáforo do buffer indicando
que a tarefa não está mais utilizando o buffer.
O consumidor por sua vez testa o semáforo de ítens, se não estiver em 0 significa que
existem itens a serem consumidos, testa se o buffer está sendo utilizado por mais alguém, então
consome um ítem do buffer, depois ergue o semáforo de vagas indicando que existe um lugar
vago no buffer e ergue o semáforo de acesso ao buffer indicando que não está mais utilizando o
buffer.
No fim das contas os semáforos são soluções simples para problemas bem complexos
entre várias threads concorrentes.

2
Figura 1: Diagrama de tempo de execução.