T1 – SISTEMAS OPERATIVOS
von Neumann Architecture
CPU executa uma sequência de instruções que actua sobre os dados;
- as instruções e dados encontram-se em memória;
- unidade de controlo – obtém instruções da memória, descodifica e
executa-as, chamando a ALU quando necessário;
- unidade aritmética lógica (ALU) – realiza operações aritméticas e
lógicas;
- esta arquitectura é baseada no ciclo ‘fetch-decode-execute’:
1) fetch – obtém uma instrução da memória, de acordo com o valor de
PC (program counter), e coloca-o no IR (e incrementa PC);
2) decode – descodifica a instrução, por forma a perceber o que deve
fazer;
3) execute – executa a instrução (colocada em IR – instruction register);
Características desejáveis de um SO:
1)fiabilidade – limitar ao máximo a falha dos componentes de hardware
(como bad blocks no disco) e programas de software (provocados pelo
utilizador e mesmo pelo próprio sistema);
2)eficiência – tempo de resposta (do ponto de vista do utilizador) e, carga
de trabalho e gestão de recursos (do ponto de vista do sistema);
3)uniformidade e facilidade de uso – tanto do utilizador para o SO no
acesso a serviços, como do SO para o utilizador com, por exemplo,
mensagens de erro;
4)previsibilidade do comportamento do sistema – o tempo de resposta
deve depender, crucialmente, da natureza da tarefa a decorrer, não de
factores aleatórios;
5)facilidade de adaptação – alteração de parâmetros para melhorar o
desempenho aquando do ajuste das definições do sistema para um novo
hardware.
6)Mensurabilidade e avaliação de desempenho – permite a recolha de
dados de componentes, hardware e software para apoiar o utilizador no
desenvolvimento mais eficiente, e o administrador obter um
desempenho satisfatório;
Conversões bits/bytes:
1 byte = 8 bits | 1KB = 1026 bytes | 1MB = 1024KB
T3 – ALGORITMOS DE ESCALONAMENTO CPU
Tipos de escalonamento:
- não-preemptivo: quando o CPU é alocado para um processo, o processo mantém o
CPU até que termine ou bloqueie nas operações de I/O, passando para um estado de
espera (waiting);
- preemptivo: o SO pode decidir e tirar o CPU de um processo que esteja em
execução.
Critérios de optimização de escalonamento:
Utilização de CPU – Máx;
Throughput – número de processos que completam a sua execução por unidade de
tempo | Máx;
Tempo de execução (turnaround) – tempo que leva a executar um processo em
particular | Min;
Turnaround = completion time – arrival time
Tempo de espera – tempo que um processo esteve em espera na ready queue | Min;
Tempo de resposta – tempo que demora desde a submissão até à obtenção da
primeira resposta | Min.
Dispatcher:
- módulo que dá controlo ao CPU para executar o processo seleccionado no
escalonador de curto-prazo;
- invocado sempre que há troca de processos -> latência de despacho: tempo que leva
o dispatcher a parar um processo e a iniciar outro; nunca poderá ter a mesma duração
do tempo de execução de um processo;
Algoritmos de escalonamento:
1) FCFS (First-come, First-served) ou FIFO (first-in, first-out):
- método mais simples, sem grande gestão associada;
- pela ordem de chegada, distribui os processos para o CPU; o processo que primeiro
requisite o CPU será o primeiro a ser executado;
- tempo de espera longo;
- não-preemptivo, i.e., o processo não pode ser interrompido em qualquer altura,
apenas quando este interromper voluntariamente (bloquear ou requerer I/O) ou
acabar.
- Desvantagem: convoy effect – processos mais curtos depois de processos longos são
penalizados, pois estarão mais tempo à espera para serem executados.
2) Shortest job first (primeiro o menos trabalhoso):
- associa a cada processo o tamanho do próximo serviço (burst) de CPU, e faz uso
desses tamanhos para escalonar o processo que tem o menor tempo;
- Shortest process next (SPN) – não-preemptivo | procura o próximo processo a entrar
(em ready) que exige menos tempo e executa-o depois do processo que está em curso
(terminar o CPU burst);
- Shortest remaining time (SRT) – preemptivo | interrompe o processo em execução,
caso seja longo, e passa a executar o processo que tenha chegado e tenha um tempo
de execução inferior ao tempo que falta para terminar o processo longo que se
encontrava em execução; analisa de todos os processos os tempos que precisam e
executa aqueles que têm menor ou igual tempo àquele que está a ser executado;
- o SPN será o melhor método pois haverá menor tempo de espera para o conjunto de
processos;
- cálculo: tempo de espera = momento em que é executado – tempo de chegada;
5) Escalonamento prioritário
- o CPU é alocado para o processo com maior prioridade: preemptivo | não-
preemptivo;
- Problema: esgotamento (starvation) – os processos com pouca prioridade poderão
nunca ser executados;
- Solução: envelhecer (aging) – com o tempo aumenta a prioridade do processo;
T2 – PROCESSOS, THREADS, SINCRONIZAÇÃO, DEADLOCK
- Um processo consiste em ciclos de execução, seguido de I/O;
- A execução de um processo consiste no ciclo da execução do CPU e espera de I/O (operações que gerem e obtêm dados);
- O processo está grande parte do tempo a executar CPU e invoca I/O para ir buscar dados e recursos (RAM).
- Balancear as operações de CPU e I/O para rentabilizar a máquina; optimizar o CPU e I/O por forma a que não haja
processos à espera para serem executados.
Ciclo de vida de um processo:
- ready: todos os processos prontos a executar; que podem a
qualquer momento começar a ser executados (não consome
CPU);
- running: executa um processo até que o utilizador ordene
ou caso necessite de executar outro processo para
completar o primeiro (ficando este em waiting) (tem acesso
ao CPU, logo consome CPU); Multiprogramação (Multiprogramming):
- waiting/blocked: processo a aguardar que seja executado Tem vários programas em memória, activos ao mesmo
(bloqueio) e passará para ready assim que seja chamado a tempo, para que quando o programa em curso já não
executar (não consome CPU); consiga correr/ prosseguir (no caso de estar
- terminated: todas as estruturas são executadas, a memória bloqueado à espera de I/O), outro está pronto a ser
é limpa e o processo termina (acesso ao CPU). executado; vários processos (na íntegra) executados
ao mesmo tempo.
Escalonadores
O nome do escalonador sugere a frequência relativa com Multitarefa (multitasking):
que as suas funções são executadas. Extensão de multiprogramação, em que a execução de
- LONG TERM (ou de admissão) – Decide que processos programas activos é escalonada, i.e., cada programa
podem ser admitidos para a ready queue. corre por um curto período de tempo e depois, é
- MID TERM – Transporta temporariamente os processos da interrompido, para correr outro programa;
memória principal para a secundária e vice-versa. Cada processo tem um tempo, de curta duração,
- SHORT TERM – Decide qual o processo da ready queue vai máximo para ser executado, quando exceder esse
ser executado tempo o processador é retirado a esse processo e
executa um novo; Este tempo é definido pelo SO,
Terminação do processo:
sendo baseado em round robin.
- processo foi completado;
- excedeu o limite de tempo; THREADS
- memória indisponível; São executadas dentro do mesmo processo/programa;
- violação da ‘fronteira’, i.e., um processo está ‣ A memória ocupada é a mesma;
a escrever na memória de outro, assim é ‣ Não é necessário mudar de processos;
forçado a terminar; ‣ Comutar a execução e a comunicação entre threads é
- erro de protecção; fácil e rápida.
- falha no acesso ao sistema I/O; Porquê usar threads? Trocar de processos implica:
- instrução inválida; remapear endereços de memória, estabelecer novos
- intervenção do SO (no caso de deadlock); contextos de segurança, etc.
- o processo-pai termina, por isso o processo- PARALELISMO – Executar mais do que uma tarefa
filho também termina; simultaneamente.
- o processo-pai ‘ordenou’ a sua terminação; CONCURRENCY – Um sistema é concorrente se permitir
que mais que uma tarefa consiga fazer progressos.
É possível haver concurrency sem paralelismo.
Thread pools: estima-se o número de pedidos a serem atendidos e criam-se threads para esses pedidos, que ficam em
stand-by até serem chamadas a executar a tarefa e, assim que termine é novamente libertada.
1)Algumas threads são criadas atempadamente e bloqueadas à espera que lhes seja atribuída uma tarefa;
2)Quando aparece uma tarefa, a thread gestora acorda uma thread da “piscina” e atribui-lhe essa tarefa para ser feita;
3)Depois de a thread completar a tarefa esta retorna à “piscina” e fica à espera que outra tarefa lhe seja atribuída.
SINCRONIZAÇÃO
– É o processo de sincronizar processos de forma a que sejam executados conforme o utilizador/developer pretendem.
(Exemplo dos trabalhos na impressora.)
RACE CONDITION – A situação criada quando vários processos acedem e manipulam dados concorrentemente e os
resultados que daqui podem advir, dependendo do timing dos processos.
Mútua exclusão
RECURSO CRÍTICO – Que não pode ser acedido por mais do que um processo de cada vez.
SECÇÃO CRÍTICA – A parte de um programa que a acede a um recurso crítico. ‣ Exclusão mútua é a habilidade de garantir
múltiplos processos que partilham dados/recursos apenas acedem um de cada vez a um objeto.
REGIÕES CRÍTICAS – Processos em regiões críticas necessitam de ser geridos p/ não ameaçarem a integridade do sistema,
a sincronização é obtida através de semáforos, variáveis condicionais, etc.
Semáforos É um objeto de sincronização; suporta duas operações. wait() – Se o semáforo estiver positivo, decrementa
e continua, senão bloqueia o processo ou thread. post() – Incrementa o semáforo ++ se havia algum processo bloqueado
devido ao semáforo, desbloqueia-o
DEADLOCK
- Ocorre quando existe um bloqueio permanente de processos que competem entre si pelos recursos do sistema ou
que comunicam entre si; dependem um do outro.
Condições para deadlock:
Caso se verifiquem, ao mesmo tempo, as 4 condições seguintes:
1)Exclusão mútua – apenas um processo pode usar um recurso de cada vez;
2)Hold-and-wait – um processo requer todos os recursos necessários para a sua execução de uma só vez, i.e., um
processo detém um recurso e espera pelos restantes que necessita;
3)Não-preempção – os recursos não podem ser preendidos, i.e., apenas podem ser libertados voluntariamente;
4)Espera circular – o processo1 está à espera de um recurso retido pelo processo2 que, por sua vez, está à espera de
um recurso retido pelo processo1;
3) Highest Response Ratio Next (HRRN): não-preemptivo;
𝑡𝑒𝑚𝑝𝑜 𝑒𝑚 𝑒𝑠𝑝𝑒𝑟𝑎+𝑡𝑒𝑚𝑝𝑜 𝑑𝑒 𝑠𝑒𝑟𝑣𝑖ç𝑜 (𝑞𝑢𝑒 𝑙𝑒𝑣𝑎 𝑎 𝑡𝑒𝑟𝑚𝑖𝑛𝑎𝑟 𝑜 𝑝𝑟𝑜𝑐𝑒𝑠𝑠𝑜)
- escolhe o processo com maior rácio (R):
𝑡𝑒𝑚𝑝𝑜 𝑑𝑒 𝑠𝑒𝑟𝑣𝑖ç𝑜
- os processos mais curtos são favorecidos (uma vez que têm denominador menor e por isso o seu rácio é maior);
- tem em conta a idade dos processos – o processo fica mais velho (mais tempo parado) e com isto aumenta a sua prioridade para executar; a
idade do processo aumenta com o tempo de espera (período sem ser servido);
- por ter em conta a idade, evita o esgotamento (starvation), i.e., que os processos fiquem ad eternum sem serem executados;
4) Round Robin:
- time quantum: cada processo tem um tempo limitado para ser executado (no CPU time), Depois deste tempo acabar, o processo é interrompido
e adicionado ao fim da ready queue;