Sistemas Operacionais: Conceitos e Funcionalidades

- S.O.: Programa ou conjunto de programas que fazem a intermediação entre o hardware e o usuário.

- S.O. estático: Projetado para executar uma única operação.

- S.O. dinâmico possuem um número variável de processos. Necessita de uma forma de criar e destruir.

- Multiprogramados mantêm mais de um programa simultaneamente na memória para permitir o compartilhamento efetivo do tempo.

- Multiprocessados executam suas tarefas em múltiplas UCPS.

- Processo: Programas em execução, incluindo os valores correntes do contador de programa, registradores e variáveis. Conceito dinâmico.

- Criação de um processo: Inicialização do sistema, requisição do usuário, processo em execução chama outro processo.

- Término: Saída normal, erro, erro fatal, destruído por outro processo.

- BCP - Contém informações sobre o processo: Identificação, estado, prioridade, localização, contador.

--------------------------------------------------

- Indefinido: Processo desconhecido pelo S.O.

- Bloqueado: Aguarda um evento.

- Pronto para execução: Aguardando outro processo sair do processador.

- Em Execução: Processo dentro do processador, está sendo executado.

- Criar: Processo na memória, torna conhecido pelo S.O.

- Acordar: Libera o andamento.

- Despachar: Dar sequência imediata ao andamento.

- Bloquear: Para o andamento do processo, aguarda evento.

- Preempção: Para por motivos alheios.

- Destruir: Libera a área de memória ocupada pelo processo.

- Escalonador: Avalia os processos e decide qual o processo rodará primeiro.

- Escalonamento de processos: Atividade organizacional feita pelo escalonador da CPU, possibilitando executar os processos mais viáveis e concorrentes, priorizando determinados tipos de processos como I/O.

- Curto prazo: Pronto para execução para em execução.

- Médio prazo: Em execução para bloqueado.

- Longo prazo: Olha a área do swap.

- Para que a CPU não fique muito tempo sem executar nada, os S.O. utilizam técnicas para escalonar os processos que estão em execução ao mesmo tempo.

- Critérios de Escalonamento: Uso da CPU, fração de tempo que está sendo ocupada, intervalo entre chegada ao sistema e início de sua execução, tempo de espera.

- FIFO: Primeiro que chega, primeiro a ser executado.

- SJF: Menor processo ganhará a CPU, fila por ordem crescente. - SRT Escolhido quem possui o menor tempo restante. - RR O S.O. possui um timer chamado quantum, onde todos os processos ganham o mesmo valor de quantum para rodarem na CPU.

- Preemptivo: Libera o processador para outro processo ganhar um quantum para executar e retornar a executar assim que possível. Não preemptivo não tem quantum, processo roda pelo tempo que for necessário.

Quantum: Tempo que o processo ganha ao ser despachado para execução.

- Performance = executar até acabar o workload.

- Tempo de resposta = apresentar o processo quando o usuário solicitar, impossível ter os 2.

- Gerenciamento de memória = alocar e desalocar um espaço na memória principal dos processos que estão em execução.

- Threads: Linha de execução, plano de execução, todos processo têm uma thread, ou seja, um caminho a ser percorrido. Possuem interdependência, uma vez que possuem privadamente: contador de programa, registradores, pilha e estado.

- Multithread: Existência de vários threads no mesmo processo, na troca de processos as tarefas são alternadas internamente.

- Benefícios: Processo pode ser dividido em mais de uma linha de tarefas, quando uma linha está esperando determinado dispositivo de I/O ou recurso do sistema, o processo não fica parado. Quando uma linha de execução entra em bloqueio, a outra aguarda na fila de prontos para executar.

- Contras: Roda apenas em um processador, não podem ser temporizadas, devem abrir mão voluntariamente.

- Thread no kernel: Núcleo conhece e gerencia, kernel mantém a informação de contexto para processos e threads. As threads podem aproveitar o multiprocessamento.

- 4 operações básicas:

- Criação: Uma linha de execução pode dividir-se em 2 e depois executam simultaneamente.

- Término: Terminado trabalho, a thread termina. Quando o pai termina, todas as variáveis são perdidas e as filhas não poderão acessar os recursos.

- Junção: A thread pode executar a join e aguardar até a outra terminar.

- Rendição: Para não ocupar a CPU por um longo tempo, a execução é suspensa e a CPU passa para outra thread em execução. Esta aguardará até a CPU tornar-se disponível novamente.

- Threads também necessitam de escalonamento, devido à alternância de tarefas, falsa ilusão de estar rodando em simultâneo.

- Último: Programador define o algoritmo de escalonamento, só não interfere. Programador é responsável por criar, executar, escalonar e destruir.

KLT: Escalonados pelo S.O., são mais lentas que a última, pois a cada chamada necessita consultar o sistema, exigindo assim a mudança total de contexto do processador.

Da mesma forma que os processos sofrem escalonamento, as threads também precisam.

- Escalonamento - threads em modo usuário: Passamos o controle ao processo, enquanto seu quantum for válido, ele irá decidir qual a thread irá rodar.

- Thread x processo: Processos carregam considerável estado da informação, têm endereço de MP separado e interagem somente através de mecanismos de inter-processos de comunicação.

- As threads, por outro lado, compartilham o estado da informação de processos únicos e compartilham MP e outros recursos diretamente.

Linha de execução assume estados:

- Criação: Processo pai está criando a thread, que é levada à fila de prontos.

- Execução: Linhas de execução estão na UCP.

- Pronto: Neste estado, a linha de execução avisa a CPU que pode entrar no estado de execução e entra na fila de prontos.

- Bloqueado: Neste estado, por algum motivo, a CPU bloqueia a linha de execução, enquanto aguarda I/O.

- Término: São desativados os contextos de hardware e a pilha é deslocada.

- Aplicação, S.O., hardware. Máquina multinível: ->

- Aplicações: Base de dados, jogos; - Software básico: Compiladores, S.O. - Hardware: Linguagem de máquina, dispositivos físicos.

Um S.O. pode processar sua carga de trabalho (workload) de duas formas:
● Serial: Neste, os recursos são dedicados a um único programa, até o seu término.
● Concorrente: Os recursos são dinamicamente reassociados entre uma coleção de programas ativos, em diferentes estágios de execução.

Classificação quanto ao compartilhamento de hardware:

- Monoprogramado: 1 programa em um dado período de tempo, o qual permanece na memória até seu término.

- S.O. para processamento em Batch (lote): Os jobs dos usuários são submetidos em ordem sequencial para a execução.

- S.O. Interativo: O sistema permite que os usuários interajam com suas computações na forma de diálogo.

- S.O. de Tempo Real: Usados para servir aplicações que atendem processos externos e que possuem tempos de resposta limitados.

* A ideia básica é criar um S.O. como uma hierarquia de níveis de abstração, de modo que, a cada nível, os detalhes de operação dos níveis inferiores possam ser ignorados. Através disso, cada nível pode confiar nos objetos e operações fornecidas pelos níveis inferiores.

O (VM) cria um nível intermediário entre o hardware e o S.O., denominado Gerência de Máquinas Virtuais. Este nível cria diversas máquinas virtuais independentes, onde cada uma oferece uma cópia virtual do hardware, incluindo modos de acesso, interrupções, dispositivos de E/S, etc.