O sistema operacional é a interface entre o usuário e o hardware.

O assembly é uma linguagem de

montagem e cada máquina era diferente.

Sistema operacional tem 2 modos de acesso: modo usuário e modo kernell. O modo usuário é onde
as aplicações funcionam, e o modo kernell é onde o SO faz suas rotinas. Quando os programas
necessitam de uma rotina do SO, eles fazem System calls para concluírem alguma tarefa como
salvar arquivo, por exemplo.

Arquitetura do Núcleo
Monolítico não é utilizado pq todos os programas rodavam no modo kernel e funcionavam como
um só programa, assim, se desse erro em um programa, todo o sistema travava.
Em camadas, na teoria era bonito mas viram que na prática não funcionava mt bem.
Microkernel os programas rodam no modo usuário, assim, quando trava o programa, é só fechar e
abrir dnv. Dessa forma, fica menos sensível a falhas. Porém, a troca constante de mensagens entre
os programas e o microkernel levava tempo.

Atualmente, utiliza-se uma arquitetura híbrida, em que pega os melhores pontos de cada tipo.

Processos
Quando o programa é disparado, ele entra no estado de criação e o sistema operacional cria um
pcb (bloco de controle do processo) para o processo.

Processos do SO é sempre de prioridade alta.

Uma vez que seu programa entra no estado de execução, ele passa a ser visível. Sempre que o
programa espera uma entrada do usuário ou saída, o processo entra em estado de espera, até que a
entrada, saída ou pop-up é respondido, ele volta ao estado de pronto, na fila. Quando o programa
termina, ele entra no estado de término, assim, o sistema operacional toma o controle e libera os
recursos para outros processos usarem. Depois ele deleta o pcb do processo para liberar memória
para outros processos entrarem.
Quando a memória está cheia e mais programas são disparados, ele coloca alguns processos no
estado de espera e pronto no HD para liberar espaço na memória para outros programas. Isso tem
um custo, como o HD é lento, isso vai atrasar os processos, e o desempenho do SO fica pior.

Sinal é uma interrupção avisando ao SO que o processo tem um sinal para ele, aí o processo trata
esse sinal. Só quando o processo está em estado de execução que ele vai lidar com o sinal.
CPU-bound gastam maior tempo em execução, I/O-bound gastam maior tempo em espera.
 Thread é um pedacinho de código do programa que faz uma tarefa específica. As threads utilizam
a cota de recursos que o processo recebeu. É muito mais rápido criar uma thread do que um
subprocesso ou processo independente.

Escalonamentos
Escalonamento preemptivo é caracterizado pela possibilidade do SO interromper um processo em
execução e passá-lo para o estado de pronto. No escalonamento não-preemptivo, quando o processo
está em execução nenhum evento externo pode ocasionar a perda do uso do processador.
Os critérios de escalonamento é o que faz a fila andar.

Tipos de escalonamento:
Escalonamento FIFO(não-preemptivo) - nesse escalonamento os processos seguem uma fila e só
saem quando terminam sua execução. O problema é que se um processo grande entrar, ele vai
atrasar os próximos processos na fila.

Escalonamento Circular(preemptivo) - nesse escalonamento os processos são atendidos com fatias

de tempo iguais, assim a CPU atende mais processos em um período de tempo. Porém se um
processo I/O-bound for para o estado de espera, na volta ele fica no final da fila, o que não é justo.
Pra ser mais justo existe o escalonamento circular virtual.

Escalonamento circular virtual - nesse escalonamento, os processos I/O-bound que foram pra espera
e saíram, eles voltam para o início da fila.

Escalonamento por Prioridades - nesse escalonamento, os processos prioritários, como um processo

de correção de problemas, precisão ser executados rapidamente, assim, esses processos são
atendidos primeiramente. Porém, se chegar muitos processos com prioridade alta, os processos com
prioridade baixa nunca vão ser atendidos. Esse problema é chamado de starvation, a solução é o
Aging (prioridade dinâmica).

Escalonamento Circular com Prioridades(preemptivo) - nesse escalonamento, os processos com

prioridade alta tem uma fatia de tempo, para que os de prioridade baixa também sejam atendidos.

Vai cair na prova:

1) Arquitetura de núcleo
2) Estrutura do processo (contextos de hardware, software e espaço de endereçamento )
3) Subprocessos e Threads (modo de criação)
4) Interrupções e/ou sinais
5) Escalonamento
 Gerência de Memória Antigamente
Pra executar os programas, eles tem que estar na memória principal. A primeira coisa que ocupa a
MP é o SO. Com a alocação particionada estática, cada partição da memória principal guarda um
programa por vez, e se sobrar espaço na partição, não poderá ser utilizado. Esse desperdício é
chamado de Fragmentação interna e não tem solução, porque não pode escolher o tamanho do
programa. Esse problema sempre será possível de acontecer se for definido espaços fixos na
memória.

Com a alocação particionada dinâmica, os tamanhos das partições é exatamente o tamanho que o
programa ocupa na memória principal. Essa alocação foi criada para tentar evitar a fragmentação
interna. Porém, quando os programas vão terminando e saindo da memória principal, vai
aparecendo “buracos” na memória que acaba dividindo o espaço. Esse problema chama-se
Fragmentação externa. A solução pra esse problema é a desfragmentação da memória, em que o SO
muda os programas de lugar e coloca eles juntos. Essa desfragmentação é mt demorada e acaba
afetando o desempenho do sistema, já que vai aparecer buracos várias vezes na memória.

Quando existe mais de um "buraco" que o programa pode entrar, havia 3 critérios para escolher
qual área alocar o programa: Best-fit, em que o SO tentava encaixar o programa no buraco mais
justo, menor, para que sobrasse menos espaço livre; Worst-fit, SO colocava no buraco mais largo,
para que sobrasse mais espaço para entrada de outro porgrama; First-fit, no primeiro buraco que
aparecer e caber, o SO encaixa lá. A performance de cada um depende da sorte.

Swap é quando a memória principal está cheia e algum programa é movido para a memória
secundária, para a entrada de outro programa na memória principal. O programa retirado é o que
tem menos chance de ser executado, quem estiver no fim da fila. Essa estratégia podia ser usada na
alocação estática e na alocação dinâmica. Na dinâmica, o programa a ser retirado tem que ser maior
ou igual ao tamanho do programa que vai entrar.
 Gerência de Memória Atualmente
O SO cria um Espaço de Endereçamento Virtual, que é uma abstração da memória. Esse espaço
aponta para vários endereços, tanto da MP, tanto da memória secundaria. Basta o endereço estar em
ordem na memória virtual que vai funcionar corretamente, mesmo estando fora de ordem na MP.
Quando a parte de um programa não está na MP, o bit de validade na tabela de páginas é 0, aí dá
page fault e precisa buscar a parte da memória secundaria pra MP. A memória virtual é dividida em
pedacinhos chamados de páginas, com tamanhos fixos, e o mapeamento é chamado de paginação.
Para encontrar a parte na MP pelo endereço virtual, é utilizado a tabela de mapeamento, que vai
traduzir o endereço virtual em endereço real na MP.
Como os tamanhos dos programas aumentaram muito, não dá pra trazer todo o programa pra MP
como antigamente, assim, é utilizado a memória virtual para mapear todas as partes do programa
em páginas.
Criação dos processos
Quando o processo é criado, também é criado o espaço de endereçamento virtual e a tabela de
mapeamento. Para o SO poder rodar o programa, ele precisará trazer pelo menos a primeira página
do programa para MP, nesse momento não pode dar page fault. Paginação antecipada é o processo
de trazer a primeira página e mais algumas pra MP. A vantagem é que vai dar menos page fault, e a
desvantagem é que demora para trazer as páginas. Na paginação por demanda, o SO traz somente a
primeira página, e depois vai carregando as outras, uma por uma, quando são referenciadas.
Desvantagem é que logo na segunda página já vai dar page fault. Quando dá page fault, o processo
é colocado em espera, mesmo sendo CPU-bound, vai ler aquela página e colocar na MP, daí vai
liberar o processo que vai voltar pra fila de pronto, aí a fila vai andar e aí sim o processo vai ser
executado.
Para alocar as páginas, o SO pode utilizar duas políticas de alocação: fixa ou variável. Na fixa, o
SO determina um número máximo de páginas que cada programa vai ter na MP. Na variável, o
limite de páginas varia de acordo com a ocupação da MP, se tiver sobrando espaço, o limite
aumenta.
Substituição de páginas
Em algum momento, não vai dar pra alocar mais páginas na MP, o SO vai ter que tirar uma página
do processo que precisou de outra página mas já está com o limite máximo. Pro SO escolher a
página a ser substituída, existem duas políticas de substituição: local e global. Na substituição local,
a página a ser retirada será escolhida do processo que gerou o page fault. Na substituição global, a
página retirada poderá ser de qualquer processo na MP. Os algoritmos de substituição são aqueles já
vistos: aleatório, FIFO, LFU, LRU, NRU, ...
Quanto menor for a página, mais páginas o SO vai ter que gerenciar. E pra gerenciar melhor essas
páginas, o SO trabalha com paginação em dois níveis, em que o primeiro é o diretório de páginas e
o segundo é a tabela. Exemplo paginação em dois níveis num sistema de 32 bits:

.
 Quando se usa paginação em múltiplos níveis, o SO utiliza o Translation Lookaside Buffer (TLB),
que é uma tabela de referência rápida, e serve para o SO não precisar toda hora passar por aquela
árvore de tabelas, guardando os endereços mais acessados na TLB.