Sistema Operacional

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Sistema Operacional
Aula 1
Conceitos
Sistema Operacional – É um conjunto de programas (software) responsável por:
Fazer a interface com os usuários;
Gerenciar recursos;
Fazer a interface com o hardware.
Funções adicionais – Contabilização de uso, segurança de acesso, auditoria.
Cada parte (módulo ou função) de um sistema operacional é responsável pelo gerenciamento de um recurso específico. Que recursos são esses?
Tempo de CPU
Espaço em memória
Espaço em disco
Acesso aos dispositivos de comunicação
Bibliotecas de software
Gerenciar recursos e garantir a utilização compartilhada do recurso sem que ocorram erros que possa gerar instabilidade ou falha no sistema. Na visão do usuário, o sistema operacional fornece:
Acesso ao sistema
Possibilidade de criar e gerar arquivos e diretórios
Ambiente para execução de programas
Acesso aos dispositivos de E/S
Acesso ao conteúdo de arquivos
Detecção de erros
Classificação de Sistemas Operacionais
Sistemas Monotarefa x Sistemas Multitarefa
Sistemas Monousuários x Sistemas Multiusuário
Sistemas Monoprocessados x Sistemas Multiprocessados
Estruturas dos Sistemas Operacionais Modernos
As aplicações são executadas em modo usuário, ou seja, modo que não possui privilégios para operações que coloquem o sistema em risco, tais como escrever no disco, criar novas tarefas e etc.
Quando essas aplicações precisam executar tarefas críticas, é necessário que haja uma mudança para modo KERNEL. Essa mudança ocorre através de uma “system call” ou chamada ao sistema.
System Call – Mecanismo responsável pela mudança de modo usuário para modo kernel. Ao invés de executar diretamente funções do kernel a aplicação executa uma função intermediária que verifica se o acesso ao kernel é seguro e, só então, completa a operação.
Tipos de Estrutura
Os sistemas são classificados em relação às atribuições do KERNEL e a relação entre seus módulos em monolíticos, camadas e microkernel.
Os sistemas modernos são divididos em dois grandes grupos: arquitetura monolítica e microkernel. A diferença entre elas está nas atribuições do núcleo do sistema operacional, denominado KERNEL.
Interrupções
São sinais de hardware fundamentais para a existência de sistemas multitarefa, pois provocam a suspensão da tarefa em execução pela ocorrência de um evento externo permitindo que outras tarefas compartilhem o tempo de uso do processador.
Parte do mecanismo é executada pelo hardware (identificação do dispositivo, empilhamento dos registradores de sistema) e parte é feita por software através de rotina de tratamento de interrupção (interrupt handler).
Hardware
Dispositivos de controle ou outro sistema de hardware que permita ativar uma interrupção;
Processador termina a execução da instrução corrente;
Processador reconhece sinal de interrupção;
Processador coloca PSW e PC na pilha de controle;
Processador carrega novo valor do PC, baseado na interrupção...
Software
Salva informações remanescentes sobre o estado do processo;
Processa a interrupção;
Restaura a informação do estado do processo;
Restaura o velho PSW PC.
Concorrência
É a capacidade de execução concorrente de tarefas permitindo um melhor aproveitamento de recursos. Uma tarefa pode deixar a CPU por vontade própria, quando precisa aguardar por um recurso, ou por uma interrupção. Em particular, uma interrupção de temporizador provoca a substituição da tarefa em execução, criando uma alternância entre as tarefas.
Aula 2
Processos
É a instância de um programa em execução. É a unidade de carga e alocação de uma tarefa. Em sistemas mais antigos, também é considerado a unidade de execução.
Cada processo é único em um sistema;
O processo é criado quando o programa é carregado para a memória principal para ser executado;
Um programa é carregado para a memória onde aloca uma determinada área para código e dados.
Componentes
Um processo é dividido em partes que são armazenadas na memória em uma estrutura denominada PCB (process control block).
	Identificação
	Programa
	Registrador SP
	Registrador PC
	Registrador de uso geral
	Informações de escalonamento
	Relação de arquivos abertos
	Privilégios
	Espaço de endereçamento de memória
Estados
No que diz respeito aos estados de um processo, o diagrama mais comum possui cinco estados e é suficiente para o entendimento dos demais estados intermediários.
Novo
Pronto
Executando
Fim
Bloqueado
Novo – Estado de admissão onde são geradas as estruturas de dados e alocado espaço para o processo. O processo é recém-criado é configurado como “pronto”.
Pronto – Após a admissão, o processo está pronto para ser executado, mas aguarda a sua vez.
Executando – Apenas um processo por vez pode estar nesse estado. Após ser selecionado, o processo recupera seu contexto que é guardado após ter sua execução interrompida.
Fim – Ao terminar a execução do processo, as estruturas criadas são removidas e a área alocada é liberada.
Bloqueado – Um processo é bloqueado quando precisa aguardar um recurso. Esse bloqueio é síncrono, ou seja, sempre que o programa executar um determinado trecho, o bloqueio acontecerá (Ex. acesso ao disco).
A substituição do processo em execução é denominada troca de contexto. Quando o processo é interrompido seu contexto é armazenado. Quando o processo retorna para o estado de execução. Seu contexto é recuperado. O sistema operacional NÃO pode provar troca de contexto, uma vez que é um software e para gerar uma ação precisaria estar em execução.
Tipos
Processos CPU-Bound – São processos que passam a maior parte do tempo em estado de execução ou pronto. Realiza poucas operações E/S.
Processos I/O-Bound – São processos que passam a maior parte do tempo em estado de espera, pois realizam um elevado número de operações de E/S.
Processos de Foreground – Permitem a execução direta do processo com o usuário durante sua execução. Em geral, o canal de entrada está associado ao teclado/mouse e de saída a um monitor.
Processos em Background – Processos em que não existe interação direta com o usuário.
Aula 3
Threads
São fluxos de execução distintos dentro de um mesmo processo, um executável. Atualmente, uma thread é considerada a unidade de execução de um sistema ao invés de um processo como um todo.
Estrutura
Um processo que contenha threads é composto pelo seu PCB (Process Control Block) e pelos blocos específicos para cada thread que contém uma estrutura de contexto de software e uma estrutura de contexto de hardware. 
Cada thread possui contextos próprios de hardware e software, porém compartilham o mesmo espaço de endereçamento alocado ao processo.
Tipos de Threads
Threads de Kernel – As threads de Kernel são criadas e gerenciadas pelo Kernel do Sistema Operacional, mas não podem ser diretamente utilizadas pelo usuário. O suporte a múltiplas threads é uma característica do sistema operacional.
Threads de Usuário – As threads de usuário facilitam aspectos de portabilidade e são criadas e gerenciadas por uma biblioteca no nível usuário. O Kernel não enxerga essas threads e, por esse motivo, não podem ser gerenciadas individualmente. Ex. Bibliotecas de threads: POSIX, Pthreads, Win32 threads, Java threads.
Processo Leve ou LWP
A combinação entre os dois tipos de threads promove uma associação entre threads de usuário e de Kernel, porém a forma de associação depende do sistema operacional.
Esta é a solução mais utilizada nos sistemas operacionais modernos. O uso combinado de threads de usuário e de Kernel permite melhor aproveitamento do tempo de CPU, possibilidade de paralelismo e facilidade de programação.
Modelos de associação entre threads de usuário e de Kernel
Muitos para um:
Gerenciamento da thread é feito no espaço do usuário;
Usadas em sistemas que não suportam threads;
Uma thread bloqueada bloqueia todo o processo.
Um para um:
Cada thread de usuário é mapeada para uma Kernel thread;
Criar uma user thread requer a criação de uma thread de Kernel;
Algumas
implementações restringem o número de threads suportada pelo sistema;
É utilizada pelo Windows e pelo Linux.
Muito para muitos:
Permite que várias threads de usuário sejam mapeadas para um número menor ou maior de threads de Kernel dinamicamente;
Permite que o sistema operacional crie um número suficiente de threads de Kernel.
Aula 4
Comunicação entre processos
Condição de corrida – Conjunto de eventos que geram resultados não determinísticos e deve ser evitada. O termo “condição de corrida” vem do fato da não previsibilidade do resultado de uma corrida onde a velocidade de execução de um processo não pode ser prevista, pois depende das atividades dos outros processos, da forma como o sistema operacional trata as interrupções e das estratégias de escalonamento adotadas.
Há condição de corrida quando existem recursos compartilhados entre duas ou mais threads ou entre dois ou mais processos sem as devidas precauções.
O trecho do código que trata recursos compartilhados é denominado REGIÃO CRÍTICA.
Região Crítica – Parte do código que trata recursos compartilhados e deve ser protegida de forma a garantir acesso exclusivo a um processo ou uma thread.
Como evitar a ocorrência de uma condição de corrida?
Para garantir o acesso exclusivo a uma região crítica, será necessário utilizarmos mecanismos que garantam a EXCLUSÃO MÚTUA entre processos e/ou threads.
Exclusão Mútua – Solução que impede que dois ou mais processos tenham acesso a uma mesma região crítica, ou seja, impede acesso simultâneo a um determinado recurso.
Obs.: Acesso simultâneo à região crítica não é a mesma coisa que execução simultânea.
Os mecanismos que implementam a exclusão mútua podem colocar o processo que não deve ter acesso ao recurso em “espera ocupada” (busy wait) ou bloqueá-lo ao executar a função e deverá permitir o acesso ou desbloqueá-lo ao executar a função.
Para que um mecanismo de exclusão mútua seja efetivo, deve garantir que:
Somente um processo por vez possa executar uma região crítica;
Um processo interrompido fora de uma região crítica não possa impedir que outro processo tenha acesso a essa região crítica;
Não possa haver nem deadlock nem starvation;
Quando não houver processo executando uma região crítica, qualquer processo que solicitar acesso deverá obtê-lo imediatamente;
Um processo deve permanecer executando uma região crítica por tempo infinito;
Nada possa ser assumido sobre a velocidade relativa e dos processos nem o número de processadores.
Condições para ocorrência de deadlock
	Condições necessárias (não suficientes)
	Condição suficiente
	Exclusão mútua
	Os processos P1 e P2 precisam dos recursos R1 e R2 para executar
	Posse e espera (hold & wait)
	P1 está de posse de R1 e aguardando R2. P1 não executará enquanto não obtiver R2; logo, não liberará R1
	Não preempção
	P2 está de posse de R2 e aguardando R1. P2 não executará enquanto não obtiver R1; logo, não liberará R2
Para implementação de um mecanismo de exclusão mútua, utilizaremos um protocolo de acesso e um protocolo de saída de uma região crítica. Esse protocolo poderá ser baseado em soluções algorítmicas, em características do processador ou em primitivas do sistema operacional.
Aula 5
Sincronização entre Processos
A utilização de mecanismos de exclusão mútua é necessária para impedir o acesso a uma região crítica por mais de um processo evitando, assim, condições de corrida. 
Os mecanismos estão divididos em três categorias baseados em:
Algoritmos
Características de hardware
Primitivas do sistema operacional
A implementação de um mecanismo de exclusão mútua implica a utilização de um protocolo de acesso à região crítica e um protocolo de saída da região crítica.
Mecanismos baseados em algoritmos
Possui uma estrutura baseada em algoritmos possui uma estrutura muito simples onde uma variável compartilhada determina se a região crítica está ou não livre. Essa solução possui diversas limitações, como veremos a seguir.
Algoritmo de Peterson
Apresenta uma solução para dois processos que pode ser generalizada para N processos.
Antes de acessar a região crítica, o processo sinaliza esse desejo através de uma variável booleana flag.
Porém o processo cede o uso do recurso ao outro processo indicado pela variável vez.
Em seguida, o processa executa um loop até a obtenção da variável vez.
Mecanismos baseados em características de hardware
São mecanismos que utilizam determinadas instruções do processador para a implementação de exclusão mútua.
Inibir interrupções - É a solução mais simples para o problema de exclusão mútua, pois permite que um processo desligue o recebimento de interrupções antes da execução de uma região crítica, impedindo a troca de contexto. As interrupções são novamente habilitadas após o término da região crítica. Nesse exemplo, serão utilizadas as instruções da família de processadores x86 para desligar (cli) e ligar (sti) as interrupções:
Instruções TSL (test and set lock) – São instruções atômicas que executam a leitura de uma variável utilizada para lock, armazenando temporariamente seu valor em um registrador. Sem sofrer interrupção, essa instrução valida o conteúdo da variável e faz a alteração se necessário.
Mecanismos baseados em primitivas do sistema operacional
Semáforos
Um processo é suspenso enquanto não obtém acesso à região crítica;
O processo bloqueado é acordado através de um sinal.
Monitores
O monitor é composto de várias rotinas cujas variáveis somente são acessadas dentro do monitor;
Um processo entra no monitor chamando uma das suas rotinas;
Somente um processo entra no monitor de cada vez.
Troca de Mensagens
Utilizado também em sistemas distribuídos.
Utiliza primitivas send e receive para o envio e recebimento de mensagens.
As primitivas podem ou não bloquear o processo.
Considere um receive bloqueante e um send não bloqueante. O processo deve aguardar um send para liberar o processo bloqueado na instrução receive.
Semáforos
O conceito de semáforo foi proposto por Dijkstra para implementação de exclusão mútua e sincronização condicional entre processos.
Um processo é suspenso enquanto não obtém permissão para executar uma RC e é automaticamente “acordado” através de um sinal.
Para liberar um semáforo “s” o processo deve executar uma primitiva signal(s) e para obter acesso a RC, via o semáforo “s”, o processo deve executar uma primitiva wait(s).
Um semáforo é uma estrutura de dados composta por um controlador e uma fila que registra os processos pendentes em ordem de solicitação.
Regras de acesso dos semáforos
O semáforo deve ser inicializado com um valor não negativo;
A operação wait decrementa o semáforo; se o valor ficar negativo o processo é bloqueado;
A operação signal incrementa o semáforo; se o valor não ficar positivo o processo bloqueado pela operação wait e desbloqueado.
Sincronização condicional – Um processo precisa de um resultado de outro processo para que possa continuar sua execução.