Conceito de processo como uma unidade de trabalho em um sistema moderno de tempo compartilhado. Estados de um processo.

gerenciamento de processos Objetivo Compreender a maneira como o sistema operacional controla o gerenciamento dos programas em execução por meio do gerenciamento de processos no qual cada processo representa a abstração do programa em execução. Conteúdos UNIDADE 2 Conceito de processo como uma unidade de trabalho em um sistema moderno de tempo compartilhado. Estados de um processo. Escalonadores e escalonamento de processos. Cooperação, comunicação e sincronização entre os processos. Threads e Deadlocks.

No início de cada unidade você encontrará as informações práticas para o seu desenvolvimento, os objetivos que pretendemos atingir e o conteúdo que será estudado. Portanto, lembre-se de que sua participação é fundamental para o seu aprendizado. INFORMAÇÃO: Em um instante determinado um programa está sendo executado e, no instante seguinte, este é interrompido para que outro programa ocupe o processador, mesmo que o primeiro ainda não tenha terminado totalmente sua execução. 1 Introdução Na unidade anterior você conheceu o histórico e a evolução dos sistemas operacionais, aprendeu alguns conceitos importantes para o seu estudo, como por exemplo a multiprogramação. Você pôde compreender que um sistema multiprogramável permite a execução de diversas tarefas ao mesmo tempo, simulando um ambiente de monoprogramação para cada usuário, sendo que cada um tem a sensação de estar utilizando um processador exclusivamente para si. Mas vimos que o que realmente acontece é a divisão do tempo do processador para todos os programas (time-sharing). Nesta unidade você aprenderá mais sobre o chaveamento de programas, ou seja, a troca de programas no processador e, principalmente, sobre a entidade que torna essa troca possível, chamada de processo. Além de técnicas e algoritmos utilizados para realizar o escalonamento e a sincronização entre processos, respectivamente. 2 Definição de processos Um processo é tudo aquilo que o processador executa efetivamente, ou seja, é a entidade pela qual a utilização da memória de um programa, tempo de processador e recursos de E/S podem ser gerenciados e monitorados pelo sistema operacional. O processo pode ser visto como a abstração de um programa em execução. A divisão do processador em vários processos significa que em um instante o sistema operacional decide interromper um processo em execução, e dar o processador a outro processo, pois o primeiro já utilizou sua porção do processador. Se um processo é interrompido, em um dado momento, para que outro ocupe o processador, quando esse voltar a ser executado em que ponto deverá continuar? Quando um processo é suspenso, todas as informações sobre ele são armazenadas em uma estrutura chamada tabela de processo, mantida pelo SO. O chaveamento rápido dos processos na CPU dá aos usuários a sensação de paralelismo na execução dos programas. O que não é verdade, pois o que acontece realmente é um pseudo-paralelismo. O verdadeiro paralelismo acontece apenas em sistemas com múltiplos processadores. As informações de um processo são: um programa executável, os dados e a pilha do programa, o contador de programa, o ponteiro de pilha, registradores e as informações necessárias para executar o programa. Esta estrutura pode ser implementada como uma lista encadeada de processos. 3 Modelo de procresso O processo possui uma natureza seqüencial, ou seja, se um processo for executado várias vezes com os mesmos dados, a mesma seqüência de instruções será executada e fornecerá o mesmo resultado em todas as execuções. Todo software executável em um computador moderno, até mesmo o sistema operacional, é organizado em processos. Sistemas de multiprogramação permitem ao usuário a execução paralela de vários processos. Porém, o que acontece é um chaveamento rápido dos processos na CPU que dá aos usuários a sensação de paralelismo na execução dos programas. Esse pseudoparalelismo, definido como multiprogramação é caracterizado pelo chaveamento de processos pela CPU. O verdadeiro paralelismo acontece apenas em sistemas com múltiplos processadores. 16 CRC Sistemas Operacionais Claretiano Batatais

A cada instante, um processador diferente ocupa o processador e pode rodar independentemente dos outros existentes, pois cada um possui sua própria memória virtual e fluxo de controle (contador de programa). Desta forma, a velocidade de execução dos processos depende da quantidade, e também dos recursos oferecidos pelo computador. Por exemplo: Se você tiver três aplicativos rodando em sua máquina, terá uma velocidade de cada processo reduzida conforme carrega outros aplicativos ao mesmo tempo, porque outros processos estão na competição pelo processador. Dependendo da velocidade do processador e da quantidade de processos, o trabalho poderá ser prejudicado, ou até mesmo inviabilizado. A troca de processos consiste, basicamente, em salvar o conteúdo atual dos registradores da CPU, referentes a um processo que esteja deixando o processador, e carregá-los com o conteúdo do processo que esteja ganhando a CPU. Observe o esquema da Figura 1 a seguir que representa a mudança de contexto entre dois processos. Processo X S.O. Processo Y fim 1) Salva conteúdo dos Registradores de A 2) Carrega Registradores de B início execução execução Figura 1 Troca de processos na CPU. Nos computadores modernos o gerenciamento de processos é feito pelo sistema operacional. Para o gerenciamento de processos o Sistema Operacional atribui, basicamente, três conjuntos de informações: identificação do processo; quotas de recursos; privilégios. A identificação de um processo é feita pelos seguintes campos: PID (process identification) identificação única de cada processo. Owner campo que armazena a identificação de quem o criou: pode ser um PID, no caso de ser criado por outro processo, ou um UID (user identification), no caso de ter sido criado por um usuário. Assim como os processos possuem uma identificação única no sistema (PID process identification), os usuários também são identificados unicamente por um UID (user identification). O ID (identificação) do usuário é muito útil quando desejamos controlar o acesso aos arquivos, aos processos e memória por questões de segurança. Sistemas Operacionais CRC Batatais Claretiano 17

As quotas de recursos identificam a quantidade de recursos que um processo pode utilizar. Alguns exemplos destes recursos são: tamanho máximo de memória, tamanho do para E/S e número máximo de arquivos abertos simultaneamente. Se a quota alocada não for suficiente para a execução do processo, este será prejudicado. Se a cada instante um processo diferente ganha a CPU, pode-se constatar que existem alguns privilégios. Estes privilégios definem qual a permissão que cada processo tem para utilizar o sistema, alguns exemplos são: ele pode acessar, criar e eliminar outros processos; ele pode acessar arquivos de outros usuários. 4 Estados Dos processos Você já sabe que o processador não pode ser ocupado por todos os processos existentes no sistema em um mesmo instante, então todos competem para ganhar o processador. O sistema operacional é responsável por controlar essa competição entre os processos, ou seja, ele diz em que momento e quais processos devem entrar ou deixar a CPU (estado de execução). Esta transição de processos entre os três estados possíveis, permite que os processos mudem de estado várias vezes durante sua existência. Como você viu na primeira unidade existem, basicamente, três estados principais que um processo pode estar:, ou. Conforme as situações descritas a seguir. quando todos os recursos necessários para sua execução já estão disponíveis, mas ainda não pode entrar em execução porque não chegou sua vez e a CPU está ocupada por outro processo. Neste estado pode haver uma fila de processos esperando a liberação da CPU. quando o próprio processo está ocupando a CPU e sendo executado. quando o processo estava em execução, mas precisou de um recurso que não estava disponível no momento, então ele é bloqueado até que o recurso desejado esteja disponível. A Figura 2 apresenta as transições possíveis entre os estados de um processo. Observe que um processo bloqueado não pode voltar diretamente para a CPU, deve antes passar pelo estado de pronto, se não houver nenhum processo prioritário na frente e se seu tempo de CPU ainda não se esgotou, então aí sim ele poderá voltar para o estado de execução. Um processo que sai da CPU porque seu time-slace (fatia de tempo) já terminou, volta para o estado de pronto e aguarda, juntamente com outros processos, até ser eleito novamente pelo sistema operacional para entrar em execução. 18 CRC Sistemas Operacionais Claretiano Batatais

Processo Fila de processos esperando escalonamento 0 1... n-2 n-1 n Escalonador Processo Processo Processo Processo Figura 2 Estados possíveis de um processo. Um processo pode denominar outros subprocessos que executam de maneira hierárquica. Veja no tópico a seguir. Escalonador é um componente que faz parte do Sistema Operacional. Ele tem a função de selecionar qual dos processos concorrentes ganhará a CPU. Este escalonador se baseia em algoritmos de escalonamento para definir os critérios para seleção de um processo. 5 Subprocessos e thread Uma aplicação pode ser dividida em partes que trabalham concorrentemente. Essa divisão da aplicação consiste em particionar o processo gerado para controlar a aplicação (processo pai) em outros subprocessos subordinados a este que são chamados de processos filhos, ou apenas subprocessos. Os subprocessos, por sua vez, podem criar outros processos filhos em uma estrutura hierárquica de subprocessos. Esta hierarquia faz com que todos os processos filhos de um processo pai sejam destruídos caso o processo pai deixe de existir. Pa Pb Pc Pd Pe Pf Pg Figura 3 Representação hierárquica de processos. Conforme aumenta a utilização de subprocessos há um desperdício de tempo gasto para criação e eliminação desses subprocessos. Para minimizar este problema, introduziu-se o conceito de threads de controle (ou linhas de controle). Sistemas Operacionais CRC Batatais Claretiano 19

As threads são consideradas processos mais leves e representam uma entidade básica de utilização da CPU. Enquanto os processos são usados para agrupar recursos, as threads são as entidades escalonadas para a execução na CPU. INFORMAÇÃO: A diferença mais marcante entre subprocessos e threads é que enquanto os subprocessos utilizam espaços de memória independentes e protegidos, as threads compartilham o mesmo espaço de endereçamento do processo. Para você compreender melhor a utilidade de threads, considere um navegador web. Você sabe que muitas páginas na Internet são carregadas de imagens e outros recursos pesados. Se para cada imagem o navegador tiver que estabelecer uma conexão separada com o servidor para solicitar uma imagem, o procedimento seria muito difícil. Mas se o navegador implementar múltiplas threads, é possível fazer a requisição de muitas imagens ao mesmo tempo melhorando o desempenho e a capacidade de resposta. A Intel lançou no mercado um modelo de processador com a tecnologia Hyperthreading, que permite que se processe, dentro de um mesmo ciclo de clock, instruções referentes a várias threads e não apenas várias instruções dentro de uma mesma thread. Os sistemas multiprogramáveis possibilitam o compartilhamento da CPU entre diversos processos concorrentes. Para isso, cada sistema possui critérios para determinar qual será a forma de seleção de um dos processos que ocupará a CPU. Este procedimento de seleção é realizado pelo sistema operacional e conhecido como escalonamento de processos. 6 escalonamento dos processos Você compreendeu que o estado de pronto possui uma fila de processos aguardando a liberação da CPU para entrarem em execução e cabe ao sistema operacional decidir qual processo terá a posse do processador? Na tentativa de manter o processador ocupado 100% de seu tempo, o sistema operacional possui um componente de seleção que escolhe um dos processos que ocupará a CPU, este componente é chamado de escalonador e utiliza um algoritmo de escalonamento para definir os critérios de seleção de um processo. Os algoritmos de escalonamento podem ser divididos em três categorias: Não-preemptivos utilizados em processamento batch. Quando um processo (job) ganha a CPU, nenhum outro poderá tirar-lhe este recurso. Exemplos de implementação: FIFO (First In First Out) o primeiro da fila de pronto será o primeiro a executar e SJF (Shortest Job First) escolhe sempre o processo que precisa de menos tempo de CPU. Cooperativos um processo libera, voluntariamente, a CPU para outro. O grande problema é a monopolização do processador. Preemptivos o sistema interrompe um processo em execução para que outro ocupe o processador. A seguir você conhecerá os detalhes deste tipo de algoritmo. Exemplos de algoritmos de escalonamento PREEMPTIVOS: Round Robin Este algoritmo aloca um intervalo de tempo, conhecido como quantum, para cada processo. 20 CRC Sistemas Operacionais Claretiano Batatais

Ao final de seu quantum, se o processo ainda estiver em execução voltará para o estado de pronto e o próximo processo da fila será alocado para ocupar a CPU. Se o processo terminar antes de finalizar o seu quantum a CPU será liberada imediatamente para o próximo processo. Se o processo for bloqueado para esperar algum recurso externo antes de terminar o quantum, a CPU é liberada para outro processo, e esse voltará para a fila de pronto assim que o recurso for liberado. Neste momento, se a CPU estiver livre, ele a ocupará imediatamente, senão deverá entrar na fila de espera. Você deve estar se perguntando: Qual é o tamanho de um quantum? Se o quantum for muito grande poderá degradar o tempo de resposta. Se for muito pequeno, diminui a eficiência da CPU que terá uma sobrecarga de processamento para realizar o chaveamento de recursos entre processos. O ideal seria um balanceamento de acordo com a carga dos processos, mas tal não é fácil de ser gerenciado. Essa é maior dificuldade deste algoritmo Prioridade Este algoritmo considera níveis de prioridade entre os processos, permitindo um tratamento especial em casos de emergência, pois processos de maior prioridade podem ser executados. O problema seria se processos de alta prioridade executassem indefinidamente, mas neste caso o escalonador pode diminuir a prioridade do processo corrente e trocá-lo pelo próximo com maior prioridade (chaveamento). Múltiplas filas Este algoritmo adota várias classes de prioridades. Cada classe possui um quantum diferente. Desta forma, processos menores entram na fila de menor quantum, processos maiores entram na fila de maior quantum, e assim por diante. Shortes process next (Tarefas Pequenas Primeiro) Lembra da idéia do algoritmo não-preemptivo SJF (Shortest Job First)? A idéia é a mesma, ou seja, na tentativa de minimizar o tempo médio de espera pelo processador tarefas menores são executadas primeiro. Apesar das soluções apresentadas para escalonamento de processos, há ocorrências em que os recursos do sistema são compartilhados. Compartilhar, principalmente os espaços de memória, pode ocasionar diversas situações indesejadas de discriminação de processos caso não seja bem controlada. Nestes casos dizemos que há concorrência entre processos. No próximo tópico será apresentada uma descrição dos problemas típicos em computação gerados pela concorrência entre processos. Se encontrar dificuldades não desanime! Entre em contato com seus colegas de curso e seu professor que estará sempre pronto para esclarescer suas dúvidas. 7 Concorrência entre processos Os processos concorrem pelos recursos do sistema que normalmente podem atender a uma única requisição por vez. Sistemas Operacionais CRC Batatais Claretiano 21

(1) Fila de impressão A regra é simples, o primeiro arquivo que chega será o primeiro a ser impresso, e assim sucessivamente. Quando processos compartilham a mesma área de memória, ou o mesmo arquivo ou qualquer outro recurso compartilhado, existem situações de concorrência entre os processos por aquele recurso, esta situação de competição é conhecida por Race Conditions. Suponha a fila de impressão 1 (spool directory) com uma variável que indica onde a fila começa, ou seja, o próximo documento a ser impresso; e outra variável que indica o final da fila, ou seja, o último documento que chegou, portanto o último que será impresso. Todos os processos que desejam imprimir deverão consultar a próxima posição livre para colocar seu documento (fim+1). Imagine a seguinte situação (considere que os documentos das posições de 1 a 4 já foram impressos). começo fim SAÍDA so.pdf ed.doc index.htm mail.txt 5 6 7 8 9 10 11 Figura 4 Fila de impressão (spool directory). Imagine um processo X em execução que consulta a próxima posição vazia (fim+1) para inserir seu documento. No exemplo da Figura 4 o processo obterá o valor 9. Só que antes de armazenar, de fato, o seu arquivo na posição 9 da fila, o Sistema Operacional, subitamente, envia uma interrupção para que o processo X deixe a CPU, pois seu tempo já se esgotou. O SO salva as informações dos registradores, inclusive a posição 9 da fila de impressão, e libera a CPU para o processo Y. Este entra em execução e também deseja enviar um documento para ser impresso e, da mesma forma, obtém a próxima posição (fim+1) para inserir seu documento, esta posição continua sendo 9, pois o processo X não teve tempo de ocupá-la. O processo Y insere seu arquivo na fila e atualiza a variável fim com o valor 9, isso indica que a próxima posição livre (fim+1) será a 10 e não mais a 9. começo fim SAÍDA so.pdf ed.doc index.htm mail.txt foto 5 6 7 8 9 10 11 Figura 5 Inserção do arquivo foto.jpg na fila de impressão. Neste instante, o processo Y volta para o estado de pronto e libera a CPU para o processo X que continuará a executar do local que parou utilizando as informações armazenadas dos registradores, ou seja, colocará seu documento na posição 9 da fila de impressão. Este novo documento, contas.xls, irá sobregravar o documento e o arquivo foto.jpg nunca será impresso. 22 CRC Sistemas Operacionais Claretiano Batatais

começo fim SAÍDA so.pdf ed.doc index.htm mail.txt contas 5 6 7 8 9 10 11 Figura 6 Inserção do arquivo contas.xls na fila de impressão. A solução para resolver o problema anterior é chamada de exclusão mútua e garante que se um processo estiver utilizando um recurso compartilhado, os outros processos serão impedidos de fazer o mesmo. O nome dado à parte de um programa executada concorrentemente é região crítica e sua implementação deve obedecer a quatro condições: a) Dois processos não podem estar dentro de suas regiões críticas de um mesmo recurso compartilhado ao mesmo tempo. Isso garante a exclusão mútua dos processos. b) A exclusão mútua dos processos deve ser independente da velocidade dos processos ou o número de CPU s. c) Um processo executado fora da região crítica não pode bloquear outros processos. d) Nenhum processo esperará para sempre para entrar em sua região crítica. Existem vários algoritmos criados para garantir que todas estas condições sejam seguidas. Tais algoritmos possuem características particulares, porém todos têm o mesmo propósito: implementar eficientemente a exclusão mútua. Exclusão mútua com espera ocupada É a garantia que um recurso compartilhado será utilizado por apenas um processo de cada vez. Se um processo está acessando uma região crítica, ou seja, esta em execução, todos os outros processos que precisarem acessar esta região deverão entrar em estado de espera ocupada, mas esta espera se refere apenas à região crítica. Isso significa que eles poderão continuar disputando a CPU e utilizando outros recursos, mas ainda não poderão executar a região crítica. Desabilitar Interrupções Para que o sistema operacional controle a transição de processos em execução, utiliza envio de interrupções de hardware para os processos avisando sobre a mudança de estado. Uma possível solução de exclusão mútua com espera ocupada permite desabilitar todas as interrupções, inclusive as do sistema operacional, quando uma região crítica está sendo acessada, garantindo que o processo em execução termine de executar a região crítica sem a intervenção de outros processos. Todavia, o custo desta solução é caro, pois processos de usuário têm o poder de desabilitar as interrupções do sistema e se, por algum motivo (de implementação, de hardware), não puder reabilitar as interrupções, o sistema operacional perderá integralmente o controle do hardware. A exclusão mútua em regiões críticas garante que mais de um processo não acessará o mesmo recurso compartilhado ao mesmo tempo. INFORMAÇÃO: O sistema operacional, bem como outros arquivos de sistema e de usuários, pode gerar interrupções. Um caso comum é o Sistema Operacional gerar interrupções obrigando um processo a deixar a CPU. As soluções que implementam exclusão mútua com espera ocupada serão descritas no decorrer do texto. Você não precisa decorar tais soluções, basta entender como elas funcionam e quais são as técnicas possíveis, utilizadas pelo sistema operacional, para resolver problemas de acesso simultâneo em regiões compartilhadas. Variável LOCK Esta solução utiliza um algoritmo em que cada recurso compartilhado possui uma variável global chamada lock, com valor inicial igual a 0. O algoritmo controla o acesso à região crítica por meio da variável lock. Ao consultar, se o seu valor for 0, o processo executará a região crítica; e se for 1, o processo aguardará até que a variável lock se torne 0. Sistemas Operacionais CRC Batatais Claretiano 23

Um processo que precisa entrar em sua região crítica testa o valor de lock. Se o valor for 0 o processo altera para 1 e executa a região crítica até o final. Se o valor for 1, espera até que seja 0. Desta forma sempre existem duas opções: lock=0 execução da região crítica liberada; lock=1 espera da liberação para executar a região crítica. Você achou este algoritmo uma boa solução? Realmente, os problemas parecem ser solucionados, mas esta solução se torna inviável se dois ou mais processos tentam acessar a variável lock e obtém o valor 0 ao mesmo tempo. Refletiria assim, a situação inicial (exemplo da fila de impressão) do problema de concorrência. Alternância Estrita ou Variável TURN Alternância estrita é uma solução implementada em software que utiliza uma variável turn para indicar o processo com direito de executar a região crítica naquele momento. Se turn for igual a i, o processo de número i executará a região crítica até terminar. Ao sair, o processo altera o valor de turn para i+1 para que o próximo processo, ao executar, tenha acesso à região crítica. Na verdade é uma solução simples e que garante a exclusão mútua. O problema desta solução surge quando processos possuem freqüências diferentes de acessos à região crítica, ou seja, um processo que utiliza muito uma região crítica poderá ser prejudicado se tiver que ficar ocioso esperando os acessos de vários outros que precisam menos deste recurso compartilhado. Solução de Peterson Esta solução combina as duas últimas soluções que nós vimos anteriormente, variáveis lock e turn solucionando os problemas individuais de cada uma delas. Instrução TSL Test and Set Lock é uma instrução utilizada em muitos processadores que permite, neste caso, a implementação de variáveis lock. A característica das instruções TSL é que são executadas do início ao final pelo processador, não permitindo a divisão de sua execução, mesmo em caso de interrupções de hardware. Funcionamento da instrução TSL. Para compreender melhor o funcionamento da instrução TSL, leia o algoritmo ao lado que implementa a exclusão mútua por esta técnica. Atente para os comentários em itálico. entra_regiao: tsl register, flag copia flag para o registrador e seta flag para 1 cmp register,#0 a flag é zero? jnz entra_regiao se diferente de zero, já tem lock, então fica no loop ret retorna para quem chamou; conseguiu entrar na região crítica sai_regiao mov flag, #0 libera a execução da região crítica e armazena um 0 em flag ret retorna para quem chamou 24 CRC Sistemas Operacionais Claretiano Batatais

As soluções apresentadas para a exclusão mútua com espera ocupada não impedem que os processos que esperam para executar a região crítica, continuem competindo pela CPU e executando outras instruções. A exclusão mútua pode, porém, ser implementada usando outra técnica; os processos que competem pela região crítica serão bloqueados e somente um poderá continuar executando a região crítica e também a CPU. Esta solução é chamada de Exclusão Mútua com Espera Bloqueada. Exclusão mútua com espera bloqueada Para garantir a exclusão mútua de forma mais eficiente, em uma tentativa de eliminar os problemas causados pelas técnicas apresentadas foram propostas outras, caracterizadas pelo bloqueio de processos enquanto um deles está executando uma região crítica. Dorme e Acorda (Sleep and Wakeup) crítica: Este método utiliza duas variáveis para controlar a entrada-saída na região Sleep é uma chamada de sistema que altera o estado de um processo em execução para bloqueado (dormente). Wakeup é uma chamada de sistema, feita por um processo, que acorda o processo tornando-o ativo novamente, saindo do estado de bloqueado. Se você entendeu como funciona a Instrução TSL, não terá problema em compreender este método. Note que o princípio utilizado é o mesmo, exceto que neste caso, o controle da ocupação-liberação da região crítica será feito por chamadas sleep e wakeup, ou seja, quando a variável está setada com 1, o processo executa sleep. O processo que altera o valor de LOCK para 0 ao sair da região crítica é o responsável por ativar um processo bloqueado (via wakeup). O programador é o responsável pela execução destas chamadas, sleep e wakeup. Pode não ser uma idéia boa, uma vez que erros no programa podem causar uma situação na qual todos os processos ficam bloqueados ao mesmo tempo, ocasionando o que chamamos de deadlock 2. Há um exemplo clássico, utilizado na maioria dos livros que ensinam sistemas operacionais, para demonstrar a utilização do método dorme e acorda. Esse exemplo é conhecido por Produtor-Consumidor. (2) Deadlock é uma situação em que todos os processos no sistema se encontram em estado de bloqueado () e não há como acordá-los. O problema do Produtor-Consumidor considera um de tamanho fixo que é compartilhado por dois processos, um processo que insere elementos no, conhecido como produtor e outro que retira os elementos do, conhecido como consumidor. A regra principal é que o produtor não pode inserir elementos se o estiver cheio e o consumidor não pode remover elementos se o estiver vazio. A solução parece ser simples se considerarmos algumas regras durante a implementação, enumeradas a seguir. Para o processo produtor: Antes de inserir no o produtor verifica se ainda há espaço para inserção. Se houver, ele insere, se não houver, ele vai dormir e espera o consumidor acordá-lo quando um novo slot estiver livre. Ao inserir o primeiro elemento do, o produtor sabe que o consumidor estava, pois não havia nada para ele consumir, e então envia uma chamada para que ele acorde (wakeup). Sistemas Operacionais CRC Batatais Claretiano 25

Para o processo consumidor: Lembre-se de que o escalonador, a qualquer momento, pode selecionar outro processo para ocupar a CPU, ou seja, entrar em estado de execução. Porém, o escalonador não interfere no estado dormir, pois quem pode dar ordens para um processo dormir-acordar são apenas os processos produtor e consumidor. Leia o programa linha a linha fazendo a execução mental e veja se encontra algum problema nesta solução. Antes de consumir um elemento do, o consumidor testa para confirmar que há elementos. Caso não haja, ele vai dormir e espera que o produtor o acorde quando o primeiro elemento for inserido. Ao consumir o último elemento do, o consumidor envia uma chamada, acorda o produtor e avisa que há posições livres para serem preenchidas. Acompanhe a seguir como ficaria a implementação desta solução do problema produtor-consumidor em pascal. PROGRAM ProdutorConsumidor; CONST N = 10; {número de slots no } VAR : ARRAY [1..N] OF INTEGER; elem : INTEGER; count : 0..N; {contador de elementos no } PROCEDURE produtor; REPEAT produz_elem (elem); IF (count = N) THEN sleep(); {repita para sempre} {produz um novo elemento} {enquanto o estiver cheio, produtor vai dormir} {se couber elementos no, insere elemento na posição count} insere_ (elem, count); count := count +1; {incrementa contador} IF (contador == 1) THEN wakeup(consumidor); {se o estava vazio, acorda o consumidor} UNTIL false; END; PROCEDURE consumidor; REPEAT {repita para sempre} IF (count = 0) THEN {se vazio, consumidor vai sleep(); dormir} {se o não estiver vazio, consumidor consome elemento} remove_elem (elem); count := count - 1; {decrementa contador, libera uma posição do } IF (contador == N-1) THEN wakeup(produtor); {se o estava cheio, acorda o produtor} WRITELN(elem); UNTIL false; END; {imprime elemento} count := 0; END. 26 CRC Sistemas Operacionais Claretiano Batatais

Se você analisou algumas possibilidades, pode ter encontrado um problema gravíssimo na utilização deste método (Sleep-Wakeup). Pode acontecer dos dois processos, produtor e consumidor, dormirem para sempre sem que o sistema operacional volte a ter controle sobre eles! A Tabela 1 detalha uma seqüência de execução do programa que mostra como isso pode acontecer. Tabela 1 Seqüência de execução do programa ProdutorConsumidor.pas. SITUAÇÃO REAL SITUAÇÃO CONHECIDA PELO PRODUTOR SITUAÇÃO CONHECIDA PELO CONSUMIDOR count 0 O escalonador decide que o processo consumidor entrará em execução. Consumidor testa variável count e obtém o valor 0 (não há o que consumir, deve ir dormir. Antes de o consumidor dormir, seu time slice termina e ele entra em estado de pronto e guarda o count = 0. c c count 0 count 0 O escalonador decide que o processo produtor entrará em execução. Produtor consulta o count e obtém valor 0 (significa que o consumidor está ). Produtor insere um elemento no, incrementa o contador e envia um sinal de acorda para o consumidor, que nunca receberá o sinal, pois estava bloqueado pelo sistema esperando um novo time slice (situação real) e não (situação conhecida pelo Produtor). p c c p a c o r d e X count 1 X count 1 Sistemas Operacionais CRC Batatais Claretiano 27

SITUAÇÃO REAL SITUAÇÃO CONHECIDA PELO PRODUTOR SITUAÇÃO CONHECIDA PELO CONSUMIDOR O escalonador decide que o processo consumidor entrará em estado de execução, pois seu tempo de CPU terminou. Enquanto isso, o produtor vai para o estado de pronto aguardar novo time slice. O produtor imagina que o processo consumidor já está acordado, pois havia enviado um sinal de acorda. Consumidor continua sua execução de onde havia parado. Agora sim, ele dormirá achando que o count continua valendo 0 (informação obtida antes de terminar seu time slice mesmo problema do spool de impressão). p p c c X count 1 count 0 Quando o processo produtor for escalonado novamente para entrar em execução preencherá todas as posições do (até count chegar a 10) e dormirá. Só o produtor poderia acordar o consumidor, mas como acredita que já tenha feito isso, não fará novamente. Problema: Ambos irão dormir para sempre! C P C P P C X X X X X X X X X X count 10 X X X X X X X X X X count 10 count 0 Depois de acompanhar a execução do programa, você viu que o método sleepwakeup não é suficiente para resolver o problema do produtor-consumidor. Uma alternativa é utilizar um bit de controle que recebe um valor true quando uma chamada é enviada para um processo que não está. Porém, esta solução possui uma deficiência: o sistema pode sobrecarregar se houver muitos pares de processos, pois necessitariam de muitos bits de controle. Na tentativa de otimizar a solução do problema produtor-consumidor presente no método sleep-wakeup, propôs-se um outro método chamado de semáforos, que trataremos no próximo tópico. Semáforos Um semáforo pode ser manipulado por duas instruções: down e up, que funcionam como protocolos de entrada e saída de um processo em sua região crítica, respectivamente. 28 CRC Sistemas Operacionais Claretiano Batatais

O semáforo indica quando um recurso compartilhado está sendo acessado por outro processo concorrente. Se o valor do semáforo for maior que 0, o recurso está livre; se for igual a 0 o recurso está ocupado por outro processo. Um down (sleep) é executado sempre que o processo deseja entrar em uma região crítica. Se o valor do semáforo for maior que 0, será decrementado e o processo executa sua região crítica; se o valor for igual a 0, o processo é posto na fila de espera sem completar a operação de down. Uma instrução up (wakeup) é executada sempre que o processo sai da sua região crítica, neste caso incrementa-se o valor do semáforo liberando o recurso compartilhado. Se houver processos na fila de espera, o sistema escolherá um deles e enviará uma chamada wakeup, este processo vai para o estado de pronto e poderá completar a operação de down assim que a CPU for liberada. Observe a seguir a implementação de semáforo em Pascal.... TYPE Semaforo = RECORD elem : INTEGER; fila_espera : {fila com processos aguardando a CPU} END; PROCEDURE down (VAR s: semaforo); IF (s=0) THEN {processo entra na fila de espera} ELSE s := s 1; END; PROCEDURE up (VAR s: semaforo); s := s + 1; IF (tem_processo_na_fila_de_espera) THEN {um processo sai da fila de espera e vai para pronto} END;... END. Apesar da facilidade do uso de semáforos, eles não excluem totalmente as ocorrências de deadlocks, pois um engano no envio de chamadas do sistema pode gerar uma situação de bloqueio mútuo dos processos. Um outro método, conhecido por Monitores, pode representar uma solução eficiente para este problema. Monitores Os monitores constituem um método de sincronização entre processos concorrentes. Eles são formados por um conjunto de procedimentos, variáveis e estrutura de dados em um único módulo. Sua principal característica é que apenas um processo pode estar ativo dentro do monitor em um instante (exclusão mútua), enquanto outros ficam bloqueados esperando a liberação do monitor. Sistemas Operacionais CRC Batatais Claretiano 29

A utilização de monitores consiste em escrever o programa colocando todas as regiões críticas em forma de procedimentos no monitor e o compilador será o responsável por garantir a exclusão mútua destes procedimentos. O exemplo a seguir demonstra a utilização de monitor em Pascal. PROGRAM monitores;... MONITOR regiao_critica; VAR elem : INTEGER; PROCEDURE multiplica; elem := elem * 2; END; PROCEDURE divide; elem := elem DIV 2; END; elem := 0; END; PAR regiao_critica.multiplica; regiao_critica.divide; PAREND; END. A implementação da exclusão mútua nos monitores é realizada pelo compilador e não pelo programador, como acontecia com os semáforos. O compilador é quem reconhece um monitor e quem tratará este mecanismo. Sua utilização pode não ser possível, pois não são todas as linguagens de programação que incorporam este conceito. 8 Trocas de mensagens A troca de mensagens garante, além da sincronização, a comunicação entre os processos. Uma comunicação acontece quando há intercâmbio de informações entre os processos concorrentes e objetiva a cooperação entre eles. A troca de mensagens é implementada pelo sistema operacional por meio de duas chamadas de sistema: send(destino, $mensagem); receive(origem, $mensagem); Send envia mensagem para um processo receptor (destino especificado), e o procedimento receive recebe esta mensagem de um processo transmissor em uma origem especificada. Se não houver mensagens disponíveis, o procedimento receive é bloqueado até que uma nova mensagem seja entregue. 30 CRC Sistemas Operacionais Claretiano Batatais

Você pode perceber facilmente a comunicação entre os processos quando ocorre a troca de mensagens. A sincronização acontece quando uma mensagem só pode ser lida após ter sido enviada, isso significa que não há mais o problema de trocar a ordem de execução dos eventos. Resolvido o problema da ordem de execução dos processos, parece que todos os problemas apresentados pelas soluções anteriores foram resolvidos. Mas ainda existem situações que precisam ser consideradas. Situação 1 Lembrando que os recursos compartilhados podem estar em rede e que, portanto, as mensagens send/receive trafegam de uma máquina para outra, maximizando a ocorrência de perda de mensagens no meio do caminho. Alternativa para a situação 1 Para resolver a perda de mensagens utiliza-se uma mensagem de confirmação de recebimento, conhecida por acknowledgement, ou simplesmente ACK. Após enviar uma mensagem send, se o transmissor não receber um ACK em um determinado intervalo de tempo, ele retransmite a mensagem. Situação 2 A alternativa para a situação 1 parece resolver o problema da perda de mensagens, mas há uma 2ª situação. A mensagem é recebida corretamente pelo receptor e envia um ACK, mas quem se perde desta vez é o ACK. Desta forma o send retransmitirá a mensagem e quando esta chegar, o receive executará novamente. Se a mensagem se tratar de uma impressão, por exemplo, o arquivo será colocado na fila duas vezes e será impresso repetidamente. Alternativa para a situação 2 Se o receive soubesse se uma mensagem é uma retransmissão, poderia solucionar o problema. Para isso, basta acrescentar um campo de identificação em cada mensagem. Assim, ao receber uma nova mensagem, o receive compara o campo de identificação com o das outras mensagens e a descarta se concluir que é uma retransmissão. A troca de mensagens é uma solução, mas possui outros problemas presentes em qualquer comunicação distribuída, como, por exemplo, garantir a autenticidade do transmissor e receptor no envio das mensagens, além de se tornar um processo mais lento do que as operações com semáforos e os monitores. APRENDA A APRENDER: Terminado o estudo desta unidade é importante que você reflita sobre os conteúdos estudados, bem como sobre as técnicas e estratégias propostas para sua aprendizagem. Identifique o que foi útil e, portanto, pode ser incorporado e o que pode ser dispensado. Em caso de eventuais dúvidas, retome o estudo do conteúdo, realize pesquisas e interaja na Sala de Aula Virtual com seus colegas de curso e com seu professor. Você é o protagonista de sua aprendizagem. Participe! Sistemas Operacionais CRC Batatais Claretiano 31