Semaforos no Windows e Linux

Prévia do material em texto

GRADUAÇÃO À DISTÂNCIA 
ATIVIDADE ACADÊMICA: SISTEMAS OPERACIONAIS 
Módulo 4 - Semáforos 
 
Grupo: Rodrigo de Araújo Rosa e Viviane Becker Dias 
Data: 04/11/2012 
SEMÁFOROS NO WINDOWS E LINUX 
1. INTRODUÇÃO 
Em 1965, E. W. Dijkstra sugeriu usar uma variável inteira para contar o número de sinais de acordar salvos para 
uso futuro. De acordo com a proposta dele, foi introduzido um novo tipo de variável, chamado semáforo. Um 
semáforo poderia conter o valor 0 – indicando que nenhum sinal de acordar foi salvo – ou algum valor positivo se um 
ou mais sinais de acordar estivessem pendentes (TANENBAUM, 2010). 
 
Este trabalho tem por objetivo descrever exemplos teóricos e casos práticos do uso de semáforos em sistemas 
operacionais Linux e Windows, comparando as diferenças de funcionamento, parâmetros e definições de uso entre os 
dois. O exemplo escolhido foi o “Problema do Jantar de Filósofos”, onde temos uma mesa de jantar com cinco 
filósofos (que fazem o papel dos processos). Para conseguir comer um filósofo precisa de dois garfos (recurso 
compartilhado), porém, pela quantidade de garfos existentes na mesa (cinco), não é possível que todos comam ao 
mesmo tempo. Dai temos a necessidade do uso de semáforos. 
 
Semáforos provêm uma abstração simples e elegante que é útil para implementar exclusão mútua e outras 
tarefas de sincronização. Duas operações são definidas sobre semáforos: P (do holandês "proberen", testar): uma 
operação atômica que espera o semáforo ficar positivo, e a seguir decrementa-o de 1. Tanenbaum utiliza down. V (do 
holandês "verhogen", incrementar): uma operação atômica que incrementa o semáforo de 1. Tanenbaum utiliza up. 
 
2. TRABALHOS RELACIONADOS 
Semáforos – Walter Fetter Lages – UFRGS (http://www.ece.ufrgs.br/~fetter/eng04008/sem.pdf) 
 
3. COMPARANDO OS SEMÁFOROS WINDOWS X LINUX 
Os semáforos do Windows são variáveis de contagem que permitem que um número limitado de 
threads/processos acesse um recurso compartilhado. 
No Linux são utilizados semáforos System V, que são um conjunto de valores de semáforos, a criação é 
independente da inicialização, não são destruídos com os processos, pois estão no escopo do sistema e não no escopo 
dos processos que os utilizam. Também é possível utilizar POSIX pthreads como variáveis de contagem. 
Tipo de semáforo: o Windows fornece semáforos nomeados e não nomeados. Semáforos nomeados estendem a 
sincronização entre processos. No Linux, semáforos POSIX são usados somente entre as threads do mesmo processo. 
Entre processos, semáforos System V podem ser utilizados. 
Timeout em funções de espera (wait): quando usado em uma das funções de espera, o valor limite pode ser 
especificado para objetos de semáforo Windows. Isto não está previsto no Linux, ele precisa ser tratado na lógica de 
aplicação. 
Tabela comparativa entre os semáforos de Windows e Linux 
Windows Linux POSIX (threads) Linux System V (Processos) 
CreateSemaphore sem_init semget semctl 
OpenSemaphore Não se aplica semget 
WaitForSingleObject sem_wait sem_trywait semop 
ReleaseSemaphore sem_post semop 
CloseHandle sem_destroy semctl 
 
GRADUAÇÃO À DISTÂNCIA 
ATIVIDADE ACADÊMICA: SISTEMAS OPERACIONAIS 
Módulo 4 - Semáforos 
 
Criando semáforo: no Windows é utilizado CreateSemaphore() para criar ou abrir um semáforo nomeado ou não 
nomeado. Esta função cria o semáforo e retorna um identificador para o semáforo. Ele também define a contagem 
inicial com os valores especificados na chamada. Assim, permite que um número limitado de threads acesse um 
recurso compartilhado. No Linux, sem_init() é utilizada para criar um semáforo POSIX não nomeado que pode ser 
utilizado entre as threads de um mesmo processo. Ainda no Linux, semget() é usada para criar um semáforo System V, 
que pode ser usado entre threads de um processo diferente. É utilizada para obter a funcionalidade de semáforo 
nomeado do Windows. 
Windows Linux POSIX Linux System V 
HANDLE CreateSemaphore( 
 LPSECURITY_ATTRIBUTES 
lpSemaphoreAttributes, 
 LONG lInitialCount, 
 LONG lMaximumCount, 
 LPCTSTR lpName 
); 
int sem_init(sem_t *sem, int pshared, 
unsigned int value) 
int semget(key_t key, int nsems, int semflg) 
 
int semctl(int semid,int semnun,int cmd, union 
semun arg) 
lpSemaphoreAttributes: é um ponteiro para 
os atributos de segurança. Se este for nulo, o 
semáforo não pode ser herdado. 
lInitialCount: determina a contagem inicial 
do semáforo. 
lMaximumCount: é a contagem máxima do 
semáforo e deve ser maior do que zero. 
lpName: é o nome do semáforo. Se esta é 
NULL, o semáforo é compartilhado apenas 
entre as threads do mesmo processo. Caso 
contrário, ele pode ser compartilhado entre 
encadeamentos de processos diferentes. 
*sem: ponteiro para o semáforo 
pshared: pode ser ignorada. 
value: (contador do semáforo) define o valor 
inicial do semáforo. 
 
Cabe salientar que o valor máximo do 
contador baseia-se no SEM_VALUE_MAX 
definido no arquivo de cabeçalho 
semaphore.h. 
 
semget() 
key: é uma chave única 
nsems: é o número de semáforo no conjunto. 
IPC_PRIVATE garante a unicidade. 
semflg: bitwise or entre. IPC_CREAT cria um 
novo semáforo. Modo de acesso: rwxrwxrwx 
SEM_R, SEM_R >> 3, SEM_R >> 6 
SEM_W, SEM_W >> 3, SEM_W >> 6 
 
Retorna o identificador dos semáforos 
associados a key 
 
 
Abrindo semáforo: no Windows, é utilizado OpenSemaphore () para abrir um semáforo nomeado. Isso é necessário 
apenas se o semáforo é compartilhado entre dois processos. Após uma abertura, esta função retorna um identificador 
que pode ser utilizado nas chamadas subsequentes. No Linux, a abertura de um semáforo não se aplica ao POSIX, pois 
este trata de semáforos não nomeados. Já para semáforos System V, a mesma função semget() é utilizada para abrir 
um semáforo nomeado, porém usando 0 (zero) em semflg. 
Windows Linux POSIX Linux System V 
HANDLE OpenSemaphore( 
 DWORD dwDesiredAccess, 
 BOOL bInheritHandle, 
 LPCTSTR lpName 
); 
Não se aplica int semget(key_t key, int nsems, int semflg) 
dwDesiredAccess: é o acesso solicitado para 
o objeto do semáforo. 
bInheritHandle: é a flag que controla a 
herança de semáforos. Se TRUE, handle 
pode ser herdado. 
lpName: é o nome do semáforo. 
 semflg = 0 
 
Bloqueando threads/processos (P/down): A função P(semáforo) ou Down(semáforo) decrementa uma variável do 
tipo semáforo. Quando tenta-se decrementar uma variável do tipo semáforo cujo o valor é 0 (zero), o processo que 
executou o decremento é suspenso, sendo inserido numa lista de processos bloqueados. No Windows, funções de 
espera (wait), oferecem a facilidade para a utilização de objetos de sincronização. Existem diferentes tipos de funções 
de espera disponíveis – aqui, será considerada apenas a função WaitForSingleObject(). Esta função recebe o 
identificador para o semáforo e espera até que seja sinalizado ou um tempo limite se esgota. No Linux, a função 
sem_wait() é usada para permitir o acesso ao semáforo. Esta função suspende a thread de chamada até que o 
semáforo tenha uma contagem diferente de zero. Em seguida, ele atomicamente diminui a contagem do semáforo. A 
opção de tempo limite não está disponível em semáforos POSIX. Isto pode ser conseguido através do uso da função 
sem_trywait() dentro de um loop, o qual conta o valor de tempo limite. Quando o semáforo System V é utilizado, a 
GRADUAÇÃO À DISTÂNCIA 
ATIVIDADE ACADÊMICA: SISTEMAS OPERACIONAIS 
Módulo 4 - Semáforos 
 
função semop() obtém o sinal quando valor inicial é definido pela função semctl() usando o comando IPC_SET. Então, 
semop() executa as operações especificadas no conjunto de operações e bloqueia a thread/processo de chamada até 
que o valor do semáforo seja zero ou maior que zero. 
Windows Linux POSIX Linux System V 
DWORD WaitForSingleObject( HANDLE 
hHandle, DWORD dwMilliseconds );int sem_wait(sem_t *sem) 
 
sem_trywait(sem_t *sem) 
int semop(int semid, struct sembuf *sops, 
unsigned nsops) 
hHandle: é o ponteiro para mutex. 
dwMilliseconds: é o valor de tempo limite 
em milissegundos. Se o valor é INFINITE, 
então ele bloqueia a chamada da 
thread/processo. 
*sem: ponteiro para o semáforo *sops: estrutura sembuf, abaixo: 
struct sembuf { 
 short sem_num; 
 short sem_op; 
 short sem_flg;}; 
sem_num: número do semáforo 
sem_op: operação de semáforo 
sem_flg: sinalizadores de operação 
 
Liberando threads/processos (V/up): a função V(semáforo) ou Up(semáforo) incrementa o valor do semáforo. 
Quanto tentamos incrementar uma variável semáforo que estava com valor negativo, o processo que estava na lista 
de processos bloqueados passa para a lista de processos prontos e poderá ser executado novamente. No Windows a 
função RealeaseSemaphore() é utilizada para liberação. Esta função incrementa a contagem de semáforo para um 
valor especificado e define o estado do semáforo para sinalizado. No Linux, a função sem_post() é usada para liberar o 
semáforo. Este, “acorda” qualquer uma das threads bloqueadas no semáforo. A contagem do semáforo é 
incrementada apenas por 1. Para incrementar a contagem do semáforo por um número especificado (como no 
Windows), esta função pode ser chamada várias vezes junto com uma variável mutex. Para semáforos System V, a 
função semop() tem que ser usada para liberar o semáforo. Para liberar o semáforo, semop() é chamado com sem_op 
como 1 (sem_op > 0 é equivalente à operação signal). Chamando semop() com sem_op como 1, a contagem do 
semáforo é incrementado e o semáforo é sinalizado. 
Windows Linux POSIX Linux System V 
BOOL ReleaseSemaphore(HANDLE 
hSemaphore, LONG lReleaseCount, 
 LPLONG lpPreviousCount); 
int sem_wait(sem_t *sem) 
 
sem_trywait(sem_t *sem) 
int semop(int semid, struct sembuf *sops, 
unsigned nsops) 
hSemaphore: é um ponteiro para o 
manipulador do semáforo. 
lReleaseCount: é a contagem do semáforo 
incrementado. 
lpPreviousCount: é o ponteiro para a 
variável onde a contagem do semáforo 
anterior. O parâmetro pode ser NULL se a 
contagem do semáforo não for necessária. 
*sem: ponteiro para o semáforo *sops: estrutura sembuf, abaixo: 
struct sembuf { 
 short sem_num; 
 short sem_op; 
 short sem_flg; 
}; 
sem_num: número do semáforo 
sem_op: operação de semáforo 
sem_flg: sinalizadores de operação 
 
Fechando/Destruindo semáforos: no Windows a função utilizada para fechar ou destruir um semáforo é a 
CloseHandle(). No Linux, sem_destroy() destrói o objeto do semáforo, liberando os recursos que ele pode conter. 
Para semáforos System V, semctl() com comando IPC_RMID deve ser usado para fechar o conjunto de semáforos. 
Windows Linux POSIX Linux System V 
BOOL CloseHandle(HANDLE hObject); int sem_destroy(sem_t *sem) int semctl(int semid, int semnum, int cmd = 
IPC_RMID, ...) 
hSemahore: é um ponteiro para o 
manipulador do semáforo. 
lReleaseCount: é a contagem do semáforo 
incrementado. 
lpPreviousCount: é o ponteiro para a 
variável onde a contagem do semáforo 
anterior. O parâmetro pode ser NULL se a 
contagem do semáforo não for necessária. 
*sem: ponteiro para o semáforo Utilizando o comando IPC_RMID para destruir 
o semáforo. 
 
 
GRADUAÇÃO À DISTÂNCIA 
ATIVIDADE ACADÊMICA: SISTEMAS OPERACIONAIS 
Módulo 4 - Semáforos 
 
4. EXEMPLOS (print dos exemplos rodando) 
Windows (execução de um programa com o problema do jantar de filósofos resolvido com o uso de semáforos) 
Ao fundo a implementação de semáforos no Windows, também é possível ver o programa sendo executado, o 
processo listado no Process Explorer com PID 8196 e a lista de Threads representando o processo pai (TID 6440) e 
mais 5 threads que representam os filósofos. 
 
LINUX (execução de um programa com o problema jantar de filósofos resolvido com o uso de semáforos System V) 
Ao fundo a implementação de semáforos no Linux utilizando System V, também é possível ver o programa sendo 
executado, o processo pai listado no Linux Process Explorer com PID 4382 e a árvore de Processos, com 5 processos 
representando os filósofos. 
 
GRADUAÇÃO À DISTÂNCIA 
ATIVIDADE ACADÊMICA: SISTEMAS OPERACIONAIS 
Módulo 4 - Semáforos 
 
 
5. CONCLUSÃO 
 
Conforme a análise dos exemplos teóricos e casos práticos, tivemos a oportunidade de comparar as 
diferenças de funcionamento, parâmetros e definições de uso entre dois sistemas operacionais: Windows e Linux. 
 
O Windows fornece semáforos nomeados e não nomeados através de sua API. No Linux para implementar 
semáforos não-nomeados utiliza-se o System V Semaphores do Unix, para semáforos nomeados com Threads é 
utilizado POSIX. Com o exemplo teórico do “Problema do Jantar de Filósofos”, implementado em linguagem C no 
Windows e no Linux foi possível verificar como o programa é executado em diferentes sistemas operacionais, 
seus processos e suas Threads. 
 
6. REFERÊNCIAS 
TANENBAUM, ANDREW S. Sistemas Operacionais Modernos/Andrew S. Tanenbaum; tradução Ronaldo A.L. Gonçalves, 
Luís A. Consularo, Luciana do Amaral Teixeira; revisão técnica Raphael Y. de Camargo. – 3. ed. – São Paulo: Pearson 
Prentice Hall, 2010. 
Comunicação Interprocessos: http://homepages.dcc.ufmg.br/~arabe/so97/aulas/aula04.html 
Port Windows IPC apps to Linux, Part 2: Semaphores and events: 
http://www.ibm.com/developerworks/linux/library/l-ipc2lin2/index.html 
Sistemas Operacionais – Processos Parte 2 – Prof. Dr. Fábio Rodrigues de la Rocha (UTFPR): 
http://www.pb.utfpr.edu.br/frr/pagina/SO/slides/processos2.pdf 
Semaphore: http://comsci.liu.edu/~murali/win32/Semaphore.htm 
The Dining-Philosophers Problem: http://www.lisha.ufsc.br/teaching/os/exercise/phil.html