Sistemas operacionais

1. Sistemas operacionais Carlos Oberdan Rolim Ciência da Computação Sistemas de Informação

2. Processos * Baseado no material do Prof. Luis Cláudio Gubert

3. Processos • Conceito de Processo • Escalonamento de Processos • Operações com Processos • Processos Cooperativos • Comunicação entre Processos

4. Conceito de processo • Um sistema operacional executa uma variedade de programas: • Sistema Batch – jobs • Sistema Tempo Compartilhado (Time-shared) – programas do usuário ou tarefas • Livros usam os termos job e processo quase que indeterminadamente. • Processo – um programa em execução; execução do processo deve progredir de maneira seqüencial. • Um processo inclui: • Contador de programa • pilha • Seções de dados

5. Criação de processos • Sistemas operacionais precisam assegurar a criação de todos os processos necessários • Há quatro eventos que fazem com que processos sejam criados • Inicio do sistema • Execução de uma chamada ao sistema de criação de processo por um processo em execução • Uma requisição do usuário para criar um novo processo • Inicio de um job em lote • Inicialização de processos em segundo plano pelo SO • Daemons • Tecnicamente um processo é criado quando um outro processo faz uma chamada ao sistema de criação de processos • Fork  clone identico ao processo que o chamou

6. Término de processos • Após efetuar sua tarefa processo termina por alguma das seguintes razões: • Saída normal (voluntária) • Saída por erro (voluntária) • Erro fatal (involuntário) • Cancelamento por um outro processo (involuntário)  Ex.comando kill

7. Hierarquia de processos • Relação pai x filho de processos • No Unix um processo pai, todos os seus filhos e descendentes formam um grupo de processos • Quando um sinal é enviado todos os processos do grupo de processos recebem o sinal e decidem o que fazer • Exemplo de inicialização do sistema • Processo init que cria os teminais de video, que disparam os interpretadores de comando, que disparam novos processos e assim por diante • Init é o processo raiz • Windows não apresenta hierarquia de processos • Todos são iguais • Somente existe uma especie de hierarquia quando um processo cria outro • Pai recebe handle dos filhos para os controla-los.Porém pode passar esse handle para outros processo invalidando conceito de hierarquia

8. Estados de processo • Durante a execução de um processo, ele altera seu estado • Novo (new): O processo está sendo criado. • Executando (running): instruções estão sendo executadas. • Esperando (waiting): O processo está esperando algum evento acontecer. • Pronto (ready): O processo está esperando ser associado a um procesador. • Terminado (terminated): O processo terminou sua execução.

9. Diagrama de estados de processos

10. Process Control Block (PCB) Informações associadas com cada processo. • Estado do Processo • Contador de Programas • Registradores da CPU • Informações de escalonamento da CPU • Informação de Gerenciamento de memória • Informação para Contabilidade • Informações do status de E/S

11. Processo Control Block

12. Troca de CPU entre processos

13. Filas de escalonamento de processos • Fila de Job – conjunto de todos os processos no sistema. • Fila de Processos prontos (Ready queue) – conjunto de todos os processos residentes na memória principal, prontos e esperando para executar. • Fila de dispositivos – conjunto dos processos esperando por um dispositivo de E/S. • Migração de processos entre as várias filas.

14. Fila de processos pronto e várias filas de E/S

15. Representação de Escalonamento de Processos

16. Escalonadores • Escalonador de Jobs (Long-term scheduler) – seleciona quais processos devem ser trazidos para a fila de processos prontos. • Escalonador da CPU (Short-term scheduler) – seleciona qual processo deve ser executados a seguir e aloca CPU para ele.

17. Inclusão de escalonador de nível médio

18. Escalonadores (cont) Escalonador da CPU é invocado muito freqüentemente (milisegundos) → (deve ser um fato). • Escalonador de Jobs é invocada muito infreqüentemente (segundos, minutos) → (pode ser lento). • O escalonador de Jobs controla o grau de multiprogramação. • Processos podem ser descritos como: • Processos com E/S predominante (I/O-bound process) – gasta mais tempo realizando E/S do que computando, muitos ciclos curtos de CPU. • Processos com uso de CPU predominante (CPU-bound process) – gasta mais tempo realizando computações; poucos ciclos longos de CPU.

19. Troca de contexto • Quando CPU alterna para outro processo, o sistema deve salvar o estado do processo deixando o processador e carregar o estado anteriormente salvo do processo novo. • Tempo de troca de contexto é sobrecarga no sistema; o sistema não realiza trabalho útil durante a troca de contexto. • Tempo de Troca de Contexto é dependente de suporte em hardware.

20. Criação de processos • Processo pai cria processo filho, o qual, por sua vez, pode criar outros processos, formando uma árvore de processos. • Compartilhamento de Recursos • Pai e filho compartilham todos os recursos. • Filho compartilha um subconjunto dos recursos do pai. • Pai e filho não compartilham recursos. • Execução • Pai e filho executam concorrentemente. • Pai espera até filho terminar.

21. Criação de processos (cont) • Espaço de endereçamento • Filho duplica espaço do pai. • Filho tem um programa carregado no seu espaço. • Exemplos no UNIX • Chamada de sistemas fork cria um novo processo • Chamada de sistemas execve é usada após o fork para sobrescrever o espaço de memória do processo com um novo programa.

22. Uma Árvore de Processos em um Sistema UNIX Típico

23. Terminação de processos • Processo executa última declaração e pede ao sistema operacional para decidir (exit). • Dados de saída passam do filho para o pai (via wait). • Recursos do processo são desalocados pelo sistema operacional. • Pai pode terminar a execução do processo filho (abort). • Filho se excedeu alocando recursos. • Tarefa delegada ao filho não é mais necessária. • Pai está terminando.

24. Comunicação entre Processos • Processos Independentes. • Não afetam nem são afetados por outros processos. • Processos Cooperados. • Compartilham: • Memória; • Arquivos; • Dispositivos de E/S; • Etc. • Vantagens da cooperação entre processos: • Compartilhamento de Informações • Aumento na velocidade da computação • Modularidade • Conveniência

25. Processos Cooperados • Compartilhamento de dados. • Processo “produtor” de dados. • Insere informações no buffer • Processo “consumidor” de dados, • Remove informações do buffer • Buffer: • Limitado: Produtor e Consumidor. • Ilimitado: Somente Consumidor. • Implementação. • Via memória compartilhada; • Via IPC (Interprocess Comunication - SO)

26. Buffer Circular • Implementação como um array circular. • Introdução de um contador de quantidade. • Produtor e Consumidor manipulam o contador. próximasaída próximaentrada 4 8 5 Contador 5 7 6

27. Implementação • i aponta para posição anterior ao primeiro elemento • f aponta para último elemento • c indica o número máximo de elementos presentes • N indica o número máximo de elementos

28. Buffer vazio • i == f • c == 0

29. Buffer cheio • i == f • c ==N

30. Comportamento básico int buffer[N]; int c = 0; int i = 0, f = 0; Produtor Consumidor while (true) while ( true) f = (f + 1) % N; i = ( i + 1 ) % N; buffer[f] = produz(); consome( buffer[i]); c++; c--;

31. Problemas • Produtor insere em posição que ainda não foi consumida • Consumidor remove de posição já consumida

32. Condições de Corrida (Race Conditions) • Processos trocam dados, as vezes, através de memória • Principal, arquivo... • Região/seção crítica • Porção de programa que pode levar a condição de disputa • Tipo de memória não altera o problema • Alguma forma de garantir que apenas 1 esteja na região crítica

33. Condições de Corrida • Mecanismo de Sincronização. • Garante o compartilhamento de recursos e a comunicação entre os processos. • Garante a integridade e a confiabilidade dos dados compartilhados. • Condições de Corrida: • Situações onde dois ou mais processos estão acessando dados compartilhados. • O resultado final pode variar de acordo com a ordem de execução.

34. Condições de Corrida • Exemplo 1: • Resultado Final: Contador = 6 (ERRO!) 2 1 7 7 ProcessoA7+1 ProcessoB7-1 7 4 3 6 5 6 8

35. Condições de Corrida ProcessoA • Exemplo 2: • Valor armazenado peloprocesso B é perdido. suspenso 2 recebe CPU 8 10 Y 1 9 7 8 6 5 próximaentrada 7 4 3 6 X 4 5 7 8 ProcessoB recebe CPU 3 suspenso 7

36. Condições de Corrida • Região Crítica: • Parte do código onde é feito acesso a recursos compartilhados, e que podem levar a condições de corrida. • Ex: Processo A. • Código normal • Início da Seção Crítica (Protocolo de Entrada) • Seção Crítica • Término da Seção Crítica (Protocolo de Saída) • Código normal

37. Concorrência em programas • Enquanto um processo estiver usando um recurso, os outros devem aguardar até que o recurso esteja liberado. • Exclusão Mútua. • Exclusividade no acesso a um determinado recurso. • A exclusão mútua deve afetar os processos concorrentes quando um deles estiver em uma região crítica.

38. Regiões críticas • Como evitar condições de disputa? • Implementar exclusão mútua • Um por vez junto à região • Garantir que dois ou mais processos estarão sincronizados, e só um dentro da região crítica • Operando sobre dados compartilhados

39. Regiões críticas • Quatro requisitos básicos para os algoritmos • Dois ou mais processos NUNCA podem estar simultaneamente na região crítica • Não considerar velocidade relativas dos processos • Quem estiver fora da região não pode bloquear quem quer entrar • Tem que entrar em algum momento!

40. Regiões críticas

41. Algumas alternativas • Espera ocupada • Inibição de interrupção, variáveis de bloqueio, estrita alternância, TSL • Bloqueio/desbloqueio • Sleep/wakeup • Semáforos • Monitores • Troca de mensagens • “caixa postal”, rendezvous

42. Problemas de Sincronização • Velocidades muito diferentes dos processos: • Podem causar problema de solução de sincronização entre processos. • Ex: Problema produtor / consumidor. • Starvation (Indefinitely Postponed): • Um processo nunca consegue executar sua região crítica e acessar o recurso compartilhado. • Outros processos são sempre prioritários. • Também chamado de problema de inversão de prioridade

43. Soluções de Hardware • Inibição das interrupções: • Solução mais simples para a exclusão mútua; • Falha de Proteção: • O processo precisa voltar a habilitar as interrupções. • Instrução Test-and-Set. • Utilização de uma variável para testar a possibilidade de executar a região crítica. • O processo impedido de executar sua região crítica executa um loop de espera. • Gasto de CPU.

44. Inibição de interrupção • Processo desativa interrupções quando entra na região crítica • Evita a interrupção • Ninguém, além dele, estará processando • Problemas • Usuário é não confiável • Sistemas multiprocessados • Kernel pode precisar interromper (e.g., atualizar lista de prontos)

45. Test and Set Locked (TSL) • Precisa de apoio do hardware • Operação para mover e ajustar de forma atômica um registrador de flag • Só entra se registrador igual a 0 entrar_regiao: TSL register, flag // copiar flag em register e faz flag = 1 CMP register, #0 // register ? 0 : 0, 1 JNZ entrar_regiao // volta para novo TSL RET // retorna ao processo sair_regiao: MOV flag, #0 // coloca 0 em flag RET // retorna ao processo Processo X { código... entrar_regiao() R.C. sair_regiao() código... }

46. Soluções de Software • Estrita alternância • Bloqueio/desbloqueio • Sleep/wakeup • Semáforos • Monitores • Troca de mensagens • “caixa postal”, rendezvous • Em geral, as soluções por software resolvem a exclusão mútua, mas geram a espera ocupada(Busy Wait): • Teste contínuo de uma variável até que ocorra uma mudança no seu valor; • O processo impedido de executar sua região crítica executa um loop de espera. • Gasto de CPU.

47. Estrita alternância • Cabana com uma lousa dentro • Só um na cabana, só um número na lousa • Quem quiser entrar na região, verifica a lousa • Entra na cabana. Se a lousa não tiver o seu número, sai e dá uma volta • Se estiver, entra na região e, ao sair, escreve o próximo número

48. Estrita alternância • Outra opção: várias cabanas, com várias lousas • Cada um examina todas as lousas mas altera apenas a sua • TRUE na lousa  processo na região • Quem quiser entrar verifica as outras lousas • Se todas falsas, escreve TRUE na sua e entra • Escreve FALSE ao sair • Vários processos • Verificação não é atomica

49. Sleep/Wakeup • TSL funciona, mas é espera ocupada... • Problema de prioridade invertida • L com prioridade baixa na região critica, e H com alta prioridade tentando entrar • Em vez de esperar, um processo comunica diretamente ao outro • SLEEP e WAKEUP • Produtor/consumidor com buffer limitado • Buffer cheio? Produtor dorme • Buffer vazio? Consumidor dorme... Starvation

50. Sleep/Wakeup Extern N, count; void consumer (void) { int item; while (TRUE) { if (count == 0) sleep(); remove(item); count--; if (count == N-1) wakeup (producer); consome(item); } } #define N 100 int count = 0; void producer(void) { int item; while (TRUE) { produz(&item); if (count == N) sleep(); armazena(item); count++; if (count == 1) wakeup(consumer); } }