SISTEMAS OPERACIONAIS

Tipos e Estruturas de um Sistema Operacional

O sistema operacional é um conjunto de rotinas que oferece serviços ao usuário e

às aplicações, O conjunto de rotinas é chamado de núcleo do sistema operacional
ou kernel.

Os tipos de arquiteturas existentes são:

● Arquitetura Monolítica
● Arquitetura em Camadas
● Máquina Virtual
● Microkernel

Arquitetura Monolítica
Nesta arquitetura os componentes do sistema são compilados em módulos
separados e depois linkados em um único programa executável. Os módulos são
carregados em memória e interagem entre si, a manutenção deste tipo de
arquitetura é bem difícil

Arquitetura em camadas
Nesta arquitetura o sistema operacional é formado por níveis ou camadas onde as
camadas inferiores oferecem serviços às camadas superiores. As camadas
inferiores são privilegiadas
Máquina Virtual
Um sistema operacional é formado por níveis, onde a camada de nível mais baixo é
o hardware. Acima dessa camada temos o sistema operacional que oferece
serviços para os aplicativos do usuário.

Na arquitetura de máquina virtual existe uma camada intermediária entre o

hardware e o sistema operacional chamada gerência de máquinas virtuais.

Esta camada cria diversas máquinas virtuais independentes, onde cada uma
oferece uma cópia virtual do hardware, incluindo os modos de acesso, interrupções,
memória, dispositivos de entrada e saída, etc.

-Como cada máquina virtual é independente das outras, é possível que cada VM
tenha seu próprio sistema operacional

Arquitetura MicroKernel

A arquitetura MicroKernel busca tornar o núcleo do sistema, o kernel o menor e

mais simples possível. Nesta arquitetura os serviços do sistema operacional são
disponibilizados como serviços. Cada serviço oferece um conjunto de funções como
gerência de arquivos, gerência de processos, gerência de memória e etc.

Sistemas Monoprogramados e Multiprogramados

Monoprogramados/Monotarefa
Este tipo de sistema operacional permite que apenas um programa seja
armazenado na memória para execução. Os demais programas devem aguardar o
término da execução do programa que está em memória. Todos os recursos do
computador permanecem exclusivamente dedicados ao único programa que está
em memória.

- SOs monoprogramados executam apenas um único processo por vez (dois

processos nunca estarão ativos ao mesmo tempo).
Multiprogramados/Multitarefas
Os sistemas multiprogramados/multitarefas permitem que vários programas sejam
executados compartilhando os recursos do computador tais como discos,
impressora, memória e processador.

- SOs podem múltiplos processos ao mesmo tempo em memória e há alternância

entre processos.

- A CPU não precisa ficar ociosa quando um processo não está sendo executada,
ela pode executar outro processo. O conjunto de processos são executados com
mais eficiência.
- O SO vai escalonando os processos - cada processo tem uma fatia de tempo para
ser executado.
- Multiprogramados = múltiplos processos em um único processador.
- Multiprocessados = múltiplos processos em múltiplos processadores.
- Preempção: SO multiprogramados podem tirar um processo da CPU porque já
acabou seu tempo de execução (mesmo que não tenha sido encerrado) para
executarem outro processo.

—-------------------------------------------------------------------------------------------------------------
 Perspectiva Top-Down e Bottom-Up

Top-Down
A perspectiva Top Down se refere muito a comodidade que os SOs fornecem aos
usuários (programadores e processos). Utilizando os mesmos comandos em
diferentes arquiteturas e SO's é uma comodidade que a perspectiva Top Down
provê aos usuários.

Bottom-Up
Escalonamento e gerenciamento do hardware para melhorar o desempenho, feito
pelo sistema operacional
- Bottom Up: Como o Hardware enxerga o SO.A perspectiva Bottom Up pensa na
eficiência da CPU, para que a mesma não fique ociosa.

Programas, Processos e Estados de Processos

Programas
Um programa de computador é uma coleção passiva de instruções, enquanto que
um processo é a execução real dessas instruções

Execução de Programas
‣ Código (instruções)
Um programa necessita estar carregado em memória RAM para ser executado,
sendo assim, cada variável e cada instrução do programa está localizado em algum
endereço na memória.
O conteúdo da memória onde estão localizados os dados, está mudando
constantemente e o local onde estão armazenados os código, permanece sempre
com o mesmo conteúdo.
A execução do programa é feita instrução por instrução até que a instrução de
finalização do programa seja executada.

Processos
Um processo pode ser considerado como um programa em execução, também um
conjunto de informações necessárias para a concorrência de programas no sistema
operacional. Além disso, também pode ser entendido como o ambiente onde um
programa é executado.
Estados do Processo

Em sistemas Multitarefas o processo não é executado todo o tempo pelo

processador

3 tipos de estados:

Execução (running) – O processo

está sendo executado pela CPU.

Pronto (ready) – O processo está

pronto e esperando para ser
executado pela CPU.

Espera (wait) – O processo está

esperando algum evento externo ou
por algum recurso para poder
prosseguir seu processamento.

Bloqueado – O processo está

esperando por algum recurso do
sistema que não se encontra
disponível.
Término de Processo

O processo termina quando ele é pedido para termina, quando outro processo
substitui ele ou quando o usuário pede para ele terminar

Threads

Threads são entidades escalonadas para executarem na CPU , de modo simples

elas são linhas de execução de um programa, quanto mais threads mais linhas de
execução são possíveis no programa

Threads permitem que múltiplas execuções ocorram no mesmo ambiente do

aplicativo com um grande grau de independência uma da outra, portanto, se temos
muitas threads executando em paralelo no sistema é a mesma coisa a múltiplos
aplicativos executando em paralelo em um computador. A principal razão para
existirem as threads é termos a possibilidade de ocorrerem muitas atividades ao
mesmo tempo em nossa aplicação.

As Threads têm um ciclo de vida similar ao de um processo: estado de PRONTO,

EXECUTANDO, BLOQUEADO. A thread não tem estado de SUSPENSO - o
processo do qual a thread faz parte é suspenso, é muito comum ter threads
bloqueadas esperando que outras threads acordem ela. Isso não é tão comum com
processos.. (tópico:escalonamento de threads)
n:1 - n:n - n:m
Todo processo tem pelo menos uma thread. Threads compartilham o mesmo bloco
de controle de processo.

Em SO's modernos, o escalonamento de threads acontece por parte do próprio SO

(ele conhece todas as threads), o que permite paralelismo real. Threads de um
mesmo processo podem ser executados em múltiplos processadores. O SO tem
tabelas de processos e tabelas de threads.

Comunicação entre Processos (IPC)

É definido como um grupo de mecanismos que permite aos processos transferir

informação entre si.

O IPC (Inter-Process Communication) é um mecanismo que permite que dois ou

mais processos realizem a troca de dados entre si. Isso é extremamente útil devido
ao fato que um processo possui sua própria região de memória onde outros
processos não têm a permissão de acessar aquele espaço de memória.
Tipos de IPC

Pull-based
Requer um meio, como um armazenamento para compartilhar os dados, isso
porque os processos que querem ler esses dados precisam dar um pull desses
dados. Neste caso os dados serão lidos através de um elemento intermediário,
como um repositório de dados,

Push-based

Neste caso os dados serão entregues diretamente ao processo que está realizando
a leitura, os IPC referente a esse grupo são:
● Signal
● Socket
● PIPE
● DBUS

Condição de Corrida e DeadLocks

Uma condição de corrida ocorre quando dois threads acessam uma variável
compartilhada ao mesmo tempo. O primeiro thread lê a variável e o segundo thread
lê o mesmo valor da variável.

Cada thread é alocado um período de tempo predefinido para ser executado em um

processador. Quando o tempo alocado para o thread expira, o contexto do thread é
salvo até a próxima ativá-lo

- Na região crítica pode ocorrer a condição da

corrida
A maneira de evitar a corrida é garantir a
exclusão mútua, não permitindo que várias
threads acessem a região crítica ao mesmo
tempo.
Há quatro regras para evitar corrida:

1. Exclusão mútua:
2. Progressão: nenhuma thread fora da região crítica pode impedir outra thread
de entrar na região crítica (uma thread na região crítica deve proibir outra
thread de entrar na região crítica).
3. Espera limitada: uma thread não deve esperar infinitamente para entrar na
região crítica.
4. Hardware: não deve se considerar as características do hardware:
quantidade de núcleos, memória, etc. (precisa funcionar em qualquer
hardware).

DeadLock

Um deadlock ocorre quando dois threads

bloqueiam uma variável diferente ao mesmo tempo
e tentam bloquear a variável que o outro thread já
bloqueou. Como resultado, cada thread para de
executar e aguarda o outro thread liberar a variável.
Como cada thread está segurando a variável que o
outro thread deseja, nada ocorre e os threads
permanecem com deadlock.

Para ocorrer deadlock deve ocorrer:

● 1-Exclusão mútua
● 2-uso e espera
● 3-não preempção
● 4-espera circular

tática do avestruz
 Escalonador e Algoritmos de Escalonamento

Um Escalonador de Processos é um subsistema do Sistema Operacional

responsável por decidir o momento em que cada processo obterá a CPU, ele é
usado em algoritmos que estabelecem tal lógica de decisão.

Deve-se ter cuidado com algumas variáveis como em casos que necessitam de
mais processamento. Como com processos que necessitam de processamento,
ocuparão a CPU por um tempo maior e não precisarão, ou de pouca intervenção do
usuário.

Por exemplo, programas de cálculo científico, que o usuário insere parâmetros e

executa o programa que demora um determinado tempo para mostrar os resultados,
isso exige processamento da CPU, com entrada e saída de dados apenas no
momento inicial.

Já processos que necessitam de mais entrada e saída de dados o processo

necessita de intervenção do usuário. Por exemplo, ao digitar um texto, há entrada e
saída de dados, logo, a resposta do ato de teclar e a resposta de aparecer isso na
tela exige que esse processo "entra e sai" da CPU inúmeras vezes e em um
pequeno espaço de tempo.

Acabamos de ver os dois diferentes comportamentos de processos. Aqueles

orientados a Entrada e Saída (IN/OUT bound) e aqueles orientados a orientados a
CPU (CPU bound).
 Tipos de Escalonamento

O Escalonamento Preemptivo que escolhe um processo e lhe concede a CPU

durante certo tempo. Dado esse tempo, a CPU é de outro processo. Esse cenário
tem as seguintes condições: Criação de um novo processo; Término de um
processo; Processo ser bloqueado; Após alguma interrupção; Periodicamente, a
cada k intervalos de relógio.

O Escalonamento Não Preemptivo que ocorre apenas em situações que

praticamente obrigam que uma decisão seja tomada. Esse cenário tem as seguintes
condições: Criação de um novo processo; Término de um processo; Processo ser
bloqueado; Após alguma interrupção.

Tipos de Algoritmos de Escalonamento

First-Come, First-Served (não preemptivo)

A forma de escalonamento mais elementar consiste em simplesmente atender as

tarefas em sequência, à medida em que elas se tornam prontas (ou seja, conforme
sua ordem de ingresso na fila de tarefas prontas). Esse algoritmo é conhecido como
FCFS – First Come - First Served – e tem como principal vantagem sua
simplicidade.
ID - id da tarefa
AT- Arrival Time
BT- Bash Time
CT-Completion Time
TaT-Turnaround Time - tempo total de execução da tarefa (inclui tempo de pronto)
WT-Waiting Time

TaT=CT-AT WT=TaT-BT

ID AT BT Ct TAT WT

A 0 16 16 16 0

B 0 7 23 23 16

C 0 3 26 26 23

D 0

Shortest-Job-First

O algoritmo de escalonamento conhecido como menor tarefa primeiro (SJF -

Shortest Job First) consiste em atribuir o processador à menor (mais curta) tarefa da
fila de tarefas prontas. Esse algoritmo (e sua versão preemptiva, SRTF) proporciona
os menores tempos médios de espera das tarefas.
Hiqhest Response Rate N

O processo com maior taxa de resposta

(Bt+Wr)/Bt

Shortest Remaining Time First (SRTF)

O algoritmo SJF é cooperativo, ou seja, uma vez que uma tarefa recebe o
processador, ela executa até encerrar (ou liberá-lo explicitamente). Em uma variante
preemptiva, o escalonador deve comparar a duração prevista de cada nova tarefa
que ingressa no sistema com o tempo de processamento restante das demais
tarefas presentes, inclusive aquela que está executando no momento
Round-Robin

A adição da preempção por tempo ao escalonamento FCFS dá origem a outro

algoritmo de escalonamento bastante popular, conhecido como escalonamento por
revezamento, ou Round-Robin

Referências

Condições de Corrida e Deadlocks

https://learn.microsoft.com/pt-br/troubleshoot/developer/visualstudio/visual-basic/lan
guage-compilers/race-conditions-deadlocks

Comunicação entre processos - wikipedia

https://pt.wikipedia.org/wiki/Comunicação_entre_processos#:~:text=A%20comunicaç
ão%20entre%20processos%2C%20em,processos%20transferirem%20informação%
20entre%20si.

Threads
https://www.devmedia.com.br/programacao-com-threads/6152

https://www.techtudo.com.br/noticias/2019/01/o-que-sao-threads-e-para-que-servem
-em-um-processador.ghtml

Comunicação entre processos

https://embarcados.com.br/comunicacao-entre-processos/

Micronúcleo
https://pt.wikipedia.org/wiki/Micronúcleo_(computação)#:~:text=Micronúcleo%2C%2
0ou%20microkernel%2C%20é%20uma,sistema"%20(kernel%20space).

Processos no sistema operacional

https://dev.to/nfo94/o-que-e-um-processo-em-um-sistema-operacional-2769

Escalonador e Algoritmos de Escalonamento

http://wiki.inf.ufpr.br/maziero/lib/exe/fetch.php?media=socm:socm-06.pdf