Fundamentos de Sistemas Operacionais
Aula 12: Revisão para a P1
Diego Passos
Capítulo 1
Sistemas Operacionais
São programas.
Duas funções:
Gerenciar os recursos do hardware.
Dividir entre os vários processos.
Simplificar o acesso aos dispositivos pelos processos dos usuários.
Todo SO tem um kernel.
Funções e serviços mais básicos.
Dois tipos:
Micro-kernel: apenas as funções essenciais.
Kernel monolítico: todos os serviços.
Tipos de SO
Sistemas batch:
Tarefas são executadas sequencialmente.
Jobs.
Podem ser multiprogramados ou com monitor residente.
Monitor carrega novos programas quando os anteriores terminam.
Batch multiprogramados evitam desperdício de CPU por conta de E/S.
Sistemas baseados em timesharing.
Processos recebem pequenos intervalos de uso do processador.
Simula paralelismo.
Indicado para sistemas interativos.
Tipos de Sistema
Paralelo vs. Distribuído.
Sistemas paralelos têm vários processadores.
Memória compartilhada entre eles.
Sistemas distribuídos também.
Mas não há memória compartilhada.
Processadores são conectados por uma rede.
Multitarefa vs. Monotarefa.
Monousuário vs. Multiusuário.
Capítulo 2
Processo
Instância de um programa em execução.
Composto por:
Código (sequência de instruções).
Estado (variáveis, registradores, ...).
Diferente de um programa.
O programa é apenas o código a ser executado.
O processo muda a cada instante.
Um processo passa por três etapas:
Criação.
Execução.
Término.
Processo (mais)
Durante a execução, processo pode:
Executar ciclos de processamento.
Executar ciclos de E/S.
Processos podem ser classificados em:
CPU Bound: percentual de processamento é maior que o percentual de E/S.
I/O Bound: percentual de processamento é menor que o percentual de E/S.
e.g.: processos que passam até 30% do tempo realizando E/S são CPU Bound.
Mais que isso, se tornam I/O Bound.
Classificação não é absoluta:
Pessoas diferentes têm percepções diferentes.
Espaço de Endereçamento
Área de memória na qual o processo armazena suas informações.
Variáveis, código.
O espaço de endereçamento do processo não pode ser manipulado por outros processos.
Processos acessam apenas posições de memória no seu espaço de endereçamento.
Relacionamento Entre Processos
Dois processos podem ser completamente independentes.
Não há qualquer ligação entre eles.
Processos podem ser relacionados porque compartilham recursos.
e.g.: ambos acessam o mesmo arquivo.
Processos podem ainda apresentar um grau de parentesco.
Um processo pode ser pai de outros processos.
Um processo pode ser filho de outro processo.
Isso forma uma hierarquia.
O que fazer com a hierarquia quando um processo morre?
Várias possibilidades:
Deixar os filhos órfãos, postergar morte do processo, ...
Estados de um Processo
Todo processo no sistema tem um estado único.
Descreve as capacidades e características do processo naquele momento.
Estados comuns são:
Apto: processo está pronto para utilizar o processador.
Bloqueado: processo está aguardando fim de E/S.
Suspenso: processo teve seu espaço de
endereçamento retirado da memória principal.
Suspenso apto ou suspenso bloqueado.
Executando: processo está atualmento usando o processador.
Outros estados: criação, término, etc.
Estados de um Processo (mais)
SO define quais as transições possíveis entre estados.
Apto -> Executando.
Bloqueado -> Apto.
...
Algumas transições são intrinsecamente impossíveis.
Suspenso Apto -> Executando.
Apto -> Bloqueado.
...
Mudanças de estado ocorrem por:
Interferência do SO (Apto -> Executando).
Requisições do próprio processo (Executando ->
Bloqueado).
Eventos externos (Bloqueado -> Apto).
Problemas de Segurança Inter- Processos
Monopolização do processador.
Como forçar que um processo deixe o processador eventualmente (involuntariamente)?
Acessos a posições de memória indevidas.
Como evitar que um processo acesse o espaço de endereçamento de outros processos?
Como evitar que um processo acesso o espaço de endereçamento do SO?
Monopolização de dispositivos de E/S.
Como evitar que um processo não permita que outros processos usem um dado recurso?
Soluções de Segurança
Utiliza mecanismos de hardware.
Modos de operação do processador.
Circuitos de verificação de endereços de memória.
Interrupções.
Temporizadores.
Classicamente, há dois modos de operação:
Modo Supervisor.
Modo inicial da máquina.
Modo de execução do SO.
Todas as operações são permitidas.
Modo Usuário.
Modo de execução dos processos de aplicação.
Acesso restrito à memória.
Acesso restrito a instruções.
Soluções de Segurança (mais)
Em modo usuário, todo acesso de memória é verificado.
e.g.: registradores base e limite.
Se uma posição inválida é requisitada, interrupção é gerada.
Em modo usuário, algumas instruções são proibidas.
CLI, STI, IN, OUT, ...
Se processo tenta executá-las, interrupção é gerada.
Quando um processo é colocado no processador, SO pode configurar um temporizador.
Interrupção é disparada ao final do tempo.
SO cadastra tratadores de interrupção durante o ligamento da máquina.
Quando o tratador de interrupção é chamado, SO identifica a situação e toma uma providência.
Em geral, mata o processo.
Capítulo 3
Programação Concorrente
Programas que usam vários processos ou threads para executar tarefas são chamados de concorrentes.
Ou paralelos.
Se opõem aos programas sequenciais.
Vantagens da programação concorrente:
Permite a separação lógica de várias funcionalidades do programa em várias linhas de execução.
Alguns programas são intrinsecamente paralelos.
Pode melhorar o desepenho do programa.
Tirar proveito de vários processadores.
Apresentar sobreposição de operações de E/S.
Programação Concorrente (mais)
Desvantagens:
Gerenciamento das threads ou processos é complexo.
Erros são não-intuitivos.
Paradigma não é natural.
É comum que o programador faça suposições inválidas.
e.g.: processo A executa antes do processo B.
Ordem e velocidade de execução são imprevisíveis.
Depuração é mais difícil.
Programa paralelo pode ser especificado de 3 maneiras:
Explicitamente.
Implicitamente.
Através de uma árvore de dependência.
Tipos de Paralelismo
Paralelismo real.
Só ocorre em máquinas multiprocessadas.
Threads ou processos podem ser executados realmente ao mesmo tempo.
Paralelismo aparente.
Ocorre em máquinas monoprocessadas.
Usuário apenas tem a impressão de que processos são executados ao mesmo tempo.
Execução concomitante.
Compartilhamento de Recursos
Programas concorrentes tendem a manipular recursos compartilhados.
e.g.: várias threads compartilham uma estrutura de dados ou um arquivo.
Recurso compartilhado mais comum: memória.
Diversos tipos de sistema compartilham memória.
Produtor-consumidor.
Leitor-escritor.
Região Crítica
Uma região (ou seção) crítica é um trecho de código dentro de um programa concorrente.
Trecho no qual um recurso compartilhado é manipulado.
Programa pode ter várias regiões críticas.
Regiões podem estar relacionadas a recursos compartilhados diferentes.
Recursos compartilhados podem ser manipulados em mais de um ponto no código.
Importantes pois a manipulação dos recursos
compartilhados deve ser feita de maneira cuidadosa.
Do contrário, pode resultar em problemas graves.
Condição de Corrida
Problema que pode ocorrer em programas concorrentes.
Causado pelo acesso não controlado de recursos compartilhados por várias threads ou processos.
Acesso às regiões críticas do programa.
Dependendo da ordem de execução, o programa pode ter resultados diferentes dos esperados.
Solução:
Proteção/controle do acesso às regiões críticas.
Operação atômica.
Exclusão mútua.
Operação Atômica
Operação indivisível no tempo.
Uma vez iniciada, não pode ser interrompida.
Em geral, implementada como instruções únicas de máquina.
Pode ser implementada também através da desabilitação de interrupções.
Não é uma boa política:
Questões de segurança.
Falta de suporte do SO.
Se todo o código da região crítica é implementado atomicamente, não há condição de corrida.
Não há concorrência na manipulação dos recursos compartilhados.
Exclusão Mútua
Propriedada que determina que dois processos não acessarão a região crítica simultaneamente.
Processo na região crítica pode ser interrompido.
Pode, inclusive, ser tirado do processador.
Outro processo que compartilha o recurso pode ser executado no seu lugar.
Mas outro processo não pode executar a mesma região crítica, neste intervalo.
Requisitos desejáveis:
Processos não devem ser preteridos de entrar na região crítica, se não há outros processos acessando-a.
Processos não devem ser preteridos indefinidamente.
Starvation.
Protocolos de Acesso
Soluções totalmente baseadas em software.
Não necessitam de qualquer suporte do hardware.
Vários protocolos diferentes: alternância, algoritmo de Peterson, ...
Algoritmo de alternância.
Mais simples.
Variável indica de quem é a vez.
Apenas este processo pode acessar a região.
Ao final da região, processo passa a vez para o próximo.
Processo pode ser obrigado a esperar.
Processos fazem espera ocupada na variável da vez.
Spin-Locks
Solução baseada em uma variável que diz se a região crítica está aberta ou fechada.
Um lock.
O lock fica inicialmente aberto.
Quando um processo entra na região, ele fecha o lock.
Demais processos fazem espera ocupada na variável.
Processos podem sofrer starvation.
Problema:
A variável lock é compartilhada.
Pode sofrer condições de corrida.
Solução:
Suporte do hardware.
Instruções TSL, SWP, ...
Manipulam a variável lock atomicamente.
Semáforos
Solução mais utilizada hoje.
Estrutura de dados com dois componentes:
Valor inteiro.
Fila de processos.
Duas operações básicas:
P(s): decrementa o semáforo s e, se o valor é menor que zero, bloqueia o processo.
V(s): incrementa e, se há processos bloqueados, desbloqueia o primeiro.
Não há espera ocupada.
Processos ficam bloqueados.
Não há starvation.
Desbloqueio ocorre na ordem da fila.
Semáforos (mais)
Há dois tipos:
Mutex: valor inteiro só assume os valores 0 e 1.
Suficiente para exclusão mútua.
Contador: valor inteiro pode assumir qualquer valor.
Suficiente para exclusão mútua.
Mais utilidades também.
Alguns sistemas provêem apenas o mutex.
Um semáforo também é um recurso compartilhado.
Sua manipulação está susceptível a condições de corrida.
Implementação:
Usa quaisquer outros métodos para evitar condição de corrida.
Problemas das outras abordagens são mitigados.
Monitores
Solução de exclusão mútua específica de algumas linguagens.
Bloco de funções que contêm regiões críticas.
Garante que apenas um processo ou thread esteja dentro do monitor por vez.
Demais processos ou threads que tentam o acesso são bloqueados.
Vantagem:
Tendem a ser mais simples para o programador.
Desvantagem:
Reduzem o paralelismo.
Monitores (mais)
Podem usar variáveis de condição.
Representam se uma determinada condição é verdadeira ou falsa.
Duas operações:
Wait: aguarda que uma determinada condição se torne verdadeira.
Signal: sinaliza que a condição agora se tornou verdadeira.
Troca de Mensagens
Mecanismo de comunicação e sincronização em sistemas distribuídos.
Não há memória compartilhada.
Outras soluções não são possíveis.
Duas operações básicas:
send: envia uma mensagem.
receive: recebe uma mensagem.
Esquemas de endereçamento variáveis:
Endereço IP e porta.
Caixa postal.
...
Deadlock
Diz-se que N processos estão em deadlock quando cada um deles está no estado bloqueado à espera de um evento que só pode ser causado por um dos outros N processos.
Causados por disputas de recursos compartilhados.
Existem 4 condições necessárias para ocorrência:
Posse e espera.
Processo tenta adquirir um recurso de posse de outros.
Não-preempção.
Recurso não pode ser tirado do processo, uma vez que tenha sido cedido.
Espera circular: há um ciclo no grafo de espera por recursos.
Exclusão mútua: recurso não pode ser usado por mais de um processo ao mesmo tempo.
Deadlock (mais)
Possíveis soluções:
Evitá-los.
Avaliar cada pedido de recurso, verificando se
atendê-los coloca o sistema em possível deadlock.
Detectar e corrigir.
Periodicamente, verificar se o sistema se encontra em deadlock.
Se sim, escolher um processo para matar.
Não fazer nada.
Esperar que o usuário tome uma atitude.
Em geral, as duas primeiras soluções são muito "caras".
SOs preferem não fazer nada.
Capítulo 4
Organização de Memória de um Processo
Algumas regiões específicas:
Texto: código do programa.
Dados: variáveis globais inicializadas.
BSS: variáveis globais não inicializadas.
Heap: memória alocada dinamicamente.
Pilha: informações sobre funções sendo executadas Áreas de memória podem ter permissões diferentes.
Permissão de leitura.
Permissão de execução.
Permissão de escrita.
Contexto do Processo
Informações que determinam o estado atual de execução do processo.
Similar ao estado do processo.
Diferença: contexto contém apenas informações relativas ao estado do processador.
Informações do contexto do processo:
Valores dos registradores.
Importante no contexto de multiprogramação:
Vários processos compartilhando o processador.
Quando um processo sai, seu contexto precisa ser salvo.
Quando ele volta, seu contexto precisa ser restaurado.
Bloco Descritor do Processo
Estrutura de dados do kernel.
Guarda informações necessárias para o gerenciamento dos processos.
Prioridade.
Lista de recursos.
Estado.
Contexto.
Contabilidade.
Parentesco.
...
SO organiza blocos descritores em uma tabela ou lista.
Threads
Linhas de execução dentro de um processo.
Todo processo tem, ao menos, uma thread.
Determinam qual a sequência de instruções a executar.
Têm estado, mas menor que os processos.
Apenas um sub-conjunto dos registradores.
Sub-conjunto do estado de um processo.
São chamadas às vezes de "Processos Leves".
Chaveamento entre threads do mesmo processo é mais rápido que entre processos diferentes.
Criação e término também são mais rápidos.
Threads (mais)
Dois tipos de implementação:
Em nível do usuário.
SO não conhece threads.
Implementadas pela própria aplicação (ou biblioteca).
Operações são mais rápidas (sem troca de contexto para o SO).
Modelo N:1.
Em nível do Sistema.
SO conhece as threads.
Operações são feitas pelo kernel.
Operações são mais lentas (mudança de contexto para o SO).
Escalonamento tende a ser mais eficiente (threads são escalonadas, não processos).
Modelo 1:1.
Escalonador
Mecanismo responsável pelo gerenciamento do acesso de vários processos a um dado recurso do sistema.
Exemplo: processador, impressora, etc.
Em geral, quando se fala de escalonador, refere-se ao escalonador do processador.
Três tipos de escalonador:
Longo prazo: controle de admissão.
Médio prazo: suspensão de processos.
Curto prazo: decisão de quem usa o processador em dado momento.
Escalonadores podem ainda ser classificados como:
Não-preemptivos: processos só deixam o processador voluntariamente.
Preemptivos: SO pode tirar um processo do processador.
Escalonador (mais)
Podem ter vários objetivos:
Tempo médio de resposta.
Vazão.
Eficiência.
Prazos.
Justiça.
...
Podem levar em consideração também prioridades diferentes para processos diferentes.
Escalonadores Não-Preemptivos
FIFO:
Mantém processos em uma fila de chegada.
Sempre escolhe o primeiro processo da fila.
Não resulta em starvation, normalmente.
Bastante simples.
SJF:
Mantém uma lista de processos aptos.
Sempre escolhe o processo mais curto.
Precisa da informação de duração de um processo.
Pode ser estimada (com uma média, por exemplo).
Pode trabalhar com os tempos dos ciclos de processamento, apenas.
Pode resultar em starvation.
Escalonadores Preemptivos
Round-robin:
Processos são ordenados pela chegada em uma fila.
Sempre, o primeiro processo da fila é escolhido.
Processo selecionado executa por, no máximo, uma fatia de tempo.
Ao final, volta à fila.
Nunca resulta em starvation.
Baseado em Prioridades:
Cada processo recebe uma prioridade.
Processos mais prioritários sempre ganham o processador.
Pode resultar em starvation.
Escalonadores Preemptivos (mais)
Políticas podem ser combinadas.
Escalonamento com múltiplas filas.
Cada fila tem uma política diferente.
Há um escalonador principal que escolhe uma das filas.
Indicados para sistemas interativos.
Principalmente o round-robin.
Escolha da fatia de tempo influencia no desenpenho do round-robin.
Idealmente, menor fatia possível.
Mas deve ser grande o suficiente para causar pouco overhead.
Escalonamento de Tempo Real
Objetivo:
Atender a todos os prazos.
Supõe-se que todos os processos sejam periódicos.
Também têm prazos e tempos máximos de execução conhecidos previamente.
Dois algoritmos clássicos (preemptivos):
Taxa Monotônica.
Prioridades estáticas são atribuídas a cada processo.
Inversamente proprocional ao período do processo.
EDF.
A cada instante de decisão, escolhe o processo cujo prazo atualmente é mais apertado.
Escalonamento de Tempo Real (mais)
Cada algoritmo tem um teste de escalonabilidade.
Diz se um conjunto de tarefas podem ou não ser escalonadas.
Escalonador de longo prazo precisa realizar o teste para determinar aceitar (ou não) uma nova tarefa.
EDF é capaz de escalonar qualquer conjunto com menos de 100% de utilização.
Taxa monotônica nem sempre consegue.
Um teste definitivo é o desenho do diagrama:
Do instante crítico ao fim do primeiro período mais longo.
