1. Sistemas operacionais ..........................................................................................................

3
Definição do sistema operacional .................................................................................... 4
Tipos de Sistemas Operacionais ...................................................................................... 4
Estrutura de Sistemas Operacionais ................................................................................ 5
2. Sistemas Computacionais .................................................................................................... 6
Estrutura de Sistemas de E/S ........................................................................................... 6
Estrutura de Acesso Direto à Memória (DMA) ................................................................ 7
Hierarquia de Memória ...................................................................................................... 7
Interrupções ........................................................................................................................7
3. Funções do Sistema Operacional ........................................................................................ 8
Gerenciamento de Processos ...........................................................................................8
Gerenciamento da memória principal .............................................................................. 8
Gerenciamento de arquivos .............................................................................................. 8
Gerenciamento de Sistemas de E/S .................................................................................8
Gerenciamento de memórias secundárias ......................................................................8
Sistema para redes de computadores ............................................................................. 9
Sistemas de proteção ........................................................................................................ 9
Interpretador de comando .................................................................................................9
Serviços implementados por SOs .....................................................................................9
Chamadas ao sistema ....................................................................................................... 9
Programas de sistema .................................................................................................... 10
Estruturas de Sistemas ................................................................................................... 10
Mecanismos e Políticas .................................................................................................. 10
4. Processos ............................................................................................................................ 11
Definição ...........................................................................................................................11
Processos vs. Programas ............................................................................................... 11
Processo na memória - Heap vs. Stack ......................................................................... 11
Componentes de um processo .......................................................................................12
Estados dos processos ................................................................................................... 12
Bloco de controle de processos (PCB/BCP) ................................................................. 12
Chaveamento de contexto .............................................................................................. 12
Fila de seleção de processos ..........................................................................................13
Filas de escalonamento .................................................................................................. 13
Escalonadores ..................................................................................................................13
Troca de contexto ............................................................................................................ 14
Operações em processos ............................................................................................... 14
Processos cooperativos vs processos independentes. ............................................... 15
Multiprogramação ........................................................................................................... 15
5. Threads .................................................................................................................................16
 Definição ...........................................................................................................................16
Características das Threads ........................................................................................... 16
Threads e processos ....................................................................................................... 17
Modelo de processo ........................................................................................................ 17
Implementação de Threads - TCB .................................................................................. 17
6. Alocação/Escalonamento de CPU .....................................................................................19
Escalonamento Preemptivo e não-preemptivo ............................................................. 19
Objetivo do escalonamento ............................................................................................ 20
Tipos de escalonamento .................................................................................................20
Despachante / Módulo dispatcher ................................................................................. 20
Algoritmos de Escalonamento ........................................................................................21
1. Sistemas operacionais

O OBJETIVO DE UM SISTEMA OPERACIONAL É AUMENTAR O GRAU DE

MULTIOPERAÇÃO E USAR A MAIOR CAPACIDADE POSSÍVEL DA CPU.
Sistemas computacionais modernos possuem diversos componentes como memória,
interfaces de rede, etc..
Os computadores possuem um dispositivo de software chamado sistema operacional o
qual oferece aos programas de usuário um modelo de computador mais simples, ao passo
em que lida com o gerenciamento dos recursos disponíveis aos sistemas computacionais
O trabalho do sistema operacional é de tornar conveniente o uso de um sistema
computacional. Tem como objetivo secundário utilizar o hardware de maneira mais
eficiente.
Um sistema computacional qualquer pode ser dividido entre hardware, sistema
operacional, programas aplicativos e usuários. Assim, o sistema operacional atua enquanto
gerente de recursos, bem como um programa de controle - controla a execução dos
programas dos usuários para evitar a ocorrência de erros ou uso inadequado do
computador.
O sistema operacional é o programa que permanece em execução no computador
em todos os momentos - também chamado de Kernel, de forma que o resto é composto por
programas aplicativos. Ainda, em um sistema computacional têm-se Software > Kernel >
Hardware, tal que a camada de aplicativos fica em cima do SO, e qualquer comunicação
com o hardware é feita por seu intermédio.

O sistema operacional é a peça mais básicas do software (camada superior do

sistema computacional) e opera em modo núcleo. Assim, possui acesso completo ao
hardware. O resto atua em modo usuário e é um subconjunto de instruções de máquina.
 Definição do sistema operacional

O sistema operacional é o programa que permanece em execução no computador em

todos os momentos - também chamado de Kernel.
Os sistemas operacionais realizam duas funções não relacionadas: fornecem aos
programadores um conjunto de recursos abstratos claros ao invés de recursos confusos de
hardware e gerenciam esses recursos.
O sistema operacional é responsável por gerenciar todas as partes de um sistema
complexo. Em computadores modernos, permitem a execução paralela de múltiplos
programas e a utilização de um mesmo recursos por múltiplos usuários ao mesmo tempo.
A tarefa principal de um sistema operacional como um gerenciador de recursos é a
manutenção do controle sobre quem está usando qual recurso, garantindo suas requisições
de recursos, controlando as contas e mediando conflitos de requisições entre diferentes
programas e usuários. O compartilhamento desses recursos pode ser feito por tempo
(diferentes programas ou usuários aguardam sua vez de usá-los), impondo prioridades e
limites sobre o uso dos recurso pelos usuários e seus aplicativos.

Tipos de Sistemas Operacionais

 Sistemas operacionais de computadores de grande porte: Ocupam uma sala inteira e

ainda são encontrados em centros de dados de grandes corporações

 Sistemas operacionais de servidores: Executados em servidores e servem múltiplos

usuários de uma vez em uma rede e permitem compartilhar recursos de hardware e
software. Deve permitir a gestão eficiente de grandes quantidades de recursos,
impondo prioridades e limites sobre o uso dos recursos.
 Sistemas operacionais de multiprocessadores (paralelos): Sistemas com mais de um
processador se comunicando, localizados próximos uns dos outros e compartilhando
um barramento por ondem são transmitidos os dados entre os componentes do SC.
Tem como vantagem o aumento da quantidade de trabalho realizado por unidade de
tempo, além do aumento da confiabilidade (existem sistemas conhecidos como
tolerantes a falhas).

 Sistemas em tempo real: Usados quando há requisitos rígidos relativos ao tempo sobre
a operação de um processador ou sobre o fluxo de dados e assim é frequentemente
usado como dispositivos de controle em uma aplicação dedicada a um propósito
específico.

 Sistemas operacionais Embutidos/Embarcados (embedded): Construídos para operar

sobre um hardware com poucos recursos de processamento, armazenamento e energia.
 São tipicamente aplicados em sistemas de telefones celulares, controladores industriais
e automotivos e equipamentos eletrônicos.

 Sistemas operacionais de computadores pessoais: Voltado ao atendimento do usuário

doméstico e corporativo para a realização de atividades corriqueira. São caracterizados
por sua interface gráfica, suporte à interatividade e operação em rede.

Estrutura de Sistemas Operacionais

A estrutura de sistemas operacionais pode ser dividida em:

 Sistemas monolíticos: executado como um único programa no modo núcleo, possuindo
uma coleção de rotinas ligadas a um único grande programa binário executável. Em
sistemas monolíticos, todos os componentes do núcleo operam em modo núcleo e se
inter-relacionam conforme suas necessidades, sem restrição de acesso entre si. Tem
como vantagem o desempenho, e como desvantagem o desenvolvimento e robustez e
suas manutenções mais complexas.

 Sistemas de Camadas: Forma elegante de organizar o sistema operacional de maneira

que a camada mais baixa realiza a interface com o hardware, camadas intermediárias
oferecem níveis de abstração e gerência mais sofisticados e a cada superior define a
interface do núcleo para as aplicações (chamadas de sistema). Tem como problema o
tempo com que o pedido de aplicação leva para chegar a um periférico ou recursos.

 Micronúcleo: Retirada no núcleo de todo o código de alto nível, deixando somente o

código de baixo nível necessário para interagir com o hardware e criar abstrações
fundamentais. Normalmente implementa somente a noção de atividade, de espaço de
memória protegido e comunicação entre atividades.

 Sistemas cliente-servidor: Clientes enviam requisições e o servidor fica aguardando e

respondendo as requisições de clientes.

 Máquinas Virtuais: Cópia exata do hardware, de maneira que cada uma pode executar
qualquer sistema operacional capaz de ser executado diretamente sobre o hardware.

 Exonúcleo: Presente na camada inferior e em modo núcleo, é um programa responsável

por alocar recursos às máquinas virtuais e verificar as tentativas de usá-los para
assegurar que nenhuma outra máquina esteja tentando usar os recursos de outras.
2. Sistemas Computacionais

O sistema operacional precisa garantir o funcionamento correto do computador, sendo

necessários mecanismos de proteção.
Um sistema computacional é composto por uma CPU, inúmeros controladores de
dispositivos controlados por um barramento que oferece acesso à uma memória
compartilhada - CPU e controladores podem ser executados simultaneamente competindo
por ciclos de memória.
A função dos computadores executar um programa constituído por um conjunto de
instruções armazenados na memória. Nesse sentido, para a execução são necessários
Ciclos de Busca (o processador busca a instrução na memória, uma de cada vez e as
executa sequencialmente) e ciclo de execução (o computador executa a instrução).

Estrutura de Sistemas de E/S

Quando uma operação de E/S é iniciada, tem duas possibilidades: I) operação síncrona,
na qual a operação é iniciada e, ao seu término, o processo do usuário volta a ser executado;
e II) operação assíncrona, na qual o programa continua sendo executado sem esperar o fim
da operação E/S.
Se considerar que a CPU sempre espera pelo fim de uma operação de E/S que é iniciada,
poderá ter no máximo uma requisição de E/S sendo executada por vez. Assim, dada uma
interrupção, o SO saberá exatamente qual dispositivo a provocou. Porém isso impede
operações concorrentes e sobreposição de processos computacionais com operação de E/S.
Por sua vez, pode-se continuar o processamento de outros códigos. Para isso são
usada chamadas de sistema as quais dão permissão a um programa de usuário para esperar
uma operação de E/S, tal que o SO deve ser capaz de operar em múltiplas requisições - feito
por meio de uma tabela de status de dispositivo.
 Estrutura de Acesso Direto à Memória (DMA)

Preparadas as áres de armazenamento, ponteiros e contadores para dispositivos de

E/S, o controlador DMA transfere blocos de dados inteiros diretamente para a memória,
sem intervenção da CPU, de forma que somente uma interrupção é gerada por bloco.
Levando em consideração que a memória principal é pequena para o armazenamento
permanente de todos os programas e dados, é necessário um sistema de armazenamento
secundário.

Hierarquia de Memória

Conceito utilizado para coordenar o uso de memórias em um sistema, tal que memórias
no topo são mais voláteis, rápidas, caras e menores, enquanto as memórias de base são
lentas, baratas, menos voláteis e com maior armazenamento. É pensado pelo princípio da
localidade temporal, tal que um dado acessado recentemente será provável de ser acessado
novamente.

Interrupções

As interrupções em um sistema computacional podem ser de software (gerada por

uma condição de erro no resultado de uma instrução); relógio (gerada pelo relógio interno do
processador, de forma que a SO execute certas funções em intervalos de tempos regulares);
ou de hardware (ocorrência de falha como queda de energia ou paridade de memória).
3. Funções do Sistema Operacional

Gerenciamento de Processos

Um sistema é constituído por um conjunto de processos, estando alguns no SO e outros

pertencentes ao usuário. Através da multiplexação da CPU, é possível que processos sejam
executados concorrentemente.
O sistema operacional é responsável por gerenciar os processos, de forma que atua
nas operações de criação, remoção, suspensão, reativação, sincronização, comunicação e
tratamentos de impasses.

Gerenciamento da memória principal

Tem como objetivo melhorar a utilização da CPU e a velocidade de memória do

computador. Nesse sentido, a maior parte dos programas é mantido na memória secundária,
enquanto somente a parte principal à execução é mantida na memória principal.
O sistema operacional é responsável por manter as informações sobre as partes
usadas na memória em um determinado momento e por quem, além de decidir quais
processos serão carregados na memória quando possível, além de alocar espaços e
remover programas/dados da memória quando necessário.

Gerenciamento de arquivos

Cabe ao SO a criação e remoção de arquivos/diretórios, suporte Às chamadas de

sistema para manipulação de arquivos/diretórios, mapeamento de arquivos na memória
secundária, cópia de arquivos em armazenamentos não-voláteis (hierarquia de memória,
manutenção de cópias na cache para aumentar a velocidade de acesso).

Gerenciamento de Sistemas de E/S

Subsistemas de E/S são compostos por um componente de gerenciamento de memória,

interface geral para controladores de dispositivos e rotinas de controle (drivers = tradução
para que o SO possa operar, dado que não é possível que conheça as particularidades de
todos os dispositivos a todo tempo).

Gerenciamento de memórias secundárias

O sistema operacional é responsável por gerenciar o espaço livre, a alocação de espaço

na memória e ordenação/seleção das operações para o uso do disco. Nesse contexto, a
velocidade de operação de um computador pode depender do subsistema de gerenciamento
de discos e dos algoritmos que os manipulam.

Sistema para redes de computadores

O compartilhamento de recursos proporciona um aumento na velocidade de

processamento, maior disponibilidade dos dados e maior confiabilidade do sistema. Um
acesso mais generalizado aos dispositivos de rede é fornecido geralmente pelos SOs.

Sistemas de proteção

São necessários mecanismos de proteção (de controle de acesso aos programas,

processo ou usuários aos recursos do SC) para que as ações de um processo não interfiram
indevidamente na execução de outros processos.

Interpretador de comando

É uma interface entre o usuário e o SO. Alguns SOs possuem o interpretador em seu
núcleo, enquanto outros tratam enquanto programa especial. São conhecidos como shell do
sistema, tendo como função obter próximo comando e providenciar que ele seja executado.

Serviços implementados por SOs

Os sistemas operacionais são responsáveis por executar programas, operaçõesd e E/S,

manipulação do sistema de arquivo,comunicação entre processos (entre computadores
diferentes ou num mesmo computador), detecção de erros, alocação de recursos,
contabilidade e proteção aos recursos do SC.

Chamadas ao sistema

A comunicação entre usuários e o SO é feita por chamadas ao sistema, tais que

representam instruções de linhas de montagem. Em alguns sistemas as chamadas podem
ser feitas por meio de linguagem de níveis mais altos, sendo similares a funções ou sub-
rotinas.
Podem ser agrupadas nas categorias: controle de processos, manipulação de arquivos,
manipulação de dispositivos, manipulação de informações, comunicações.
São a interface para os serviços do sistema operacional e escondem a complexidade
do SO e do hardware. São similares às chamadas de função e estão dentro do kernel/SO.
 Programas de sistema

Criam um ambiente para o desenvolvimento e execução de outros programas, e estão

localizados entre os programas aplicativos e o programa do SO.

Estruturas de Sistemas

O projeto de estruturas de sistemas operacionais requer planejamento cuidadoso. Nesse

sentindo, normalmente se emprega a abordagem de decompor uma tarefa em componentes
menores. Podem ser divididas em:
 Estruturas Simples: Existem SOs que começam pequenos e simples e com recursos
limitados, até que cresçam além do alcance original.

Estrutura MD-DOS, que possui interfaces e níveis de funcionalidade com pouca

separação, permitindo aos programas aplicativos o acesso a rotinas de E/S e
deixando o sistema vulnerável durante a execução de programas
incorretos/maliciosos.

Estrutura UNIX: Também não possuía estrutura bem definida, tendo apenas o
núcleo e programas de sistema. O núcleo continua o sistemas de arquivos,
sistema de alocação da CPU, gerenciamento da memória e outras funções do SO,
estando acima do hardware e abaixo da interface de chamadas de sistema.

 Divisão em níveis: Utiliza a abordagem de refinamentos sucessivos (top-down), a

funcionalidade geral e as características do sistema podem ser determinadas e
separadas em componentes. Essa abordagem simplifica a depuração e verificação de
propriedades do sistema. A maior dificuldade está relacionada ao fato de que um
determinado nível só pode usar operações de níveis inferiores, sendo necessário um
planejamento cuidadoso - e se tornam menos eficientes que outras abordagens.

Mecanismos e Políticas

Mecanismos determinam como fazer algo e as políticas determinam como será feito,
necessitando flexibilidade visto que políticas podem mudar com o tempo e lugar.
4. Processos

Definição

Os processos são programas em execução, de maneira que a execução de um processo

é sequencial - a qualquer momento, apenas uma instrução de determinado processo é
executada.
A um processo estão associadas informações sobre seu estado: 1) contador de
instrução; 2) valores contidos nos registradores do processador; 3) pilha que contém todos
os dados temporários; 4) uma seção de dados contidos em variáveis globais.

Processos vs. Programas

O programa é a sequência de instruções, de forma que é um algoritmo expresso por

uma notação adequada. O processo é o programa em execução, ou seja, a execução das
instruções de forma que o mesmo pode ser interrompido, salvando-se o contexto de onde
estava no programa antes da interrupção para que possa retornar do ponto onde parou.

Processo na memória - Heap vs. Stack

A memória é dividida em duas partes: heap e stack

 Heap: possui valores que permanecem armazenados até o fim do programa, como
variáveis globais, constantes e variáveis estáticas
 Stack (pilha): armazenam variáveis locais / armazenamento temporário de informações.
 Componentes de um processo

Um processo é composto por:

1. Espaço de endereçamento: memória que o processo pode acessar
2. Código do programa: heap e stack
3. Estado do processador: registradores relacionados ao processo (stack pointer,
contador de programa, etc.)
4. Recursos do SO: arquivos abertos, sockets, etc

Estados dos processos

Definido em parte pelo valor do contador de instrução e pelos valores dos registradores
do processo, os processos tem como possíveis estados: novo, rodando (running),
esperando (dormindo ou bloqueado), pronto e terminado.

Bloco de controle de processos (PCB/BCP)

A cada processo existem algumas informações associadas: process ID, user ID, estado
do processo, contador de programa, registradores da CPU, informações de escalonamento,
informações de gerenciamento de memória, informações de contabilidade e informações de
E/S. Nesse sentido, os processos são descritos no SO por um bloco de controle de
processos que possuem essas informações.

Chaveamento de contexto

Ocorre na mudança de um processo para o outro

É a atividade na qual é armazenado e restaurado o estado (contexto) de uma CPU de
forma que múltiplos processos posam compartilhar uma única instância de CPU.
 O compartilhamento de tempo permite que usuários possam interagir com seus
programas enquanto são executados, de forma que é preciso que a CPU seja tranferida
frequentemente entre os processos (fazendo chaveamento de contexto). Em um sistema de
processador único nunca haverá mais de um processo em execução, de forma que cada um
terá que esperar até que a cpu esteja livre e possa ser alocada para sua execução.

Fila de seleção de processos

Quando um processo é criado, é inserido na fila de processos. Nesse sentido,

processos armazenados na memória principal e prontos para execução são mantidos em
uma fila de processos prontos e armazenados sob forma de listas ligadas. O processo
inserido na fila de processos prontos espera na fila até que seja colocado em execução e
receba o controle da CPU. Feito isso, o processo pode fazer uma requisição de operação de
E/S e ser colocado em uma fila de E/S, criar um novo subprocesso e esperar seu término; ou
perder o controle da CPU devido a interrupções, sendo retornado a fila de processos
prontos.
Há também as filas de dispositivos, que contém todos os processos que esperam pela
liberação de um determinado dispositivo.

Filas de escalonamento

São filas de processos/jobs (conjunto de todos os processos no sistema; filas de

processos prontos - processos na memória principal e aguardam sua execução; e filas de
dispositivos - processos que esperam por um dispositivo de E/S.

Escalonadores

Os escalonadores atuam de forma que selecionam o processo mais apropriado para

execução. Podem ser divididos em:
 Dispatcher (escalonador de curto prazo): tem alta frequência de execução e é chamado
quando há interrupções, chamadas ao sistema ou sinais
 Swapper (escalonador de médio prazo): é parte do processo swapper, de forma que
determina qual processo fica total ou parcialmente na memória durante a execução e
está ligado à gerência de memória.
 Job Scheduler (escalonador de longo prazo): Ocorre quando o processo é criado e
determina quando o novo processo é admitido no sistema para o processamento e
disputa de recursos. São pouco chamados e podem ser lentos, controlando o grau de
multiprogramação.
 Troca de contexto

O contexto de um processo são as informações necessárias para que ele possa ser
restaurado a partir do ponto interrompido. Assim, a troca de contexto ocorre quando um
novo processo entra em execução e depende do suporte do hardware. Estão envolvidas as
ações:
1. Salvamento do contexto do processador
2. Alterar o PCB do processo que está rodando
3. Mover o PCB para a fila apropriada
4. Selecionar outro processo
5. Alterar o PCB do processo selecionado
6. Alterar as tabelas de gerência de memória
7. Restaurar o contexto do processo selecionado

Operações em processos

Processos podem ser executados simultaneamente e devem ser criados e removidos

dinamicamente de forma que cabe ao sistema operacional o papel de oferecer mecanismos
para a criação e finalização de processos.
A criação de processos ocorre a partir de uma chamada de sistema por parte de um
processo, o qual será chamado de processo pai, enquanto os novos processos são
chamados de processos filhos, que também poderão criar outros processos criando uma
árvore de processos. No linux a função fork() (chamada ao sistema) realiza a criação de
processos filhos.

Quanto ao compartilhamento de recursos, pode se dar de forma completa, parcial ou

não ocorrer. Além disso, há a possibilidade do processo filho ser uma cópia do pai ou ter um
programa que deve ser carregado para sua execução.

Por sua vez, processos podem ser finalizados quando a execução de sua última
instrução termina e uma chamada de sistema é feita para que seja removido do sistema.
Além disso, um processo pai pode terminar a execução de seu filho por motivos como
ultrapasse do limite de tempo para uso de um recurso, perda de valor da tarefa atribuída e
finalização do processo pai.
 Processos cooperativos vs processos independentes.

Processos concorrentes em execução no SO podem ser independentes ou cooperativos.

 Processos independentes: não podem afetar ou ser afetado por outros processos, ou
seja, não compartilham dados com outros processos.
 Processos cooperativos: Podem afetar ou ser afetados por outros processos, tais como
aqueles que compartilham dados por outros processos.

Multiprogramação

Pode melhorar a utilização da CPU. Tem-se que, de forma geral, um processo

permanece em execução apenas 20% do tempo que está na memória, sendo necessários 5
processos simultâneos apara que a CPU esteja ocupada o tempo todo. No entanto, é um
modelo irrealista porque não considera que os processos podem estar ao mesmo tempo
esperando E/S.
5. Threads

Definição

A THREAD É UNIDADE FUNDAMENTAL DA UTILIZAÇÃO DA CPU, QUE FORMA A BASE DE

APLICAÇÕES MULTITAREFAS EM SISTEMAS COMPUTACIONAIS.
As threads são ordens de execução, com instruções encadeadas e desempenhadas
uma por vez. Uma vez que a execução é muito rápida, existe a sensação de que são ações
simultâneas. Ainda, a CPU, através da thread, tem uma única linha de trabalho e realiza uma
ação por vez, de maneira que processadores multithread são mais vantajosos, possibilitando
operações em diferentes frentes ao mesmo tempo.
Cada programa, ou processo, possui normalmente um fluxo de controle, de forma que o
programa é executado sequencialmente passo a passo. Por sua vez, o uso de threads
permite a existência de mais de um único fluxo de controle, de forma que atuará como se
tivessem vários aplicativos com partes de seu código atuando em paralelo no sistema.
As threads são entidades escalonadas para executarem na CPU, concorrendo pelo
processador juntamente com outras threads que estiverem no programa, ou concorrendo
apenas com o fluxo do programa. Permitem que múltiplas execução ocorram no mesmo
ambiente do aplicativo com um grande grau de independência uma da outra.
Define-se, então, a multithreading enquanto um aplicativo que possui múltiplas threads
em seu interior e que como característica central, as threads compartilham o mesmo
espaço de endereçamento do aplicativo em execução. Assim, as informações são
compartilhadas e há o ganho no processamento e no gerenciamento da memória.

Características das Threads

Em várias aplicações há várias coisas, às vezes completamente independentes, que

podem ser feitas ao mesmo tempo. Assim, é quase sempre mais simples decompô-las em
threads que processos.
As threads são entidades muito mais leves que processos, de forma que criar/destruir
threads pode ser 100 vezes mais rápido que criar processos.
Aplicações que realizam muitas operações de E/S tem sem desempenho melhorado por
threads, além de serem úteis em sistemas de multiprocessadores, permitindo o paralelismo
real de operações.

Threads são compostas por um contador de programa, registradores e uma pilha com
história de execução.
Threads em um mesmo processo tem o mesmo espaço de endereçamento,
compartilham o mesmo conjunto de arquivos, processos filhos, alarmes, sinais, etc. Assim
como processos tradicionais, podem estar nos estados em execução, bloqueado, pronto ou
finalizado.
Nesse contexto, os processos atuam enquanto containers para as threads. Ou seja,
processos são utilizados para agrupar recursos, enquanto as threads são utilizadas para o
escalonamento da CPU.

Threads e processos

As threads de um mesmo processo compartilham o espaço de endereçamento e as

variáveis globais, de forma que podem se comunicar sem ser necessário o pipe. Por sua vez,
processos pais e filhos ocupam espaços de memória diferente e dependem de pipe para
sua comunicação.
Processos são pouco eficientes por possuírem, cada um, seu próprio PCB e recursos
do SO; não compartilham diretamente a memória, e são caros para criar. Por sua vez,
threads são mais eficientes por compartilharem diretamente o mesmo espaço de
endereçamento e recursos do SO, compartilham a memória se comunicando diretamente.

Modelo de processo

O modelo de processo é baseado em dois conceitos independentes: agrupamento de

recursos e execução. Algumas vezes é útil separá-los, sendo o caso das threads. Assim,
processos são usados para agrupar recursos e as threads são entidades de escalonamento
para execução sobre a CPU.
O que as threads acrescentam ao modelo de processo é permitir que múltiplas
execuções ocorram ao mesmo ambiente de processo, com grande grau de independência.
Múltiplas threads executando em paralelo em um processo é análogo a múltiplos processos
executando em paralelo no computador.
Existem duas características que podem ser tratadas de forma independente pelo SO:
thread ou processo leve (lightweight process) é a unidade de despacho; enquanto o
processo/tarefa é a unidade de alocação de recursos.

Implementação de Threads - TCB

A implementação das threads é feita a partir da quebra do PCB em dois pedaços: thread
específico (estado do processador) e processo específico (espaço de endereçamento e
recursos do SO). Assim:
 Thread Control Block (TCB): contém informações de uma única thread; incluindo
informações sobre o estado do processador e um ponteiro para o PCB. São menores e
mais baratos que os PBCs e atuam enquanto a unidade de chaveamento de contexto.
 Bloco de controld e processos / Process Control Block (PCB): informações sobre o
processo, como o espaço de endereçamento e recursos do SO, mas não do estado do
processador.

As threads podem ser implementadas nas formas:

1. Thread de usuário: O SO não sabe sobre a existência das threads e nem precisa dar
suporte a elas, de forma que cada processo tem um supervisor. O supervisor é
responsável por todas as tarefas relacionadas à criação e término de threads. É uma
abordagem eficiente, de forma que nenhuma interrupção ou alternância entre modos
usuário e núcleo é necessária e cada usuário/aplicação pode ter sua própria biblioteca
de threads. No entanto, o SO não possui controle sobre as threads, sendo necessário
que elas abram mão da CPU voluntariamente e podendo causar inanição. Uma forma
alternativa é implementar as funções das threads como bibliotecas.
2. Threads de núcleo (Kernel): O núcleo tem uma tabela de todas as threads do sistema,
de forma que a criação ou destruição de threads são feitas por chamadas do núcleo.
Assim, todas as chamadas que possam bloquear uma thread são implementadas
enquanto chamadas de sistema e permite o uso de sistema de reciclagem (quando
uma thread é destruída, é marcada como não executável, mas não tem sua estrutura de
dados afetada... quando uma nova thread é criada, uma thread antiga é reativada e
evita sobrecargas).
3. Threads híbridas: Combinam as vantagens das duas abordagens, de forma que se usa
threads de núcleo e, então, multiplexa as threads de usuário sobre algum ou todos os
threads de núcleo. Quando utilizada, o programador pode decidir quantos threads de
núcleo usar e quantos threads de usuário multiplexar sobre cada um. Essa abordagem
dá o máximo de flexibilidade.

MULTIPLEXAR: intercalar ou misturar mensagens , permite a comunicação simultânea por

um mesmo meio.

Em sistemas de programação multicore, os principais desafios são: divisão de

atividades, balanço, divisão de dados, dependência de dados, testes e debugs.
6. Alocação/Escalonamento de CPU

A decisão do SO sobre qual thread executará a seguir e características dessa execução

são feitas a partir do chaveamento de contexto, no qual a política é o escalonamento.
Em sistemas monoprocessadores, há somente um processo em execução, de forma
que outros devem esperar a liberação da CPU. Por sua vez, sistemas multiprocessadores
(multiprogramação) permitem a execução de múltiplos processos em paralelo.

O escalonador é o módulo/componente que determina qual thread irá executar a seguir

na CPU, de forma que atua na fila de prontos. Nesse sentido, a frequÊncia de
escalonamento pode ser determinada por:
1. Thread desiste do controle voluntariamente
2. Thread é bloqueada pelo E/S ou timer
3. Thread desiste
4. Thread termina
5. Preempção (interrupção de timer)

Escalonamento Preemptivo e não-preemptivo

O escalonamento não preemptivo se dá de forma que as threads devem retornar à

biblioteca periodamente, havendo controle da execução. Nesse caso a thread desiste da
CPU voluntariamente ou quando finaliza sua execução.
O escalonamento preemptivo se dá de forma que é enviado um sinal periodicamente de
forma a criar interrupções, assim fazendo o chaveamento e mudando para uma nova thread.

PREEMPÇÃO: SO PODE INTERROMPER UM PROCESSO/THREAD EM EXECUÇÃO E

ALOCAR UM NOVO
NÃO-PREEMPÇÃO: A PERDA DE CONTROLE DA CPU SÓ OCORRE QUANDO O
PROCESSO TERMINA SUA EXECUÇÃO OU QUANDO SUAS PRÓPRIAS INSTRUÇÕES
OCASIONEM MUDANÇA PARA O ESTADO DE ESPERA.

Escalonamento batch e interativo

 Escalonamento batch: Não-preemptivo e nenhum outro job roda se ele bloqueia
 Escalonamento interativo: preemptivo e outros jobs rodam se ele bloqueia.
 Objetivo do escalonamento

A principal função/objetivo é conseguir uma ótima alocação do tempo da CPU, de

forma que os demais objetivos podem ser divididos em:
1. Manter a cpu sempre ocupada
2. Aumentar o número de processos finalizados por unidade de tempo (throughput)
3. Minimizar o tempo de espera (soma dos períodos que um processo fica esperando na
fila de pronto)
4. Minimizar o tempo de resposta (tempo gasto entre uma requisição e a primeira
resposta produzida).
5. Minimizar o tempo de processamento (tempo entre inicio e fi da execução de processo.

Além disso, escalonadores tentam eliminar o starvation, situação que ocorre quando
threads prioritárias executam antes de threads de baixa prioridade- nesses casos as
threads de baixa prioridade estão em starvation/inanição e nunca são executadas. Uma
solução é aumentar a prioridade de acordo com o tempo de espera.

Tipos de escalonamento

Existem escalonadores preemptivos e não preemptivos, tais que:

 Escalonadores preemptivos: Capazes de suspender processos e threads, de forma que
a mudança para um novo processo pode ocorrer por:

Término de execução do processo

Execução de uma requisição de E/S ou sincronização

Liberação voluntária do processador a outro processo (yield)

Interrupção de relógio

Processo de mais alta prioridade esteja pronto para executar

 Escalonadores não-preemptivos: Processos ocorrem até que sejam concluídos, sem
serem interrompidos por eventos externos. Assim, a mudança para um novo processo
se dá pelo

Término da execução

Execução de requisição de E/S ou sincronização

Liberação voluntária do processador a outro processo (yield),

Despachante / Módulo dispatcher

Relacionado à mudança de contexto, o despachante é responsável por dar controle da

CPU para o processo selecionado pelo escalonador de curto prazo. Assim, envolve a
mudança de contexto, mudança para modo usuário e desvio adequado no programa do
usuário.
A latência de despacho refere-se ao tempo que leva para o despachante parar um
processo e colocar outro em execução.

Algoritmos de Escalonamento

TEM-SE OS ALGORTIMOS NÃO-PREEMPTIVOS:

 FIFO - FIRST IN FIRST OUT: De mais simples implementação, há uma fila de processos
aptos a executar de maneira que novos processos vão para o final da fila. O processo
no topo é o primeiro a ser executado, até que ele finalize e/ou libere o uso do
processador.
 SJF - SHORTEST JOB FIRST: Necessita do conhecimento do tempo de execução de
cada processo, o que é difícil. É baseado na noção de alocar o processador para o
menor job da fila, tendo que processos baseados em E/S são favorecidos. Nesse caso,
o tempo pode ser previsto pelo histórico ou pelo armazenamento de dados de todas as
execuções.
 Por prioridade: É associado a cada processo um número que indica sua prioridade, de
forma que quanto menor a duração da próxima fase, mais alta a prioridade. Assim, a
cpu é alocada para o processo com maior prioridade, de forma que a alocação pode ser
preemptiva e não-preemptiva. Por sua vez, tem a inanição como problema, de forma
que o envelhecimento (aumentar a prioridade de acordo com o tempo de espera na fila)
é uma solução.

HÁ TAMBÉM OS ALGORTIMOS PREEMPTIVOS

 Round Robin (circular): Cada processo pega uma pequena unidade de tempo da CPU
(quantum do tempo). Quando o tempo termina, o processo é colocado no fim da fila de
pronto. Dados N processos na fila, o quantum é dado por 1/N.
 Múltiplas fitas: Fila de processos divididas em filas separadas - execução em primeiro
plano (interativos) e execução em segundo plano (não interativos). Assim, cada fila tem
algoritmo de escalonamento próprio, tal que o primeiro plano é circular e o segundo é
FIFO. Nesse sentido, é feito o escalonamento entre as filas de acordo com uma
prioridade fixa de escalonamento ou fatia de tempo. Ainda, processos podem se mover
entre as filas, permitindo a implementação do envelhecimento.