Slides Sync 2 PDF

Sistemas
Operativos
IST - LEIC - 1º Semestre
Paulo Ferreira - INESC/IST 1
Autoria
ð estes transparentes:
wsão baseados no livro “Fundamentos de Sistemas Operativos”, de José Alves
Marques e Paulo Guedes, Editorial Presença ;
wabrodam apenas a primeira parte da matéria, i.e., introdução aos sistemas
operativos, noção de processo, gestão de processos e sincronização;
wresultam do esforço de vários docentes do IST que, ao longo de vários anos, têm
leccionado a disciplina de Sistemas Operativos: Paulo Ferreira, André Zúquete,
Luís Veiga;
wsão disponibilizados livremente para fins didácticos em www.rnl.ist.utl.pt/~ic-so;
wserão constantemente melhorados de modo a satisfazer as necessiadades de
aprendizagem dos alunos.
Page 1
Introdução
ð o que é um sistema operativo?
wconjunto de programas que servem para gerir e vigiar a execução dos programas de
diversos utilizadores e que promovem a gestão dos recursos de um computador
ð quais os objectivos?
winterface com o utilizador simples e fácil de utilizar (máquina virtual)
wexploração eficiente dos recursos hardware da máquina (tempo de processamento,
memória volátil e de massa, periféricos de comunicação)
Funções Principais de um Sistema Operativo

ð gestão da concorrência
wcontrolar diversos fluxos de actividade independentes que se executam “em
paralelo” sem que os mesmos interfiram não intencionalmente
ð partilha de recursos com protecção
wfísicos: processador, memória, discos, periféricos diversos
wlógicos: programas de uso geral (editores, compiladores) e bibliotecas partilhadas
por diversos programas
ð gestão de informação persistente
warmazenamento fiável e seguro da informação não volátil em suportes magnéticos,
ópticos, etc.
ð controlo dos gastos
wcontabilização e limitação da utilização dos recursos físicos
Page 2
Recursos Físicos (hardware)
ð processador (CPU)
ð memória volátil (RAM)
ð periféricos:
wterminais
wdiscos
woutros (diskettes, bandas, CDs, impressoras, scanners, etc.)
ð especiais:
winterrupções do processador
wrelógio de tempo real
winstruções privilegiadas
wsuporte para memória virtual e protecção de memória
Evolução histórica
Sem Sistema Operativo (UNIVAC, IBM 701, IBM 650)
Tratamento por Lotes Rudimentar
Tratamento por Lotes (IBM 7090)
Multiprogramação (Multics)
Tempo Partilhado
Memória Virtual (UNIX)
Sistemas Distribuídos
1946 1950 1960 1970 1980

1ª Geração: 2ª Geração: 3ª Geração: 4ª Geração:
Interruptores Transístores Circuitos integrados Computadores pessoais
e válvulas
Page 3
Monitor de Controlo
ð permite ao utilizador: carregar programas em memória, editá-los e
verificar a sua execução
ð cada utilizador tem um determinado tempo atribuído durante o
qual tem o computador apenas para si
ð resultados dos programas: listagens, fitas perfuradas
ð monitor é formado por um conjunto de utilitários:
winterpretador de linguagem de comando
wcompilador
weditor de ligações (linker)
wcarregador de programas em memória (loader)
wutilitários para controlo de periféricos (consola, leitor de cartões, etc.)
ð desvantagem: computador está parado a maior parte do tempo
Tratamento em Lotes (Batch)

ð impessoras, leitores/perfuradores de fita são muito lentos
ð monitor de controlo: tempo de execução de um programa é
determinado pelas E/S
ð solução:
wrecolha de dados num computador auxiliar onde os dados são lidos para banda
magnética
wcomputador central lê a banda magnética e escreve resultados numa outra que é
lida pelo computador auxiliar produzindo listagens
ð evolução:
wperiféricos executam tarefas autónomas e avisam o processador do fim da sua
execução através de interrupções (comunicação assíncrona)
wexecução em paralelo dos programas e das E/S
Page 4
Multiprogramação
ð mecanismo de interrupções permite multiplexar o processador
entre várias actividades concorrentes
ð execução concorrente de vários programas:
wpermite optimizar a utilização do processador
wex.: P1 acede ao disco e ica bloqueado enquanto o controlador de disco funciona;
durante esse tempo, P2 pode ser executado pelo processador
wimplica mudança de contexto rápida, logo os programas têm de estar em memória
ð memória é limitada:
wswapping (guardar P1 em disco e carregar P2 em memória)
wimplica código recolocável (numa outra posição de memória)
Tempo Partilhado e Memória Virtual

ð tempo partilhado:
wmultiplexagem entre vários utilizadores
wdivisão do tempo disponível do processador
wsensação de dispôr de um computador apenas para si
wimplica considerar novos aspectos: sistemas de ficheiros, protecção dos dados
ð memória virtual:
wgestão da memória muito complexa (programas/utilizadores distintos)
wespaço de endereçamento virtual muito superior à memória física
Page 5
Sistemas Operativos: tempo virtual e real
ð tempo virtual:
wtempo de execução dos programas não tem relação com o tempo cronológico
exterior ao computador
ð tempo real:
wnoção do tempo é relevante
wtem como objectivo garantir que o computador pruduz uma resposta a um
acontecimento externo num intervalo de tempo limitado previamente especificado
ð várias gradações de tempo real:
wcontrolo de processos industriais
wsistemas transaccionais
wetc.
Critérios de Qualidade
ð fiabilidade:
wnão existência de erros intrínsecos
wtolerância a faltas/falhas nos recursos físicos
ð eficiência:
wtempo de resposta nos sistemas de tempo partilhado
wtempo de processador aproveitado/desaproveitado
wdesempenho - trabalhos/unidade de tempo
wpartilha dos recursos
wdegradação do desempenho com o aumento da carga
ð capacidade/facilidade de manutenção:
wconfiguração
wcorrecção de erros
wevolução
Page 6
Realização
Aplicações
Interface do Sistema
Sistema de Ficheiros
Comunicação e E/S
Gestão de Memória
Gestão de Processos
Modelo Computacional
ð conjunto de objectos do sistema operativo e operações que os
permitem manipular
Comunicação e E/S
Gestão de Memória
Comunicação e E/S
Gestão de Processos Gestão de Memória

e
Sincronização Gestão de Processos
Page 7
Gestão de Processos: conceitos de base
ð processador
welemento físico que executa uma acção definida numa instrução máquina
ð processo
wentidade “activa” no sistema operativo no âmbito da qual é executada uma
sequência de acções determinada por um programa
ð programa
wsequência de acções, descritas numa determinada linguagem, sem actividade
própria
ð aplicação
wconjunto de actividades cooperantes a decorrer em um ou mais processos segundo
as directivas de um ou mais programas
ð executável (ficheiro)
wbloco de instruções máquina e dados resultantes da tradução (compilação) de um
programa
Processo: abstracção de máquina virtual

ð espaço de endereçamento:
wconjunto de posições de memória a que um programa executado num processo pode
aceder
wregião de memória onde está o código, os dados e a pilha (stack) do processo
ð reportório de instruções:
wcódigo (programa compilado)
wtambém designado por imagem
ð contexto de execução:
wvalor dos registos do processador e de outras unidades de controlo (memória, etc.)
em cada instante
Page 8
Gestor de Processos: objectivo
ð criação e eliminação de processos
ð suportar a co-existência de processos:
watribuição do processador aos processos
wtratamento das interrupções da actividade dos processos
wfornecimento de mecanismos de sincronização entre processos
wlimitação das interferências destrutivas entre processos
ð manutenção de uma hierarquia de processos em curso
Utilizador 1 Utilizador 2
processo inicial processo inicial
subprocesso 1 subprocesso 1
subprocesso 2
Estrutura Hierárquica dos Processos

ð hierarquia traduz-se por informações que são mantidas no contexto
dos processos
ð tratamento da relação hierárquica depende dos sistemas:
wfim de um processo elimina todos os processos filhos
wfim de um processo não altera estado dos processos fihos
ð estrutura hierárquica facilita a criação de processos:
wgrande parte do ambiente pode ser herdado
Utilizador 1 Utilizador 2
processo inicial processo inicial
subprocesso 2
Page 9
Gestor de Processos: modelo computacional
ð criação de processos
wIdProcesso = CriarProc ( Código, Prioridade, ... )
•IdProcesso - identificador do processo no sistema.
•Código - ficheiro executável com o programa a executar pelo processo.
•Prioridade - importância relativa do processo no sistema.
ð eliminação de processos
wEliminarProc ( IdProcesso )
Concorrência
ð competição entre processos no acesso a um recurso
ð só um processador => pseudo-concorrência
wintercalação ou paralelismo lógico; ilusão de uma concorrência efectiva
ð comutação de processos
wo processo a executar é sucessivamente retirado do processador para dar lugar a
outro
ð salvaguarda do contexto de execução
wquando um processo perde o processador há que guardar um conjunto de
informações (contexto de execução) que possibilitem o seu retorno como se nada
tivesse acontecido
ð programação concorrente
wdesenvolvimento de programas incluindo partes que podem ser executadas em
paralelo
Page 10
Pseudo-concorrência
P1
P2
P3
Tempo real de execução dos processos t
P1
P2
P3
Utilização do processador t
Representação de Processos
ð os programas do núcleo fazem a gestão do “ambiente” onde os
processos são executados
ð estes programas manuseiam estruturas de dados que representam a
estrutura física dos processos
ð cada processo é representado por uma descrição que contém toda a
informação relevante:
wcontexto de hardware
• registos do processador (acumulador, uso geral, contador de programa, stack pointer,
estado do CPU) e da unidade de gestão de memória
wcontexto de software (permanente e volátil)
•identificação
•ficheiro executável
•prioridade
•estado do processo
•outras informações (periféricos em uso, ficheiros abertos, directório por omissão,
programa em execução, etc.)
Page 11
Gestão das Interrupções e Excepções
ð mecanismos de comunicação assíncrona entre o sistema e o
processador:
winterrupções
•notificações de acontecimentos globais à máquina (não dirigidas a um determinado
processo)
•controladas e tratadas exclusivamente pelo núcleo do sistema operativo
wexcepções
•notificações de acontecimentos relacionados com um processo e que devem ser
tratadas no seu contexto.
•controladas e tratadas pelo sistema operativo e (opcionalmente) pelos processos.
ð processamento de interrupções:
winterrupção gestor de interrupções rotina de tratamento/escalonamento
despacho
Funções Sistema (system calls)

ð interface aos serviços do sistema operativo
ð protecção (duas entidades funcionais):
wfunção propriamente dita, pertence ao programa do núcleo do sistema operativo
wrotina de interface que é ligada com o código do utilizador e que usa instruções
especiais (traps) para mudar de modo utilizador para modo sistema
ð vantagens:
wpartilha das funções sistema por todos os processos
wmodificação transparente do sistema operativo desde que não se altere a interface
ð protecção => não utilização de endereços de memória com dados do
sistema operativo
Page 12
Chamada a Funções Sistema
Programa do Utilizador
Executável
Rotina de biblioteca de
chamada à função sistema X
trap
Modo utilizador (não privilegiado)
Modo sistema (privilegiado)

Agulhagem
Sistema operativo
Função Função
sistema A sistema Z
Suporte Hardware para a Realização do SO

ð interrupções
wcomunicação assíncrona de eventos
ð relógio de tempo real
wtemporização das diversas actividades a executar
ð mecanismos de protecção
wevitar a corrupção do código e dados do sistema operativo
wlimitação das capacidades de endereçamento dos processos
ð gestão de endereçamento
wprotecção de blocos de memória principal
wpossibilidade de recolocar código e dados na memória principal
wdetecção de endereçamentos inválidos
Page 13
Diagrama de Estados de um Processo
Em
Execução
Seleccionado pelo
Bloquear
Despacho
Retirado pelo
Despacho
Não executável
Executável
(bloqueado)
Desbloquear
Lista dos Processos Executáveis

Tabela no
Sistema
Operativo
Lista dos Contexto do Contexto do Contexto do

Processos processo i processo i+1 processo i+2
Executáveis
Page 14
Núcleo do SO: gestão dos processos
Aplicações
Restantes Níveis
Multiplexagem
(scheduling)
Gestão
das Sincronização
Interrupções
Multiplexagem do Processador
ð despacho:
wverifica se o processo em execução é o mais prioritário; caso não seja (preempção):
•guarda o contexto hardware do processo em execução no respectivo descritor
•escolhe o processo mais prioritário entre os executáveis
•carrega o seu contexto hardware no processador
•transfere o controlo para o novo processo (instrução a executar: program counter)
wexecuta o processo em execução
wé activado sempre que existe a possibilidade de o processador ser comutado:
•quando o processo corrente termina ou fica bloqueado
•após uma interrupção ou uma chamada ao núcleo
ð escalonamento (scheduling):
wgestor do processador
wcontrola a prioridade dos processos de modo a optimizar a utilização de todos os
recursos do computador
Page 15
Escalonamento
ð objectivos:
wmaximizar a utilização do processador sem descurar o estado dos restantes
componentes do sistema (memória, periféricos, etc.)
wminimizar o custo computacional do algoritmo de escalonamento
ð time-slice:
wintervalo de tempo máximo que é atribuído a um processo
ð prioridade:
wrepresenta a importância do processo no algoritmo de atribuição do processador
ð preempção:
wretira o processador ao processo em execução sempre que um processo mais
prioritário fica executável
westado do núcleo do sistema operativo tem de estar consistente quando se dá a
preempção
Preempção
ð o que é:
wacção de retirar o processador a um processo em execução devido à existência de
outro mais prioritário
ð objectivo:
wpermite que os processos mais prioritários reajam rapidamente a um dado
acontecimento (reactividade aos acontecimentos externos)
ð custo:
wassociado à mudança de contexto (ex.: um processo só é retirado de execução
depois de ter usado processador durante um tempo mínimo)
ð quando ocore:
wna sequência de todas as acções susceptíveis de modificarem o estado dos
processos
ð exemplo (Unix):
wquando o processo em execução retorna a modo utilizador e existe um processo
mais prioritário executável
Page 16
Políticas de Escalonamento (1)
ð categorias dos sistemas operativos:
wtempo real (tempo de resposta limitado perante eventos externos)
wtempo partilhado
ð as políticas não podem ter em conta apenas o uso do
processador; é necessário ter em conta outros recursos (ex.:
memória)
ð teoricamente seria interessante que a função de escalonamento
fosse invocada sempre que um recurso do sistema é atribuído
ou libertado (memória, prefiféricos, etc.)
ð o problema é que a própria função de escalonamento consome
recursos

ð políticas para ambientes de tempo partilhado interactivos:
wtempo de execução partilhado:
•tempo de execução contínua limitado a um quantum (time-slice)
•lista de processos executáveis é gerida em round-robin
•pode conduzir a tempos de resposta elevados em situações de muita carga
wpreempção:
•primazia ao processo mais prioritário
•indispensável em sistemas de tempo real
•despacho é chamado na sequência de todas as acções susceptíveis de modificarem os
estado dos processos
Page 17
wmultilista:
•usado em sistemas mistos de tempo partilhado (gestão circular) e tratamento por lotes
(gestão baseada na menor duração do trabalho)
•utilização de várias listas consoante o tipo de processos em execução
(fundamentalmente segundo o nível de interactividade)
•despacho escolhe sempre um processo da lista mais prioritária
wprioridades dinâmicas:
•ajuste da prioridade de acordo com o consumo de recursos (fundamentalmente tempo
de CPU)
•processos apenas numa lista que é ordenada em função das prioridades
wquantum variável:
•adaptar o valor do quantum ao comportamento dos processos
•aumentar o valor do quantum quando o sistema está muito carregado (limitar o custo
dos context-switch e aumentar a probabilidade do processo terminar)
•complexidade acrescida no sistema operativo
Gestão Multilista
lista de maior
utiliza o processador
prioridade (menos
processador usado)
utiliza o processador
lista de
menor
prioridade utiliza o processador
Page 18
Gestão Multilista com Quantum Variável
Prioridade Máxima tcpu = 0,02 s
Prioridade Média tcpu = 0,25 s Despacho
Prioridade Mínima tcpu = 2 s
Função dos Mecanismos de Sincronização

ð aplicações eficientes implica decomposição em vários processos
ð potencialmente melhor desempenho
ð cooperação:
wpermitir a um processo assinalar a um outro o final de uma etapa, de forma a que o
segundo possa prosseguir na execução do algoritmo da aplicação (ex.: reserva de
bilhete de avião)
ð competição por/gestão de um recurso:
wcompetição pela obtenção de um recurso único ou limitado no sistema (o recurso
pode ser um periférico, um ficheiro, zona de memória, etc.)
wbloquear os processos consumidores quando não há recursos
wassinalar a existência de recursos disponíveis quando há processos bloqueados
ð exclusão mútua:
wgarantir a coerência na modificação de variáveis partilhadas (ex., teste e alteração
do valor de uma variável)
Page 19
Exclusão Mútua
ð não-determinismo:
wum processo pode ser interrompido em instantes impossíveis de prever
ð secções críticas:
wconjuntos de instrucções que se devem executar de forma atómica
wdados partilhados devem ser manipulados no interior de secções críticas que
garantam uma exclusão mútua no acesso aos mesmos
ð sincronização:
wcontrolo do não-determinismo entre processos concorrentes
ð mecanismos:
wdirectos: funções que actuam directamente sobre o estado dos processos
windirectos: trincos lógicos e semáforos
Alocador de Memória
livre
livre
livre
livre
pilha com descritores
dos blocos livres
mapa de memória
Page 20
Alocador de Memória (cont.)
funções/dados partilhados por todos os processos!

void devolveMem(char* ptr) {
char* pilha[MAX_PILHA];
if (topo < MAX_PILHA) {

ptr = pilha[topo];
#define MAX_PILHA 100
pilha[topo]= ptr;
char* pedeMem() {
if (topo >= 0) {
char* ptr = 0;
topo--;
topo++;
return ptr;
int topo;
}
}
}
Violação de uma Secção Crítica

ð conjunto de instruções que se devem executar de forma atómica
ð estruturas de dados partilhadas devem ser actualizadas no interior duma
secção crítica que garanta a exclusão mútua no acesso às variáveis
Processo A (devolveMem) Processo B (pedeMem)
Instr. n topo++;
interrupção => despacho seleciona outro processo (B neste exemplo)
Instr. n ptr = pilha[topo];
topo--;
Instr. n+1
Page 21
Exclusão Mútua: solução alg. básica
enum {PRIMEIRO = 1, SEGUNDO}; enum {FALSE, TRUE}; int nProc = PRIMEIRO
void procUm() { void procDois() {
while (TRUE) { /*testar possibilidade de acesso*/ while (TRUE) {
while (nProc == SEGUNDO) ; while (nProc == PRIMEIRO) ;
/* secção crítica */ /* secção crítica */
nProc = SEGUNDO; /*permite acesso ao outro proc.*/ nProc = PRIMEIRO; /*
} }
} }
ð processos comutam explicitamente o direito de acesso à secção crítica

ð um processo pode atrasar indefinidamente a entrada do outro na secção crítica
ð o algoritmo só se aplica a dois processos
ð o processo impedido de entrar fica em espera activa
ð instruções não são indivisíveis
Exclusão Mútua: algoritmo de Dekker

enum {PRIMEIRO = 1, SEGUNDO}; enum {FALSE, TRUE};
int procPrioritario = PRIMEIRO, P1QuerEntrar = FALSE, P2QuerEntrar = FALSE;
void procUm() { void procDois() {
while (TRUE) { while (TRUE) {
P1QuerEntrar = TRUE; /*assinalar tentativa de acesso*/ P2QuerEntrar = TRUE;
while (P2QuerEntrar) { /*verificar disponibilidade*/ while (P1QuerEntrar) {
if (procPrioritario == SEGUNDO) { /*proc. proritario*/ if (procPrioritario == PRIMEIRO) {
P1QuerEntrar = FALSE; /*desistir temporariamente*/ P2QuerEntrar = FALSE;
while (procPrioritario == SEGUNDO); while (procPrioritario == PRIMEIRO);
P1QuerEntrar = TRUE; P2QuerEntrar = TRUE;
} }
} }
/* secção crítica */ /* secção crítica */
procPrioritario = SEGUNDO; procPrioritario = PRIMEIRO;
P1QuerEntrar = FALSE; P2QuerEntrar = FALSE;
} }
} }
Page 22
Algoritmo de Dekker
ð vantagens:
wnão impõe uma sequência de utilização alternada do recurso partilhado
ð desvantagens:
wapenas se aplica a dois processos
wo processo impedido de entrar fica em espera activa
winstruções não são indivisíveis
Exlusão Mútua: algoritmo de Lamport

#define N 10
enum {FALSE, TRUE};
int senha[ N ]; int escolha[ N ];
int compara(int a, int b) { void proc (int i) {
if (senha[a] < senha[b] || int j;
(senha[a] == senha[b] && a < b )) while (TRUE) { /*atribuição da senha*/
return TRUE; escolha[i] = TRUE;
else return FALSE; senha[i] = max() + 1;
} escolha[i] = FALSE;
/*espera até deter a senha de número menos elevado*/
int max() { for (j=0; j < N; j++ ) {
int maximo=0, i; while (escolha[j]);
for (i=0; i < N; i++) while (senha[j] != 0 && compara(j, i));
if (senha[i] > maximo) maximo = senha[i]; }
return maximo; /* secção critica */
} senha[i] = 0;
}
}
Page 23
Soluções Algorítmicas vs.
ð são muito complexas
ð o programador tem uma carga adicional de trabalho
ð instruções de linguagens de alto nível não são indivisíveis
ð o modelo computacional do sistema operativo deve incorporar os
mecanismos necessários à implementação da exclusão mútua:
wé mais simples e mais eficaz
ð mecanismos indirectos:
wtrincos lógicos: variável booleana partilhada por vários processos que indica se
algum deles está numa determinada secção crítica
wsemáforos: variável inteira e fila de espera
ð mecanismos directos:
wfunções que actuam directamente sobre o estado dos processos

while (trinco == TRUE);
void fechar (int trinco) {
void abrir (int trinco) {

trinco = FALSE;
Distribuidor de Memória
trinco = TRUE;
com Trinco
}
}

ptr = pilha[topo];
pilha[topo]= ptr;
fechar(trincoMem);
fechar(trincoMem);
abrir(trincoMem);
abrir(trincoMem);
char* pedeMem() {
if (topo >= 0) {
topo++;
char* ptr = 0;
topo--;
return ptr;
int topo;
}
}
Page 24
Violação da Sincronização com um Trinco
Processo A: void fechar (int trinco) {
void fechar (int trinco) { while (trinco == TRUE);
while (trinco == TRUE); trinco = TRUE;
}
interrupção entre iteracções
rotina de interrupção => despacho void abrir (int trinco) {
trinco = FALSE;
Processo B: }
void fechar (int trinco) {
while (trinco == TRUE);
trinco = TRUE; ð trincos lógicos precisam
} de suporte especial para a
execução da secção crítica sua implementação:
interrupção
rotina de interrupção => despacho wteste e atribuição indivisível
whardware: instrução especial
Processo A:
trinco = TRUE; wsistema: inibição das
} interrupções
wmultiprocessador implica
t execução da secção crítica
gestão do bus
Trinco Lógico (lock)

ð objectivo: indicar se existe algum processo a utilizar a secção crítica
ð variável booleana partilhada por vários processos que indica se
algum deles está numa determinada secção crítica:
wos trincos lógicos precisam de suporte especial para a sua concretização:
•hardware - instrução especial - TSL (Test & Set Lock), Lock, etc.
•sistema - inibição de interrupções.
ð espera activa:
wum processo que tente fechar um trinco já fechado tem de continuar a tentar essa
operação até conseguir
ð sufocação ou míngua (starvation):
wum processo pode ser indefinidamente preterido no acesso a uma região crítica
Page 25
Diagrama de Estados de um Processo
Espera Activa/Starvation
Em
Execução
Seleccionado pelo Bloquear
Despacho
Retirado pelo
Despacho
Não executável
Executável
(bloqueado)
Desbloquear
Semáforo (Dijkstra)
ð um semáforo é constituído por
wuma variável de controlo s e por uma fila de espera (processos bloqueados)
ð que, para além da atribuição inicial, só pode ser modificada através
das primitivas
wesperar(s) = wait(s) = p(s)
wassinalar(s) = signal(s) = v(s)
ð semântica:
ws negativo ou nulo força o bloqueio do processo
ws positivo indica possibilidade de continuar a execução
Page 26
Operações Sobre os Semáforos
void Esperar () {
i = i -1; s <= 0 => bloqueia processo
if (i < 0) {
/* aceder ao descritor do processo em causa, retirar de
execução e colocar na fila de espera do semáforo */ s >0 => processo continua
}
}
void Assinalar () {
i = i + 1;
if (i <= 0) {
/* aceder ao primeiro descritor na fila de espera do
semáforo e transferir para fila de executáveis */
}
}
ð os dados do semáforo são acedidos apenas por funções sistema

ð os dados do semáforo são acedidos em exclusão mútua
Implementação de Semáforos
fechar(trinco) fechar(trinco)
Esperar Assinalar
i = i - 1; i = i + 1;
s <= 0
aceder ao descritor S retirar o descritor do

S i <= 0 ?
i<0? do processo em causa do processo da fila de
espera do semáforo
N
N
retirar o processo de
execução e colocar na colocar o descritor do
fila de espera do semáforo processo na fila dos
s >0 executáveis
abir(trinco) abir(trinco)
Page 27
Implementação de Semáforos (cont.)
void Esperar () {
fechar(trincoSem);
i = i - 1;
if (i < 0) {
/* aceder ao descritor do processo em causa, retirar de
execução e colocar na fila de espera do semáforo */
}
abrir(trincoSem);
}
void Assinalar () {
fechar(trincoSem);
i = i + 1;
if (i <= 0) {
/* aceder ao primeiro descritor na fila de espera do
semáforo e transferir para fila de executáveis */
}
abrir(trincoSem);
}
Comparação de Semáforos e Trincos

semáforos trincos
ð objectivo: ð objectivo:
wprimitivas gerais de sincronização wexclusão mútua de
processos nas primitivas de
sincronização
ð implementação: ð implementação:
wsoftware whardware
ð mecanismos de atraso: ð mecanismos de atraso:
wfila de espera wespera activa
ð tempo de atraso típico: ð tempo de atraso típico:
walguns segundos walguns microsegundos
Page 28
Sincronização com Semáforos
ð exclusão mútua no acesso a regiões críticas:
wsemáforo: ExcMut, inicialmente: ExcMut = CriarSemáforo (1)
wprograma: esperar (ExcMut) ... secção crítica ... assinalar (ExcMut)
ð cooperação:
wpermitir a um processo assinalar a outro o final de uma etapa de processamento
para que o segundo prossiga a execução do seu programa
wrequisito: P1 não passa do ponto L1 antes de P2 chegar a L2
wsemáforo: Cont, inicialmente: Cont = CriarSemáforo (0)
wcódigo de P1: ... esperar (Cont) L1: ...
wcódigo de P2: ... L2: assinalar (Cont) ...
ð gestão de recursos:
wimplementar uma política de gestão de recursos que permita:
•bloquear os consumidores na ausência de recursos livres
•assinalar a existência de recursos livres a consumidores à espera

Distribuidor de Memória
/* semExMut inicializado a 1*/

com Semáforo

ptr = pilha[topo];
pilha[topo]= ptr;
int topo = MAX_PILHA;
assinalar(semExMut);
assinalr(semExMut);
esperar(semExMut);
esperar(semExMut);
char* pedeMem() {
if (topo >= 0) {
topo++;
char* ptr = 0;
topo--;
return ptr;
}
}
}
Page 29
Distribuidor de Memória com
char* pilha[MAX_PILHA]; int topo = MAX_PILHA;

Semáforo (cont.)
/* semMem inicializado a MAX_PILHA */

/* semExMut inicializado a 1*/

assinalar(semExMut);
assinalr(semExMut);
esperar(semExMut);
esperar(semExMut);
assinalar(semMem);
esperar(semMem);
ptr = pilha[topo];
char* pedeMem() {
pilha[topo]= ptr;
return ptr;
topo++;
topo--;
}
Jantar dos Filósofos

ð cinco filósofos jantam esparguete
ð cada filósofo precisa de dois
garfos para comer
ð existe apenas um garfo por 3 2
pessoa (i.e, cinco garfos)
ð os filósofos têm lugar fixo
ð cada filósofo pode usar apenas os
garfos que se encontram à sua 4
1
esquerda e à sua direita
ð os filósofos têm três estados
possíveis: pensar, pensar comer,
0
comer
Page 30
Leitores-Escritores
}
enum {FALSE, TRUE};
}
int nLeitores, leitoresEspera, escritoresEspera;
int emEscrita;
semaforo Mutex, Leitores, Escritores; /* inicializados a 1, 0, 0 */
Paulo Ferreira - INESC/IST

Paulo Ferreira - INESC/IST
}
#define MAX 5
void iniciaLeitura() { void iniciaEscrita() {
void testa (int k) {

int estado[MAX];
Esperar(Mutex); Esperar(Mutex);
return j;
if (emEscrita || if (nLeitores > 0 ||
(escritoresEspera > 0)) { (leitoresEspera > 0) ||
estado[k] = Comer;
int mod (j, max) {

emEscrita) {
leitoresEspera ++;
assinalar (semPriv[k]);
escritoresEspera ++;
Assinalar(Mutex); Assinalar(Mutex);
if (j == MAX) return 0;
Esperar(Leitores); Esperar(Escritores);
if ((estado[k] == pensarComer) &&
if (j == -1) return (MAX-1);

Esperar(Mutex);
semaforo mutex; /* inicializado a 1 */
enum {Pensar, PensarComer, Comer};
Esperar(Mutex);
leitoresEspera--; escritoresEspera --;
(estado[mod(k-1, MAX)] != Comer)) {
}
if (leitoresEspera > 0)
(estado[mod(k+1, MAX)] != Comer) &&
emEscrita = TRUE;
semaforo semPriv[MAX]; /* inicializado a 0 */
Assinalar (Leitores); Assinalar(Mutex);
Page 31
} }
}
nLeitores ++;
Assinalar (Mutex);
}
for(;;) {
void acabaEscrita(){
testa(i);
Esperar(Mutex);
testa(i-1);
testa(i+1);
/* comer */
/* pensar */
void acabaLeitura() { emEscrita = FALSE;

Esperar(Mutex); if (leitoresEspera > 0)
esperar(mutex);
esperar(mutex);
void filosofo (int i) {
Assinalar(Leitores);
assinalar(mutex);
assinalar(mutex);
nLeitores --;
Jantar dos Filósofos - solução
estado[i] = Pensar;
else
esperar(semPriv[i]);
if (escritoresEspera > &&

nLeitores == 0) if (escritoresEspera > 0)
Assinalar(Escritores);
estado[i] = PensarComer;
Assinalar(Escritores);
Assinalar(Mutex) ; Assinalar(Mutex);
} }
62
61
Impasse ou Interblocagem (deadlock)
ð acontece quando as seguintes situações podem ocorrer:
wvários processos tentam aceder em exclusivo a diversos recursos
wos processos mantêm o acesso aos recursos já adquiridos enquanto esperam a
obtenção de acesso a outros
wos recursos não podem ser retirados aos processos que os detêm até serem
completamente utilizados
wexiste uma cadeia circular de processos na qual cada processo possui um ou mais
recursos que são pretendidos pelo processo seguinte
ð soluções:
wprevenção:
•aquisição de vários recursos sempre pela mesma ordem
•caso falhe a aquisição de um recurso, libertar todos os recursos detidos e recomeçar
wdetecção e eliminação forçada de estados de interblocagem
Interblocagem (deadlock)
Processo P1 Processo P2
Esperar(semA)
expira o quantum do processo P1
Esperar(semB)
Esperar(semA)
P2 fica bloqueado
t Esperar(semB)
P1 fica bloqueado
Page 32
Mecanismos de Sincronização Directos
ð funções que actuam directamente sobre os estado dos processos
ð suspensão e reactivação de processos:
wsuspender (IdProcesso)
wacordar (IdProcesso)
ð a capacidade de suspensão é frequentemente utilizada para realizar
mecanismos de atraso que funcionam como uma auto-suspensão:
wadormecer (Período)
ð não é de uso geral:
winterferência com outros utilizadores
widentidade do processo só é conhecida em tempo de execução
Mecanismos de Sincronização Directos
Em
Selecionado Execução
Suspender
pelo
Despacho Bloquear
Preempção Suspender
Não executável
Executável Suspenso
(bloqueado)
Desbloquear Acordar
Suspender
Acordar
Page 33
Controlador de Tarefas
ð processos:
wum processo com funções de relógio - função relogio
wum processo controlador - finção controlador
wNTAR processos, cada um desempenhando uma determinada tarefa - função tarefa
NTAR processos:
controlador tarefa 1 tarefa 2 tarefa i tarefa (i+1)
semPriv semPriv semPriv semPriv semPriv

adormecer
assinalar assinalar
relogio
Controlador de Tarefas (cont.)

define PERIODO 100
int tempo[NTAR]; /* inicializado aleatoriamente */
/* semaforo impulso inicializado a 0 */
/* semaforos iniTarefa[NTAR] inicializados a 0 */
void relogio () { void controlador() { void tarefa (int i) {
for (;;) { for(;;) { for (;;) {
assinalar(impulso); esperar(impulso); esperar (iniTarefa[i]);
adormecer(PERIODO); for (int i = 0; i < NTAR; i++) { /* executa tarefa */
} tempo[i]--; }
if (tempo[i] < 0) { }
tempo[i] = novoIntervalo();
assinalar(iniTarefa[i]);
}
}
}
}
Page 34

Slides Sync 2 PDF

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Slides Sync 2 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Sistemas

Paulo Ferreira - INESC/IST 1

Paulo Ferreira - INESC/IST 2

Paulo Ferreira - INESC/IST 3

Funções Principais de um Sistema Operativo

Paulo Ferreira - INESC/IST 4

Paulo Ferreira - INESC/IST 5

Tratamento por Lotes Rudimentar

Tratamento por Lotes (IBM 7090)

1946 1950 1960 1970 1980

Paulo Ferreira - INESC/IST 6

Paulo Ferreira - INESC/IST 7

Tratamento em Lotes (Batch)

Paulo Ferreira - INESC/IST 8

Paulo Ferreira - INESC/IST 9

Tempo Partilhado e Memória Virtual

Paulo Ferreira - INESC/IST 10

Paulo Ferreira - INESC/IST 11

Paulo Ferreira - INESC/IST 12

Paulo Ferreira - INESC/IST 13

Gestão de Processos Gestão de Memória

Paulo Ferreira - INESC/IST 14

Paulo Ferreira - INESC/IST 15

Processo: abstracção de máquina virtual

Paulo Ferreira - INESC/IST 16

Paulo Ferreira - INESC/IST 17

Estrutura Hierárquica dos Processos

Paulo Ferreira - INESC/IST 18

Paulo Ferreira - INESC/IST 19

Paulo Ferreira - INESC/IST 20

Tempo real de execução dos processos t

Paulo Ferreira - INESC/IST 21

Paulo Ferreira - INESC/IST 23

Funções Sistema (system calls)

Paulo Ferreira - INESC/IST 24

Modo sistema (privilegiado)

Paulo Ferreira - INESC/IST 25

Suporte Hardware para a Realização do SO

Paulo Ferreira - INESC/IST 26

Paulo Ferreira - INESC/IST 27

Lista dos Processos Executáveis

Lista dos Contexto do Contexto do Contexto do

Paulo Ferreira - INESC/IST 28

Paulo Ferreira - INESC/IST 29

Paulo Ferreira - INESC/IST 30

Paulo Ferreira - INESC/IST 31

Paulo Ferreira - INESC/IST 33

Políticas de Escalonamento (2)

Paulo Ferreira - INESC/IST 34

Paulo Ferreira - INESC/IST 35

Paulo Ferreira - INESC/IST 36

Prioridade Média tcpu = 0,25 s Despacho

Prioridade Mínima tcpu = 2 s

Paulo Ferreira - INESC/IST 37

Função dos Mecanismos de Sincronização

Paulo Ferreira - INESC/IST 38

Paulo Ferreira - INESC/IST 39

Paulo Ferreira - INESC/IST 40

funções/dados partilhados por todos os processos!

if (topo < MAX_PILHA) {

Violação de uma Secção Crítica

Processo A (devolveMem) Processo B (pedeMem)