Sistemas_Operacionais_Parte4

Sistemas Operacionais

Faculdade de Informática - PUCRSProf. Celso Maciel da Costa

2

Introdução

3

Sistemas operacionais– O que são?

» programas que controlam todos os recursos do computador e fornecem a base para o desenvolvimento dos programas de aplicação

– O que fazem?» virtualizam os recursos de hardware

» gerenciam os recursos de hardware

Introdução

4

Partes básicas de um sistema– hardware

– sistema operacional

– programas de aplicação

– usuários

Introdução

5

Introdução

Tipos de Sistemas Operacionais– Batch

– Time sharing

– Tempo real

– Distribuídos

– Paralelos

6

Introdução

Primeiros Sistemas – Totalmente manuais

Sistemas Operacionais Batch– Evolução dos sistemas iniciais (seqüenciamento

automático de jobs, multiprogramação,..)

– Normalmente possui como entrada uma seqüência de jobs a serem processados

– O resultado do processamento é uma saída, normalmente impressa

7

Monitor

usuário

Sistemas monoprogramados

Introdução

8

SO

usuário1

usuário2...

Sistemas multiprogramados

Introdução

9

Sistemas multipro-gramados

Introdução

Sistemas monoprogramados

10

Introdução

Sistemas Operacionais Batch(cont.)– Grande problema:

» O usuário não interage com o sistema

» O programa é preparado e encaminhado para execução

» Os resultados poderão demorar (minutos, horas, ...)

– A idéia básica é a de centralização do processamento em CPD’s

– A tendência atual é para a distribuição

11

Introdução

Sistemas Operacionais Time Sharing » Surgiram no início dos anos 60

» Se tornaram populares nos anos 70

» Existe uma comunicação on line entre o usuário e o sistema

» O usuário submete requisições ao sistema, e recebe as respostas imediatamente

» A interação é feita com o uso de terminais

» O sistema possui um Interpretador de Comandos, que lê a linha de comando contendo o nome do programa a ser executado

12

Introdução

Sistemas Operacionais Time Sharing (cont.)– Após a execução de um comando, o

Interpretador de Comandos volta a ler o terminal

– O usuário imediatamente compila e executa o seu programa

– Muitos usuários compartilham o uso do computador

13

Introdução

Sistemas Operacionais de tempo Real– Usados para controlar um dispositivo em uma

aplicação dedicada

– Sensores coletam dados que são enviados ao computador

– Os dados são analisados e são enviados sinais de resposta

– Em muitas aplicações o tempo de resposta é vital

14

IntroduçãoSistemas Operacionais Distribuídos

» Avanço tecnológico (microprocessadores, tecnologias de redes rápidas,..) aproximou as máquinas paralelas e as redes de computadores

» Um SOD é formado por um conjunto de nodos (processador/memória/periféricos?), sendo que em cada nodo existe um núcleo de sistema operacional)

» A comunicação entre os diferentes nodos se faz por troca de mensagens (ambientes sem compartilhamento de memória) ou por operações read remoto e write remoto (com memória virtual compartilhada)

15

Introdução

Sistemas Operacionais Distribuídos x Paralelos

» Distribuídos: Projetados para muitos usuários trabalharem conjuntamente (compartilhamento de recursos)

» Paralelos: Possui como objetivo obter velocidade na resolução de um único problema

16

IntroduçãoVisão Esquemática do funcionamento de um SO

SO

Usuário

Hardware

Chamadas de sistema

Interrupções

17

Organização de Sistemas Operacionais

18

Organização dos SO

Principais funções– Gerência de Processos

– Gerência de memória

– Escalonamento

– Gerência de recursos (contabilização)

– Proteção (controle de acesso)

19


MonolíticosO SO é organizado como uma coleção de processos seqüenciais cooperantes, que recebem as solicitações dos usuários (chamadas de sistema), as executam e devolvem um resultado

Usuário Usuário

rotina---------

...

20

Organização dos S.O.

Hierárquica– o sistema operacional é organizado como uma

hierarquia de níveis

– Ex. THE, construído pelo Dijkstra em 1968

21

Organização dos S.O.

Máquinas virtuais– o kernel do sistema implementa não a

multiprogramação, mas máquinas virtuais

– Ex. VM/370 da IBM

22

Micro Kernel• Modelo cliente/servidor

• Clientes (programas de aplicação) solicitam serviços

• Os serviços são implementados num nível acima do kernel, por servidores

usuario

resposta

kernel

serviço

...servidor usuario servidor


23

Windows NT

Micro kernelBaseado no modelo cliente/servidorSubsistemas de ambientes (Servidores)Executivo

24

Windows NT

Subsistemade Ambientes

(Processos Servidores)

Modo Usuário

Modo Kernel

ClienteOs/2

ServidorOs/2

ClientePOSIX

ServidorPOSIX

ClienteWin32

ServidorWin32

EXECUTIVO

25

Windows NT

Servidores– Subsistemas protegidos

– Processos independentes

– Cada um com sua própria memória

– Comunicação por troca de mensagens (LPC)

– Cada subsistema fornece uma API específica de um SO

– Servidores: POSIX, OS/2, DOS, Win16, Win32

26

Windows NT

Servidor Win32– Torna disponível aos usuários a API win32

– Fornece a interface gráfica do NT

– Controla as entradas e saídas do Win32

– Controla as entradas e saídas dos demais servidores

27

Windows NT

Executivo– É o kernel do sistema NT

– Funções:» Gerenciar de objetos

» Gerenciar processos

» Implementar LPC

» Gerenciar memória

» Tratar interrupções, escalonar processos

» Gerenciar I/O

28

Arquitetura do Sistema

29

Minix

Compatível com Unix V7Escrito em CRoda em PCEscrito por Tanenbaum

30

Estrutura interna do Minix

Init user user ...

MM

disktask

TTYtask

clocktask

systemtask

Process management

...

FS NetS

31

Unix

Visão Geral– Arquitetura

– Shell– Sistema de Arquivos

– Núcleo

32

Unix

Shell

núcleo

hardware

33

Unix - Arquitetura do Sistema

Biblioteca

Interface

Comunicação

Hardware

Sub-sistema

de gerência

de processos

Sub-sistema de arquivos

Scheduling

Ger. MemóriaDrivers

Cache

Carac. Blocos

Programas

Nível Núcleo

Nível Usuário

34

Revisão de Aspectos Básicos

35

Revisão de Aspectos Básicos Interrupções

Interrupções– permite que módulos interrompam processamento

normal do processador» gerado pelo programa

divisão por zero, referência a memória fora do espaço permitido, etc.

» timer» entrada e saída - sinalização de final de operação de E/S ou

condição de erro» falha de hardware

36

Funcionamento geral de um periférico

while ( true ){

receber ordem da CPUexecutar a ordemsinalizar a CPU

}

- os periféricos sinalizam a CPUcom o mecanismo de interrupção


Tipos de interrupções– externas ou internas

Externas– Originadas por periféricos ou eventos exteriores

(tempo real)

37


Internas– relógio

– erro

– software (chamada do sistema)

Relógio – permite a gerência do tempo pelo sistema

operacional» scheduling» disparo de um programa em um tempo determinado» contabilidade

38


Erro– overflow– violação de memória– instrução inválida– etc.

Software– instrução especial (int, trap, ...)– o programa para de executar– o sistema operacional começa – a executar o serviço solicitado pelo programa

39


Processamento de interrupções– dispositivo interrompe processador

– processador acaba execução da instrução atual

– processador testa existência de interrupção

– transferência de controle» processador salva estado atual

» carrega contador de programa com endereço da rotina de tratamento

» transfere controle para a rotina de tratamento

– rotina de tratamento executa … acaba

– restaura estado anterior

– retorna a execução da rotina interrompida

40

IntroduçãoVisão Esquemática do funcionamento de um SO

SO

Usuário

Hardware

Chamadas de sistema

Interrupções

41

Funções de um Sistema Operacional

42

Gerência de processos

Gerência de memória

Gerência de I/O

Gerência de Arquivos

Sistema de Proteção

Comunicação

Interpretador de Comandos

Funções de um SO

43

Gerência de processos– processo é um programa em execução

– entidade ativa, tem um program counter associado

– um processo executa sequencialmente até sua terminação

– dois processos podem estar executando mesmo programa -duas sequencias independentes de execução

– sistema consiste de coleção de processos» alguns do SO, outros do usuário

» processos executando de maneira concorrente, disputando CPU

Funções de um SO

44

Gerência de processos SO é responsável por– criação e deleção de processos

– suspensão e retomada de processos

– prover mecanismos para sincronização de processos

– prover mecanismos para comunicação de processos

– prover mecanismos para tratar deadlock

Funções de um SO

45

Gerência de memória– programas são carregados em memória, executando em

processos

– para maximizar o uso de CPU, vários processos são mantidos em memória, chaveando o contexto entre eles

– Sistema operacional deve» controlar quais regiões de memória são utilizadas e por qual processo

» decidir qual processo deve ser carregado para memória, quando espaço for disponível

» alocar e desalocar espaço de memória

Funções de um SO

46

Gerência de I/O– SO deve “esconder” as peculiaridades de

dispositivos de hardware específicos

– device drivers para os dispositivos específicos fazem parte do SO

– atividades» instalação e desinstalação lógica de dispositivo

» leitura, gravação

Funções de um SO

47

Gerência de Arquivos– oferece a abstração de arquivos (e diretórios)

– atividades suportadas» criação e deleção de arquivos e diretórios

» primitivas para manipulação

» mapeamento para memória secundária

Funções de um SO

48

Sistema de Proteção– controla acesso de processos ou usuários aos

recursos do sistema» proteção de memória, CPU, operação dual

» controle de acesso

Funções de um SO

49

Comunicação remota– facilidades para envio/recepção e protocolos de

comunicação

– atividades» criar, deletar conexões

» mandar e receber mensagens

Funções de um SO

50

Interpretador de Comandos– interface com o usuário

» modo textointerpretador de linha de comando

shell do unix

» gráficomachintosh

windows

Funções de um SO

51

Chamadas de Sistema

52

interface entre o programa que está executando e o sistema operacional– funções do SO disponíveis aos programas

geralmente implementadas com o uso de instruções de baixo nível

Chamadas de sistema

53

Controle de processos– criar, terminar

– carregar, executar

– espera por evento, sinalização

– espera tempo

– alocar e liberar memória

Chamadas de sistema

54

Manipulação de arquivos– criar, deletar

– abrir, fechar

– ler, escrever

– posicionar

Chamadas de sistema

55

Manipulação de dispositivos– alocar dispositivos, liberar dispositivo

– ler, escrever

Manutenção de informação do sistema– e.g.: ler, setar a hora

Comunicação– criar, deletar canais de conexão

– transferir informação

Chamadas de sistema

56

execução emmodo usuário

chamada de sistema retorno

execução emmodo núcleo

bloqueio

desbloqueiopronto

selecionado

Transição de estados de um processo em uma chamada de sistema

57

Programa………read ( fd, $b, 20)

Biblioteca

read ( int fd, char *b, int l ){

msg m;m->td = fd;m->b = b;m->l = l;m->op = READ;move m, regA;trap #12;

}

58

do_read

do_read: desabilitar intsalvar contexto…

Vetor interrupções

59

divididas em dois grandes grupos:– controle de processos, manipulação de arquivos

Chamadas de sistema - Unix

Biblioteca

Interface

Comunicação

Hardware

Sub-sistema

de gerência

de processos


Scheduling


Cache

Carac. Blocos

Programas

Nível NúcleoNível Usuário

60

Manipulação de arquivos

. open . pipe

. close . link

. read . unlink

. write . lseek

. create

Chamadas de sistema - Unix

61

Chamadas de sistema - UnixControle de processos

. fork

. wait

. exit

. exec

. kill

. signal

62

Chamadas de sistema

Implementação– Depende do computador

– Exemplo:» instrução especial transfere o controle para o SO

» chamada de uma rotina especial para executar o serviço

63

Chamadas de sistema

Passagem de parâmetros– através de registradores

» Problema: o número de parâmetros é limitado ao número de registradores

– através de um bloco de memória» o endereço do bloco de memória é passado em um

registrador

64

Processos Concorrentes

65

Em sistemas com multiprogramação

– uso da CPU compartilhado entre os diferentes programas

– ilusão de paralelismo ( pseudo-paralelismo)

um processo é um programa em execução, incluindo os valores dos registradores, o valor do PC, o valor das variáveis, etc.

cada processo tem sua própria CPU virtual


66

running

ready blockedevento

interrupção

selecionado

Grafo de transição de estados de processos

67

Escalonamento

Filas de escalonamento– Sistemas Uniprocessador

um processo running

demais processos aptos a executar esperam pela CPU

» fila ready: contém os processos aptos a rodar

» filas de dispositivos: contém os processos esperando I/O

» filas de eventos: contém os processos bloqueados a espera de eventos (ex. passagem de tempo)

68

Escalonamento

Filas de escalonamento(cont.)

– Sistemas multiprocessadores» memória comum

Uma única fila de processos aptos à rodar;

Uma fila para cada processador;

» memória distribuídauma fila em cada processador

69

Exemplos de Implementação de Filas

First

Last

Desc5

First

Last

Desc0 Desc9

Desc7 Desc13

Desc12Last

First

Ready:

Disco0

Disco1

70

Process Control BlockRepresentação de um processo para o SO:– estado do processo: ready, running, blocked ...

» Estado também pode ser representado através da fila em que o processo se encontra

– program counter

– registradores da CPU

– informação de esclonamento: depende do algoritmo - prioridades, ponteiros para filas ...

– Informação para gerência de memória: valor de registradores base e limite, páginas, ...

– Informação de contabilização: tempo de CPU utilizada, limites, ...

– informação de estado de I/O: lista de dispositivos alocados ao processo, arquivos abertos, ...

71

Escalonamento da CPUMultiprogramação– Vários programas na memória

– CPU compartilhada pelos mesmos

– A execução de um programa é uma seqüência de execução e espera por I/O

– Quando o programa faz I/O a CPU é entregue a outro programa

Escalonamento – É a troca da CPU entre os vários programas na

memória prontos para executar

72

EscalonadoresImplementam a Política de Escalonamento– Escalonadores de Longo Termo

» Sistemas Batchprogramas submetidos são armazenados em disco

o escalonador de Longo Termo seleciona programas do disco e os carrega na memória para execução

Não existem em sistemas interativos (Unix, Dos, Windows, ...)

– Escalonadores de Pequeno Termo (Escalonadores da CPU

» seleciona um processo, entre os aptos, e o dispara

– Diferença: Freqüência de execução

73

Escalonadores

Dispatcher– Entrega a CPU para o processo selecionado

pelo Escalonador de Pequeno Termo (Escalonador da CPU)

» carrega os registradores gerais (da pilha, do descritor,..) nos registradores de máquina

» carrega o Program Counter (dispara a execução)

74

Algoritmos de Scheduling

Critérios para escolha de algoritmos– utilização de Cpu: mantê-la ocupada o máximo de

tempo possível

– No. de jobs executados por unidade de tempo (throughput) (Ex. jobs grandes => 1 por hora, jobspequenos => muitos por segundo)

– tempo ocorrido desde a submissão de um job até seu término (turnaround time) (geralmente limitado por i/o)

75


Critérios para escolha de algoritmos. (cont.)– tempo de espera (waiting) (tempo na fila

ready)

– tempo de resposta (sistemas interativos) (tempo de turnaround pode não ser o melhor critério)

76


Objetivos de um algoritmo.– maximizar utilização da CPU

– maximizar No. de programas executados por unidade de tempo

– minimizar tempo de turnaround

– minimizar tempo de resposta (melhor minimizar a variância do que a média em sistemas time-sharing)

77


Algoritmo 1: First-Come-First-Served– “Primeiro processo que requisita a CPU é o

primeiro que a recebe”» 1. Processo pronto para executar entra no final

da lista ready» 2. Quando a CPU é liberada é alocada para o

primeiro da lista

78


Algoritmo 1: First-Come-First-Served

Ex.: Job Tempo1 242 33 3

Chegada: 1, 2, 3Job2 Job3Job1

0 24 27 30

79



Job 1 : 24Job 2 : 27Job 3 : 30

Tempo de turnaround

Média : (24+27+30) = 27

1 Job CPU boundMuitos Jobs I/o bound

Baixa performance.

80



Job 2 Job 3 Job 1 ??

Como seria o tempo de turnaround para chegadas:

Média: ?

E o waiting time ?

81


Algoritmo 1: First-Come-First-Served– CPU Bound prende a CPU– Todos os outros Jobs tem seu I/O completado e

esperam na fila ready– enquanto esperam, dispositivos estão desocupados– CPU Bound requisita I/O– os outros Jobs executam rapidamente, requisitam

I/O– CPU Bound recebe o processador

– particularmente problemático para sistemas time-sharing

82


Algoritmo 2: Shortest-Job-First– Associa a cada processo o seu próximo tempo de

ocupação de CPU– Quando a CPU esta livre é atribuída ao processo

com o menor tempo de CPU

Ex.:Processo Próximo tempo

1 62 83 74 3

Proc4 Proc1 Proc3 Proc2

0 3 9 16 24. Executando processos pequenos antes diminuimais seus tempos de espera do que aumenta os tempos de espera dos processos grandes

83


Algoritmo 2: Shortest-Job-First– waiting time: 7– waiting time se fosse FCFS: 10.35

84


Algoritmo 2: Shortest-Job-First– Problema do SJF

» Determinar próximo tempo de CPU para cada processo

Sistemas Batch (Long Term Scheduler)Tempo limite do processo

Scheduling da CPU (Short Term)?

Estimar o tempo

85


Algoritmo 2: Shortest-Job-First– Determinar próximo tempo de CPU para

cada processo

– estimar tamanho do próximo cpu burst com base nos tempos passados de cpu

τn+1 = α tn + (1-α) τn

» tn : último tempo de cpu amostrado

≈ τn : último valor previsto

≈ τn+1 : valor previsto para próxima vez

≈ α : fator de peso entre amostrado e passado

86


Algoritmo : baseado em Prioridades– cada job tem uma prioridade associada

– cpu alocada ao job de maior prioridade

– caso de prioridades =s, adota FCFS

– SJF é um caso especial» onde burst de cpu estimado é o inverso da

prioridade

87


Algoritmo : baseado em Prioridades» existe um campo de variação (0..7), (0..N)» Alguns sistemas 0 é a maior, outros 0 é a menor » podem ser internas ou externas

internas: espaço de memória necessária arquivos abertos, etc. (Ex.: sistema Pascal)externas: externas ao sistema operacional Ex.: tipo do programa, tamanho, fatores políticos, etc.

88


Algoritmo : baseado em prioridades– e processos de baixa prioridade

– Problemas ?

89


Algoritmo : baseado em prioridades– Problemas: postergação indefinida

– Solução: de tempos em tempos incrementar a prioridade do processo.

– Ex.: de prioridades (0.. 127) => mais alta

– incrementar um processo com prioridade 0 de 1 a cada 15 minutos ==> 32 horas para rodar

90


Algoritmos Preemptivos. – FCFS, SJF, prioridades:

» não preemptivos, como descritos

» processo somente perde o processador quando termina ou quando requisita I/O

– Questão: que fazer quando chega na fila ready um processo com prioridade maior do que o que está rodando?

91

Algoritmos de Scheduling“Preemptar ou não Preemptar”.– Preemptar:

» um processo chegando na fila ready tem sua prioridade comparada com a do processo que está rodando.

» se for maior: ganha a cpu» se for menor: fica na fila

– Em sistemas time-sharing o Scheduler deve ser peemptivo ou não?

» Resposta: Sim, para evitar que um processo possa prender a CPU por muito tempo.

92


“Preemptar ou não Preemptar”.– Ex.: de Preempção (SJF)

Processo Chegada Tempo1 0 82 1 43 2 94 3 5

preempção0

proc

1

2 4 1 3

1 5 10 17 26

93

Algoritmos de scheduling

– Ex.: de Preempção (SJF) (cont.)» Tempo médio de execução:

processo 1 17 - tempo de chegada (0) = 17




tempo médio = (17+4+24+7)/4 = 13

94


Ex.: Sem Preempção (SJF) (cont.)

(8-TC)+(12-TC) +( 26-TC) + (17-TC) onde TC=tempo de chegada

1 2 4 3

0 8 12 17 26

(8+11+24 + 14)/4 = 57/4 = 14.25

95

Round-Robin:– Sistemas time-sharing– quantum ou time slice (10-100 miliseg.)– lista ready é uma fila circular


Ex.:processo tempo

1 242 33 3

Time-slice:4

1 2 3 1 1 1 1 1

4 7 10 14 18 22 26 30

Média: 47/3 ~16

96


Round-Robin– Overhead: salvamento de contexto depende

de :» velocidade de memória» número de registradores» existência de instruções especiais: ex. mover

todos os registradores

– tempo típico: 10-100 microsegundos

97


Round-Robin– Quantum: 12 unidades

– tempo de execução do processo: 10 unidades

NÃO TEM OVERHEAD

- Quantum de 6 unidades- Tempo de execução: 10 unidades

1 TROCA DE CONTEXTO

Quantum muito grande ==> FCFS

98


Múltiplas filas – processos são classificados em grupos

– uma fila para cada grupo

– cada fila pode ter seu próprio algoritmo

– cada fila pode ter prioridade absoluta sobre as demais filas com prioridades menores

– alternativa: haver um slice entre as filas

99

Algoritmos de scheduling

Múltiplas filas com reavaliação– os processos se movem entre as filas

– parâmetros: » no. de filas

» método para aumentar processos nas filas

» método para diminuir processos nas filas

» método para determinar em que fila o processo deve entrar

100

Scheduling no sistema Pascal Concorrente

três filas de prioridades– alta: prioridade 0

– média: prioridade 1

– baixa: prioridade 2

prioridade 2: qdo. o processo é criado

prioridade 1: qdo. o processo pede I/O

prioridade 0: qdo. o processo pede acesso a um monitor

UNIX

Scheduling

102

UNIX - Diagrama de Estados de Processo

103

Estados de processos no UNIX

Criação de um processo:– processo pai executa fork

– filho é criado e entra no estado created

– quando decidido sobre sua alocação entra no estado ready to run, em memória ou swaped

104


Criação de um processo:– processo 1, init, é criado no início do sistema

– quando um usuário interativo entra no sistema, o processo init cria um processo para tratar do usuário

– este processo do usuário atende os pedidos do usuário, criando outros processos

105


Escalonamento do processo recém criado:– escalonador escolhe processo para executar

– processo escolhido sai de ready to run e passa para kernel running

– processo acaba processamento da chamada forkfeita pelo pai

– retorna para o modo user running

– prossegue execução

106


Chamada de sistema:– quando processo executa chamada de sistema

» sai do modo user running e passa para kernel running

» no caso de pedido de IO processo entra no modo asleep

– quando IO está pronto» interrupção acontece e o processo bloqueado é

passado para ready to run

» antes de retornar a user running, o processo interrompido pode perder o processador (ser preemptado)

107


Interrupção e preempção:– relógio do sistema pode interromper, ou IO fica

pronto e interrompe

– o processo entra no modo kernel running

– o tratador de interrupções acaba o tratamento da mesma

– antes de retornar para user running,núcleo pode preemptar o processo em favor de outro com maior prioridade

– primeiro processo entra no modo preempted(mesmo que ready to run)

108


Preempção:– só pode acontecer quando o processo está para

retornar para user running

– chamada de sistema de um processo (kernelrunning) não pára no meio em favor de outro processo

– como algumas chamadas de sistema são “pesadas” - o sistema não é adequado para tarefas tempo real

109


Saída de processo:– quando processo completa, ele faz chamada de

sistema exit

– processo passa para kernel running e então para zombie

– eventos externos podem indicar que processo tem que sair (exit)

110

Scheduling no UNIX

Round robin com múltiplos níveis e feedback

vários níveis de prioridades

níveis básicos:– kernel

– usuário

estes são ainda subdivididos

111

Scheduling no UNIX

Níveis do kernel– prioridades altas, não interrompíveis

» processos não perdem CPU por tempo (preemptados)

» ex.:swaper, waiting for disk IO, waiting for buffer, waiting for inode,

– prioridades baixas, interrompíveis» ex.: waiting for tty input, …output, waiting for child

exit

Níveis do usuário– user level 0, …, user level n

112

Scheduling no UNIX

Política:– políticas normais: fairness

– incentivar a liberação de recursos

113

Scheduling no UNIX

Política de prioridades para processos no modo núcleo– associa prioridade ao processo antes de ir para

estado asleep

– relaciona valor fixo de prioridade à razão do processo ir para asleep

– quando processo é escalonado » considera a prioridade do modo kernel

» entra em kernel running

» quando passa para user running, restaura prioridade do processo para modo usuário

114

Scheduling no UNIX

Política de prioridades para processos no modo núcleo– níveis de prioridade

» associados de forma que maior prioridade dada a processos com maior probabilidade de liberar recursos

» evitar gargalos no sistema

115

Scheduling no UNIX

swapper

Waiting for disk io

Waiting for buffer

Waiting for inode

Não interrom-

píveis

Waiting for tty input

Wait for tty output

Wait for child exit

Waiting for inode

Interrom-píveis

User level 0

User level 1

…

User level n

prio

rida

de

Priori-dades

no modokernel

Priori-dades

no modousuário

Níveis de prioridades Processos

116

Scheduling no UNIX

Política de prioridades para processos no modo usuário– em cada segundo, clock interrompe 60 vezes

– contador de uso de CPU é incrementado a cada vez

– a cada segundo:» ajusta o uso recente da CPU

decay(CPU) : uso de CPU = uso de CPU/2

recalcula prioridades dos processos ready to run

– priority = uso de CPU/2 + prioridade base do processo de usuário

117

Scheduling no UNIXPriority CPU

60 012…60

75 30

3067 15

63 789..67

76 33

68 16

Priority CPU

60 0

60 012...60

75 30

67 15

63 789…67

76 33

Priority CPU

60 0

60 0

60 012…60

75 30

67 15

63 7

Proc A Proc B Proc C

118

Scheduling no UNIXPriority CPU

60 012…60

75 30

3067 15

63 789..67

76 33

68 16

Priority CPU

60 0

60 012...60

75 30

67 15

63 789…67

76 33

Priority CPU

60 0

60 0

60 012…60

75 30

67 15

63 7

Proc A Proc B Proc C

decay

60 + CPU/2

60 + CPU/2

decay

119

Scheduling no UNIX

Extensão: Fair share Scheduler– Dividir capacidade computacional da máquina

– Grupos» processos pertencem a grupos

» além de contabilizar uso da CPU por processo, contabiliza por grupo

decay(CPU) : uso de CPU = uso de CPU/2

decay(Group) : uso de CPU do grupo = uso de CPU do grupo/2

recalcula prioridades dos processos ready to run

– priority = uso de CPU/2 + uso de CPU do grupo /2+ prioridade base do processo de usuário

120

Scheduling no UNIXPriority CPU Group

60 0 01 12 2… ...60 60

90 30 30

74 15 1516 1617 17… ...75 75

96 37 37

78 18 1819 1920 20… ...78 78

98 39 39

Priority CPU Group

60 0 0

60 0 01 12 2… ...60 60

90 30 30

74 15 151617...75

81 7 37

70 3 18

Priority CPU Group

60 0 0

60 0 012...60

75 0 30

67 0 151 162 17… ...60 75

93 30 37

76 15 18

Proc A Proc B <- mesmo grupo -> Proc C

MINIX

Scheduling

122

Processos

Process management

Init

Memorymanager

Disktask

Userprocess

Filesystem

Ttytask

Networkserver

Clocktask

Userprocess

Userprocess

Systemtask

Ethernettask

...

...

...

Layer

User processes

Server processes

I/O tasks

3

2

1

4

Kernel

123

Scheduling

Rdy_head Rdy_tail

USER_Q USER_Q

SERVER_Q SERVER_Q

TASK_Q TASK_Q

2

1

0

2

1

0

3 5 4

FS MM

Clock

124

Scheduling

TASK_Q– fila de prioridade máxima

– o(s) processo(s) não perdem o processador por tempo.

125

SERVER_QFila de prioridade média na qual executam os servidores do sistema. Os processos nesta fila não perdem o processador por tempo.

Scheduling

126

USER_Qfila de prioridade mais baixa na qual executam os processos dos usuários. O algoritmo usado nesta fila é o round-robin.

Scheduling

127

proc.c - Principais funções

void pick_proc()– decide qual processo deverá ser executado no

momento. Percorre as filas de processos a procura de um processo a ser executado conforme a prioridade.

128

void ready(struct proc *rp)•adiciona o processo rp em uma das filas de processos para torná-lo runnable. •Esta função verifica em qual fila o processo se encaixa e adiciona-o no final da fila correspondente.


129

void unready(struct proc *rp)•retira o processo rp da sua fila de processos. •Esta função descobre a qual fila pertence o processo rp, procura-o na fila e retira-o, tirando a sua condição de runnable.


130

void sched()•escalona a fila de processos do usuário. •esta função retira o processo indicado pela rdy_head na fila de processos de usuário, •faz com que rdy_head aponte para o próximo processo e •aloca o processo anterior (rodando) no final da fila do usuário.


131

void sched()

USER_Q USER_Q

rdy_head rdy_tail

3 5 4

USER_Q USER_Q

rdy_head rdy_tail

5 4 3

.

.

.

.

.

.


132

Multiprocessor Scheduling

Sistemas multiprocessadores– fracamente acoplados, ou clusters

» cada sistema tem memória própria e canais de IO

– processadores especializados» como processadores de IO

» existe um processador mestre de propósito geral que controla os escravos

– processadores fortemente acoplados» conjunto de processadores que compartilham

memória principal sob controle integrado de um sistema operacional

133


Fortemente acoplados - homogeneos – tratar processadores como recurso conjunto e

associar processos a processadores sob demanda

– associação estática ou dinâmica» estática: processo roda no mesmo processador

» dinâmica: em diferentes CPU burts processo pode ocupar diferentes processadores

134


Abordagens mestre-escravo e pares– mestre escravo:

» funções do kernel rodam sempre em um processador

» outros processadores rodam só processos de usuário

» mestre faz escalonamento

» se escravo precisa serviço (chamada de sistema), faz pedido ao mestre

» desvantagens:mestre pode ser gargalo de desempenho

falha do mestre pára sistema

135


Abordagens mestre-escravo e pares– pares:

» SO executa em qualquer processador

» cada processador faz escalonamento para si da fila ready comum

» mais complicado:garantir que dois processadores não escolham mesmo processo

sincronização no acesso a estruturas comuns

136


137


Processos pesados – Processos tradicionais

– Possuem uma thread inicial que começa a sua execução (ex. main de um programa C)

– Normalmente carregados do disco para execução

– Executam um código seqüencial

138

Controle de Processos

Processos leves (threads)– Criados para permitir paralelismo

– cada um roda um código seqüencial

– Possuem sua própria pilha de execução e o seu próprio programcounter

– Compartiham o uso do processador

– Podem criar processos (threads) filhos

– Compartilham o mesmo espaço de endereçamento (dados globais)

– Podem estar em um dos estados ready, running, blocked

139


Hierarquia de processos– um grafo de processos é uma árvore cujos

nodos correspondem a um processo» uma aresta de um nodo Pi para um nodo Pj significa

que Pj foi criado por Pi

» Pi é o pai de Pj

» Pj é filho de Pi

» cada processo possui um pai, exceto o inicial (ancestral)

» cada processo pode ter muitos filhos

140

P1

P2 P3

P4 P5 P6

Árvore de processos


141


Operações em processos– criação de processos

» possibilidades de execução:o pai executa concorrente com o filho

o pai espera que o filho acabe

» possibilidades de compartilhamento de dadospai e filho compartilham todas as variáveis

pai e filho compartilham um subconjunto das variáveis do pai

142


Exemplos – UNIX

» filho é duplicata do pai

» execução concorrente de pai e filho

– DEC VMS» carga de código do novo processo na criação

– NT» ambos modelos

143


Término de processos– um processo termina quando acaba a execução

de seu último comando» pede ao SO para removê-lo com a chamada exit

– em circunstâncias especiais um processo pode acabar antes de executar o seu último comando

– um processo pode causar a morte de outros processos com primitivas especiais

144


abort (id), kill (id)– id é a identificação do processo à terminar– abort e kill são chamadas pelo pai do processo

id– para poder matar, o pai necessita conhecer a

identidade do filho, que retorna na operação de criação.

– id = fork()» retorna em id a identificação do processo criado

145

Especificação de Concorrência

Construções fork e join– Connway 1963

– Dennis e Van Horn 1966

– primeiras notações de linguagem para especificar concorrência

146


P0

fork

P1 P2

Construção fork

147


P1 ;fork l ;..

l: p3 ;

- fork produz duas execuções concorrentes no programa- uma começa no rótulo “l”- a outra continua no comando seguinte ao fork- divide uma computação em duas independentes

FORK

148

Especificação de ConcorrênciaJOIN

– combina várias execuções concorrentes em uma

– cada execução deve requisitar um join com as demais

– algumas computações terminam antes de outras

– as que executa o join antes terminam, a última continua

– existindo três computações, as duas primeiras terminam, enquanto à última é permitido continuar

– join tem um parâmetro que especifica o número de computações

– deve ser executada atomicamente

149


join com parâmetro

count = count - 1 ;if count != 0then quit ;

150


Exemplo:s1

s2 s3

s4

s5 s6

s7

Grafo de precedência de execução dos comandos s1 a s7

151


s1;count = 3 ;fork l1 ;s2 ;s4 ;fork l2 ;s5 ;go to l3 ;

l1: s3 ;go to l3 ;

l2: s6 ;go to l3 ;

l3: join count ;s7 ;

Exemplo de programa usando fork/join

152

Especificação de ConcorrênciaFork no sistema Unix– Forma: id = fork() ;

– Duplica o processo que executa a chamada

– Ambos executam a instrução seguinte à chamada de sistema

– Id, no retorno da chamada, contém no processo pai, o identificador do processo filho criado

– Para o processo filho o valor da variável id será zero

– Pode-se selecionar o trecho de código que será executado pelos processos com o comando if

– Não existe o comando join (a sincronização é feita com wait())

153

Exemplo de programa com forkno Unix

main() {

int id ;

id = fork () ;if (id != 0) {

printf(“Eu sou o pai\n”) ;

wait(0) ;

}

else

printf(“Eu sou o filho\n”) ;

}

154


fork/join

– desestruturam um programa

– são semelhantes à comandos go to

– tornam difícil a compreensão do programa

155


Comando concorrente– Dijkstra 1965

– construção de mais alto nível

– Forma:» parbegin s1, s2, ... sn parend ;

todos os comandos entre o parbegin e o parend são executados concorrentemente

o comando seguinte ao parend somente é executado após todos os anteriores terem terminado

156

Programa que copia um arquivo f para um arquivo g usando comando concorrente

varf, g file of T ;r, s of T ;begin

reset (f)read (f, r) ;while (not EOF ) do

begins = r ;parbegin

write (g, s) ;read (f, r) ;

parend ;end ;

write (g, r) ;end ;

157

Grafo de precedência apresentado anteriormenteprogramado com parbegin/parend

s1 ;parbegin

s3 ;begin

s2 ;s4 ;parbegin

s5 ;s6 ;

parend ;end ;

parend ;s7 ;

s1

s2 s3

s4

s5 s6

s7

158


Comparação entre comando concorrente e fork/join

– fork/join é mais poderosa

– comando concorrente é estruturado

– comando concorrente pode ser mais facilmente adicionado a uma linguagem de programação

159

Simulação de comando concorrente com fork/join

count = n ;fork l2 ;fork l3 ;...fork ln ;s1 ;go to lj ;

l2: s2 ; go to lj ;l3: s3 ; go to lj ;...ln: sn ;lj: join count ;

parbegins1;s2;s3;s4 ;...

Sn;parend;

160

Exercício

?

s1

s2 s3

s4

s5 s6

s7

s8

161

Resposta

count1 = 2;count2 = 3;s1;fork P1;s2;s4;fork P2;s5;go to P4;

P2: fork P3;s6;go to P4;

P1: s3;P3: join count1;

s8;P4: joint count2;

s7;

s1

s2 s3

s4

s5 s6

s7

s8

162

Multithreading

163


Processos leves (threads)

– cada um roda um código seqüencial

– Possuem sua própria pilha de execução e o seu próprio programcounter

– Compartiham o uso do processador

– Podem criar processos (threads) filhos

– Compartilham o mesmo espaço de endereçamento (dados globais)

– Podem estar em um dos estados ready, running, blocked

164

Threads e Processos pesados

165

Processos pesados

Acesso protegido a processador, outrosprocessos, arquivos, e recursos de IO

166

ThreadsTêm estado de execução (running, ready, etc.)

Salva contexto da thread quando não executando

Tem stack de execução por thread

Acessa endereços de memória e recursos do processo pesado que pertence– todas threads pertencentes ao processo pesado

compartilham

– quanto uma thread altera um valor compartilhado, todaspercebem esta mudança

– arquivo aberto por uma thread está disponível a outras

167

Modelos de Processos Mono e Multithreaded

Thread Control Block contém informações de prioridade e de estado da thread

168

Benefícios de Threads vsProcessos Pesados

menor tempo para criar thread queprocesso – processo pesado: carregar código

– thread: código já em memória

menor tempo para terminar …

menor tempo para chavear contexto entreduas threads (do mesmo processo) do quechavear processos pesado diferentes

169

Benefícios de ThreadsExemplo: servidor de arquivos em uma LAN

servir vários pedidos em curto período

mais eficiente criar e destruir threads porpedido que processos pesados

em máquinas SMP threads podem executarparalelamente em diversos processadores

170

Benefícios de threads

Aplicação consiste de várias partesindependentes que não precisam rodar emseqüênciacada parte - uma threadquando uma thread estiver bloqueada porIO, execução pode chaver para outra thread da mesma aplicação - ao invés de chavearpara outro processo

171

Benefícios de Threads

Compartilhamento de memória e arquivos: comunicação possível entre elas seminvocar chamada de sistema

Necessidade de sincronizar atividades das diversas threads para não causarinconsistência nos dados compartilhados

172

Estados de Threads

Três estados chave: running, ready, blocked

Não tem estado swapped– não existe swap de thread mas sim de todo

processo pesado

Terminação do processo pesado terminatodas as threads do mesmo

173

Threads a nível de usuárioUser-Level Threads (ULT)

Núcleo do sistema tratasomente processos pesados

Gerência de threads feita poraplicação utilizando umabiblioteca

Chaveamento de threads nãorequer privilégios do modokernel

escalonamento é específico daaplicação

Ex.: biblioteca Pthreads (ex.: sobre linux)

174

Bibliotecas de threads

Código para:– criar e destruir threads

– passar mensagens entre threads

– escalonar a execução de threads

– salvar e retomar contexto

175

Atividades do Kernel parathreads a nível de usuário

Núcleo não trata threads mas processospesados

Quando thread faz chamada de sistema, todoprocesso pesado será bloqueado

… para a biblioteca de threads, a thread rodando estará ainda no estado running

… o estado das threads é independente do estado do processo pesado

176

Vantagens e desvantagens de threads a nível de usuário

Vantagens– Chaveamento de

threads não envolvekernel: não troca de modo

– Escalonamento podeser dependente daaplicação: escolha de algoritmo

– Pode rodar em qualquerSO, precisa dabiblioteca

Desvantagens– Maioria das chamadas de

sistema são bloqueantes - e o kernel bloqueia todo processopesado - apesar de outra thread do processo poder continuar

– O núcleo só associa processospesados a processadores - duasthreads do mesmo processopesado não podem rodar emprocessadores diferentes

177

Threads a nível de núcleo -Kernel-Level Threads (KLT)

Gerência de threads feita no núcleo

ao invés de uma biblioteca de threads -> interface (chamadas) para facilidades de threads

núcleo mantém informação de contexto para threads e processospesados

chaveamento entre threads envolve o núcleo

escalonamento baseado emthreads

Ex: Windows NT and OS/2

178

Vantagens e desvantagens de thread no núcleo

Vantagens– núcleo pode escalonar

simultaneamente váriasthreads do mesmoprocesso pesado emdiferentes processadores

– bloqueio a nível de thread e não todo processopesado

– rotinas do SO podem ser também multithreaded

Desvantagens– chaveamento de threads

dentro do mesmoprocesso pesadoenvolve o núcleo

– impacto significante

179

Abordagem combinadaCriação de thread no modousuário

escalonamento e sincronização no modousuário

programador pode ajustarnúmero de threads a nívelde núcleo

combinar melhor das abordagens

Exemplo: Solaris

180

SolarisThreads a nível de usuário - User-level threads – invisíveis ao SO– são a interface de programação– uso de biblioteca

Threads do núcleo– a unidade que pode ser despachada em um

processador e suas estruturas mantidas pelo núcleo

Processos leves: Lightweight processes (LWP)– cada LWP suporta uma ou mais treads do usuário

(ULT) e mapeia para exatamente uma thread a nívelde núcleo (KLT)

– LWP são visíveis pela aplicação

181

Processo 2 é equivalente a abordagem ULT Processo 4 is equivalente a abordagem KLT

182

SolarisVárias Threads em um LWP– > ULT

Uma thread por LWP– -> KLT

Várias threads em várias LWPs– criação, escalonamento e sincronização de threads a nível

de usuário

– número de LWPs conforme aplicação

– threads podem executar em paralelo em diferentes CPUs

– chamada de sistema bloqueante não pára toda task

183

SolarisVárias Threads em um LWP– > ULT

Uma thread por LWP– -> KLT

Várias threads em várias LWPs– criação, escalonamento e sincronização de threads a nível

de usuário

– número de LWPs conforme aplicação

– threads podem executar em paralelo em diferentes CPUs

– chamada de sistema bloqueante não pára toda task

184

Solaris: user-level thread states

(attached to a LWP)

185

Solaris: Lightweight Process States

LWP states are independent of ULT states(except for bound ULTs)

186

Programação Concorrente

Exemplos de programas concorrentesparbegin

R := max(a, b);S := max(c,d);

parend;% nenhuma variável compartilhada pelos dois processos, independentes

187

Programação Concorrente

Exemplos de programas concorrentes(cont.)j := 10;parbegin

print j;j := 20;

parend;» j é compartilhada pelos 2 processos; dependentes

» qual o valor impresso por print j? 10 ou 20?

“indeterminado”

188

#include <thread.h>thread_t tid1,tid2;int a ;void * p0 (){int i ;for(i=0; i<1000000; i++)

{a = a + 2 ;

}}void * p1 (){ int i ;

for (i=0; i<1000000; i++) {a = a + 5 ;

}}main(){int result ;result=thr_create(NULL,0, p0,NULL,THR_NEW_LWP,&tid1);result=thr_create(NULL,0, p1,NULL,THR_NEW_LWP,&tid2);thr_join((thread_t)0,NULL,NULL);thr_join((thread_t)0,NULL,NULL);

}

189

Seção crítica

Produtor-consumidor com buffer limitado

int buffer [n] ;int i=0, j=0 ; int k ;

parbeginprodutor::

repeat“ produz um novo elemento k”while (( i + 1) mod n = j) do {} % buffer cheiobufffer[i] := k ;i = i + 1 mod n ; % uso circular do buffer

until false; % loop infinito

190

Seção crítica

Produtor-consumidor com buffer limitado(cont.)

consumidor:

repeatwhile i = j do {} ; % buffer vazio

y =buffer[j];j = j + 1 mod n;...“consome o item em y”

until false;parend

191

Seção crítica

Produtor/consumidor com lista encadeada

type ITEM = ...BUFFER = record

INFO: ITEM;NEXT: pointer para buffer

var P: pointer para buffer;C: pointer para buffer;FIRST: pointer para bufferNETXP, NEXTC: ITEM;

192

parbeginPRODUCER::

new(P);P.INFO := NEXTP;P.NEXT := FIRST;FIRST := P;

end;CONSUMER::

while FIRST = NILL do skip;C := FIRST;FIRST := FIRST.NEXT;NEXTC := C.INFO;DISPOSE(C);

end;parend;

193

Dada a situação acima e a seqüência de passos abaixoCONSUMER: C := FIRST => C = 4PRODUCER: P.NEXT := FIRST => P.NEXT = 4PRODUCER: FIRST := P => FIRST = 5CONSUMER: FIRST : = FIRST.NEXT => FIRST = 4

– estado final:

» o elemento adicionado (5) foi perdido

» C e FIRST estão com o mesmo valor

» FIRST aponta para elemento consumido

FIRST = ^4

44 3 2 1

5

194

Seção Crítica de Código

Causa do problema:acesso “simultâneo” à lista por PRODUCER e

CONSUMER

Código de acesso é uma

SEÇÃO CRÍTICA (SC)

Solução: execução da SC de forma mutuamente exclusiva

195


Definição geral do problema da seção crítica

– sistema com N processos, N > 1

– cada processo pode ter um código próprio

– os processos compartilham dados variáveis, de qualquer tipo

– cada processo possui SC’s, onde atualizam os dados compartilhados

– a execução de 1 SC deve ser de forma mutuamente exclusiva no tempo

196


Forma da solução: protocolo de entrada e saída na SC

entry-sectioncódigo-seção-crítica

exit-section

– entry-section: garante que somente 1 processo executa SC

– exit-section: permite que outro processo entre na SC

197


Requisitos para solução do problema da SC– prover exclusão mútua

– progresso» processos fora da SC não devem bloquear outros

processos

» somente os processos querendo entrar na SC devem participar da seleção do próximo a entrar

» a seleção não deve ser postergada indefinidamente

198


Requisitos para solução do problema da SC(cont.)

– espera limitada» um processo espera um tempo limitado na entry-

section

– velocidades indeterminadas» não se faz suposições sobre a velocidade relativa

dos processos

199

Soluções por SW para 2 processos – algoritmo 1

varTURNO: integer; % variável compartilhada; 0 ou 1EU, OUTRO: integer; % constantes locais, com valores opostos (0,1 e 1,0)

repeatwhile TURNO ≠ EU do skip; % mutexbegin

código-da-seção-crítica;TURNO := OUTRO % mutexend

resto-do-código;

until false;

– resolve ?

200

#include <thread.h>thread_t tid1,tid2;int turn = 0 ;int shared ;

void * p0 (){int i ;for(i=0; i<10; i++)

{while(turn != 1 ) {} /* entra se turn = 1 */shared =shared + 50 ;printf("Thread1: INCREMENTEI \n");turn = 0 ;

}}void * p1 (){ int i ;

for (i=0; i<10; i++) {while(turn != 0 ) {} /* entra se turn = 0 */printf("Thread2: SHARED: %d \n",shared);turn = 1 ;

}}main(){

int result ;result=thr_create(NULL,0, p0,NULL,THR_NEW_LWP,&tid1);result=thr_create(NULL,0, p1,NULL,THR_NEW_LWP,&tid2);thr_join((thread_t)0,NULL,NULL);thr_join((thread_t)0,NULL,NULL);

}

201


varvar flag[0..1] of boolean % variável compartilhada, inicializado com false

repeat

while flag[j] do skip; % mutexbeginflag[i] := true ;

código-da-seção-crítica

flag[i] := false % mutexend

resto-do-código;

until false;

– resolve ?

202

#include <thread.h>thread_t tid1,tid2;int shared ; int flag [2];

void * p0(){int i ;for(i=0; i<1000000; i++){

while(flag [1] == 1 ) {} /* entra se flag [1] = 0 */flag[0] = 1 ;shared =shared + 5 ;flag [0] = 0 ; }

}void * p1(){ int i ;for (i=0; i<1000000; i++) {

while(flag [0] == 1 ) {} /* entra se flag [0] = 0 */flag [1] = 1 ;shared = shared + 2 ;flag [1] = 0 ;}

}main(){int result ;shared = 0 ; flag [0] = 0 ; flag [1] = 0 ;result=thr_create(NULL,0,p0,NULL,THR_NEW_LWP,&tid1);result=thr_create(NULL,0,p1,NULL,THR_NEW_LWP,&tid2);thr_join((thread_t)0,NULL,NULL); thr_join((thread_t)0,NULL,NULL);printf(“O valor de shared e : %d\n”, shared) ;

}

203


varvar flag[0..1] % variável compartilhada, inicializado com false

repeat

flag[i] := true ;

while flag[j] do skip; % mutexbegincódigo-da-seção-crítica;


resto-do-código;

until false;

– resolve ?

204


varvar flag[0..1] % variável compartilhada, inicializado com false

repeat

flag[i] := true ;

while flag[j] do skip; % mutexbegincódigo-da-seção-crítica;


resto-do-código;

until false;

– propriedades

» satisfaz exclusão mútua

» não satisfaz requisito PROGRESSO;T0: P0 faz flag[0] = true

T1: P1 faz flag[1] = true =====> P0 e P1 ficam em um loop eterno

205

#include <thread.h>#thread_t tid1,tid2;int shared ;int flag [2];void * p0(){

int i ;for(i=0; i<1000000; i++) {

flag[0] = 1 ;printf("Thread0%d\n", shared) ;while(flag [1] == 1 ) {} /* entra se flag [1] = 0 */shared =shared + 5 ;flag [0] = 0 ;

}}void * p1(){

int i ;for (i=0; i<1000000; i++){

flag [1] = 1 ;printf("Thread1%d\n", shared) ;while(flag [0] == 1 ) {} /* entra se flag [0] [0] = 0 */shared = shared + 2 ;flag [1] = 0 ;

}}main(){

int result;shared = 0 ; flag [0] = 0 ;flag [1] = 0 ;result=thr_create(NULL,0,p0,NULL,THR_NEW_LWP,&tid1);result=thr_create(NULL,0,p1,NULL,THR_NEW_LWP,&tid2);thr_join((thread_t)0,NULL,NULL); thr_join((thread_t)0,NULL,NULL);printf(“O valor de shared e %d\n", shared) ;

}

206

Soluções por SW para 2 processos – algoritmo de Peterson

var flag[0..1] of boolean; % variável compartilhada, inicializada com falsevar turn of integer;repeat

flag[i] := true ;

turn := j ;

while flag[j] and turn = j do nop; % mutexbegincódigo-da-seção-crítica;

flag[i] := false; % mutexend

resto-do-código;

until false;

– resolve ?

207

Soluções por SW para 2 processos – algoritmo de Peterson

var flag[0..1] of boolean; % variável compartilhada, inicializada com falsevar turn of integer;repead

flag[i] := true ;

turn := j ;

while flag[j] and turn = j do nop; % mutexbegincódigo-da-seção-crítica;


resto-do-código;

until false;

– propriedades


» satisfaz a condição de progresso

» Satisfaz a condição de espera limitada

208

#include <thread.h>thread_t tid1,tid2;int turn ; int shared ; int flag [2];void * p0(){

int i ;printf("Thread P0\n");for(i=0; i<10000; i++){

flag[0] = 1 ;turn = 0 ;while(flag [1]==1 && turn == 0 ) /* entra se flag[1]=0 ou turn=0 */shared =shared + 5 ;flag [0] = 0 ;}

}void * p1(){

int i ;printf("Thread P1\n");for (i=0;i<10000; i++) {

flag[1] = 1 ;turn = 1 ;while(flag [0]==1 && turn == 1) /* entra se flag[0]=0 ou turn =1*/shared =shared + 2 ;flag [1] = 0 ;}

}main(){

int result,i ; shared = 0 ; turn = 0 ;flag [0] = 0 ; flag [1] = 0 ;result=thr_create(NULL,0,p0,NULL,THR_NEW_LWP,&tid1);result=thr_create(NULL,0,p1,NULL,THR_NEW_LWP,&tid2);thr_join((thread_t)0,NULL,NULL);thr_join((thread_t)0,NULL,NULL);printf(" O valor de shared e: %d\n", shared) ;

}

209

Soluções por SW para 2 processos – algoritmo de Dekker

var flag[0..1] of boolean; % variável compartilhada, inicializada com falsevar turn of integer; repeat

flag[j] := true ;

turn := j ;

repeat nop until not(flag[j]) or turn = i do nop; % mutexbegincódigo-da-seção-crítica


resto-do-código;

until false;

propriedades


» satisfaz a condição de progresso

» Satisfaz a condição de espera limitada

210

Soluções por SW para N processos – algoritmo da padaria

» na entrada da padaria, cliente recebe número

» cliente com menor número é servido

» clientes podem receber mesmo númeronúmero de processo menor tem preferência

211

Soluções por SW para N processos – algoritmo da padaria: variáveis compartilhadas

var choosing: array [0..n-1] of boolean;

number: array [0..n-1] of integer;

– algoritmo da padaria: estrutura do processo Pirepeat

choosing[i]:= true;

number[i]:= max(number[0], number[1], ..., number[n-1])+1;

choosing[i]:=false;

for j:=0 to n-1

do begin

while choosing[j] do skip;

while (number[j] ≠ 0) and (number[j],j)<(number[i],i) do skip;

end;

código-da-seção-crítica

number[i] = 0;

resto-do-código;

until false;(a,j)<(b,i) if a<b or a=b and j<i

212

Soluções de Hardware – Instruções Especiais

» TAS: Testa e modifica o conteúdo de uma variável de forma não interrompível

» Swap: Troca o conteúdo de duas variáveis de forma não interrompível

213

Soluções de Hardware - tas

int lock = 0; % globalint tas (){

r = lock ;

lock = 1 ;

return (r) ;

}

214

Soluções de Hardware - tas

pi() {

for(;;) {

while(tas(lock)) {}

“seção crítica”

lock = 0 ;

}

}

215

Soluções de Hardware - swap

int lock = 0; % global inicializada com falseswap (lock, key){

int r ;

r = lock ;

lock = key ;

key = r ;

}

216

Soluções de Hardware - swappi() {

int key = 1 ;for(;;) {

repeat swap(lock, key) ;

until key = false ; “seção crítica”

lock = 0 ;}

}

217

Soluções de Hardware - possível implementação

– Instruções especiais disponíveis no modo supervisor

– Uso correto das instruções» oferecer enter_region e exit_region

– tsl: Testa e modifica o conteúdo de uma variável de forma não interrompível

– Swap: Troca o conteúdo de duas variáveis de forma não interrompível

218

Soluções de Hardware - tasint lock = 0; % globalenter_region (){

/* implementada como chamada de sistema (salva contexto, entra no modo supervisor) */

L: tsl register, #lock /* copia o valor de lock para register

seta valor do lock - atomicamente */

cmp register, #0 /* compara com 0 */jne L /* se não for 0 a SC está ocupada, loop */

ret}

219

Soluções de Hardware - tasleave_region (){

move lock, #0 /* atribui 0 a variável lock - libera a SC */

ret

}

220

Soluções de Hardware – tslpi() {

for(;;) {enter_region() ;

“seção crítica”leave_region() ;}

}

221

Soluções de Hardware - swapint lock = 0; % global inicializada com falseenter_region() {

/* implementada como chamada de sistema (salva contexto, entra no modo supervisor) */

L: swap #lock, #key /* troca o conteúdo de lock e key -atomicamente */

cmp #key, 0 /* compara o conteúdo de key com 0 */

jne L /* se for 0 a SC está ocupada, loop */

rte}

222

Soluções de Hardware - swap

leave_region() {

move #lock, 0 /* libera a SC */

rte

}

223

Soluções de Hardware – swap

pi() {for(;;) {

int key = 1 ;

enter_region() ;


leave_region() ;

}

}

224

Semáforos

Dijkstra - 1965– Um semáforo s é uma estrutura de dados,

formada por um contador e um apontador para uma fila de processos bloqueados no semáforo

– Somente pode ser acessado por duas operações atômicas (P e V)

– As modificações no valor do semáforo são executadas atomicamente

225

Semáforos

Cont.– Se dois processos tentam, simultaneamente,

executar P(s) ou V(s), essas operações irão ser executadas seqüencialmente, em uma ordem arbitrária

– Semáforos podem ser usados para exclusão mútua com n processos, quando inicializados com o valor 1

226

Semáforos

Cada processo Pi

repeat

P(mutex) ;


V(mutex)

“seção não crítica”

until false ;

227

Semáforos

Uso de Semáforos para sincronizar processos – Ex.: p1: comando s1; p2: comando s2

– Condição: somente executar s2 depois de s1 ter terminado

semaphore sync = 0 ;

processo p1 processo p2

--- ---

s1 ; P(sync) ;

V(sync) ; ---

228

Semáforos

Implementação

P(s): s.value = s.value - 1 ;

if (s.value < 0 ) {

“adicionar o processo na lista s.l”block(p) ; /*bloqueia o processo p*/

}

V(s): s.value = s.value + 1 ; if (s.value < =0 ) {

“remover o processo “p” da lista s.l”

wakeup(p) ; /*acorda o processo p*/}

229

Semáforos

Problema clássico: buffer limitado– conjunto de “n”buffers”

– cada buffer com capacidade para um ítem

– semáforos usados:

» mutex: para exclusão mútua

» empty: contador do número de buffers vazios

» full: contador do número de buffers cheios

Int buffer [20] ;

semaphore mutex, empty, full ;

info info-p, info-c ;

full = 0 ; empty = 20 ; mutex = 1 ;

230

main() {

parbegin{

produtor: repeat

“produz um ítem”

info-p = item ;

p(empty) ;

p(mutex) ;

“adicionar info-p ao buffer”

v(mutex) ;

v(full) ;

until false ;

consumidor: repeat

p(full) ;

p(mutex) ;

“remover o item para info-c”

v(mutex) ;

v(empty) ;

until false ;

}

}

231

Programação com threads no Solaris

Thr-create ( void* stack-base, size-t stack-size,void * start-newtime, void * arg,long flajs, thread-t * new-thread);

thr-join (thread-t wait-for, thread-t* deported,void ** status) ;

thr-self ( );retorna a identificação da thread criada

232

Semáforos

OperaçõesSema-init ( sema-t * sp, unsigned int count, int type, void * arq);

sp: identificador do semáforocount: valor a ser atribuído ao semáforo type:

usync_process: sincronizar threads neste e em outros processosusync_threads- sincronizar threads neste processo

arq: sem uso

sema-wait ( sema-t * sp );sema-post (sema-t * sp);sema-trywait (sema-t * sp );sema-destroy (sema-t * sp);

233

Exemplo de programa* include < thread.h >thread_t th0, th1;void * t0 ( );void * t1 ( );main ( ) {

int r, I ;thr-create ( null, 0, t0, NULL, THR_NEW_LWP, &th0);thr-create ( null, 0, t1, NULL, THR_NEW_LWP, &th0);thr_join [( thread_t ) 0, null, null);thr_join [( thread_t ) 0, null, null);printf(“ eu sou o main\ m”);}

234

Void * t0 ( ){int k = 0;for (;; )

{print f (“thread: % d % d \ m”, thr_self ( ), K );k ++ ;

}}

void * t1 () {int k = 0 ;for (;;)

{print (“thread: % d % d \ m” , thr_self ( ), K );k ++ ;}

}

235

Exemplo de programa* include < thread.h >thread-t t0, t1 ;void * thread-0 ( );void * thread-1 ( );int k = 0;

main ( ) {int r, f;r = thr_create ( null,0, thread0, NULL, THR_NEW_LWP, &t0 );r = thr_create ( null, 0, thread1, NULL, THR_NEW_LWP, &t1 );thr_join [(thread-t ) 0, null, null );thr-_oin [( thread-t ) 0, null, null );print f ( “eu sou o main \n “ );}

236

Exemplo de programa

Void * thread-0 ( ) {for (;; ) {

k = k + s;}

}void * thread-1 ( ) {

for ( ;; ) {print + ( “valor de k = %d\n”, k );}

}

237

Exercício

Escrever um programa que define e inicializa, com valores quaisquer, duas matrizes. A seguir, cria duasthreads, th0 e th1, para identificar e imprimir o maior elemento de cadauma das matrizes. Th0 opera sobre a matriz m0 e th1 opera sobre a matrizm1.

PTHREADS

Regiões Críticas (pthreads )

pthread_create(&th, NULL, proc, &args) ;pthread_exit(void *value_ptr) ;pthread_join(pthread_t thr, void **ptr) ;pthread_mutex_t mutex1;pthread_mutex_init(&mutex1, NULL) ;pthread_mutex_lock(mutex1) ;pthread_mutex_unlock(mutex) ;

Variáveis condição (pthreads )

pthread_cond_t cond1;

pthread_cond_init(&cond1, NULL) ;

pthread_cond_wait(&cond1, &mutex1) ;

pthread_cond_timewait(&cond1, &mutex1, time) ;

pthread_cond_signal(&cond1) ;

pthread_cond_broadcast(&cond1) ;


EX.

pthread_mutex_lock(&my_lock);

while(not condition)

pthread_cond_wait(&w, &my_lock);

“executar comandos”

pthread_mutex_unlock(&my_lock);


EX.

pthread_mutex_lock(&my_lock);

“executar comandos”

pthread_cond_signal(&w);

pthread_mutex_unlock(&my_lock);

Regiões CríticasRegiões Críticas CondicionaisMonitores

Construções de Alto Nível

( Brinch Hansen, Hoare ) 72 - 74

Regiões Críticas ( 72 )Uso de Semáforos:

Type semaphore = 0;p ( mutex );

secão críticav ( mutex );

Type semaphore = 1;p ( mutex );

secão críticap ( mutex );

Type semaphore = 1;v ( mutex );secão crítica.P ( mutex );

Regiões Críticas ( 72 )Variável V:– Somente pode ser acessada dentro de

um comando region– garante exclusão mútua

Varshared T V;

po() { po() {

region V do s0; region V do s1;} }

Regiões Críticas ( 72 )

Exemplo de Região Crítica:– Var free: shared array [ 1..N ] of

Boolean;Procedure acquire ( var index: integer )

Beginregion free do

for index: = 1 to N doif ( free[ index ] then

beginfree[ index]: = false;

exit ;end ;

index: = -1 ;end;

Regiões Críticas ( 72 )Implementação da Região Crítica com Semáforos:– para cada declaração: var shared T V

;» o compilador gera um semáforo

– para cada comando Region v do S ;» o código gerado pelo compilador é o

seguinte:

P ( mutex );S ;

V ( mutex );

Regiões Críticas ( 72 )

Alinhamento de Regiões Críticas:– P0: region x do region y do s1;– P1: region y do region x do s2;

Deadlock

Região Crítica Condicional (Hoare) 72

Region V when b do S;– b: expressão booleana avaliada quando o

processo entra na região crítica.– Se b é verdadeira, o comando S é executado– senão:

» o processo libera a exclusão mútua e é suspenso até que a expressão booleana se torne verdadeira

Exemplo de Programa Usando Região Crítica Condicional:Var

buffer = shared recordelemento: array [ 0…N] integercount, in, out : integer;

end;Produtor:

region buffer when count < N dobegin

elemento [ in ]: = inf;in: = in + 1 mod N;count: = count + 1;

end;

Consumidor:region buffer when count > 0 do

begininf: = elemento [out ];out: = out + 1 mod N;

. Count : = count -1 ;end;

Região Crítica Condicional (Hoare) 72

Operação Await ( exb ):– permite a um processo se bloquear

dentro de uma região crítica a espera de uma condição

Region V do beginS1;

await ( b );S2 ;

end ;

Implementação de Região Crítica Condicional com Semáforos:

Var mutex, wait: semaphore;count, temp: intefer;P ( mutex );

if ( not b ) then {count : = count + 1 ;V ( mutex ) ;P ( wait ) ;while ( not b ) do {temp: = temp + 1 ;if ( temp < count ) then

V ( wait ) ;else

V ( mutex ):P ( wait ) ;}

count : = count - 1 ;}

“comandos”

if ( count > 0 ) then {temp : = 0 ;

V ( wait ) ;}

elseV ( mutex ) ;

Monitor( Brinch Hansen, Hoare ) 73, 74

– É um modelo que permite o compartilhamento de dados

– possui valores que representam o estado do objeto e as procedures que manipulam os valores

– as procedures são executadas de forma mutuamente exclusiva

– variáveis especiais ( condição ) permitem a um processo se bloquear a espera de uma condição (wait)

– a condição é sinalizada por um outro processo (operação signal)


Visão Esquemática de um Monitor:

Dadoscompartilhados

Código de inicialização

operações

Filas deentrada


Variáveis Condição:– ex.: var x, y : condition ;– x.wait:

» o processo que executa essa operação é suspenso até que um outro processo execute a operação x.signal

– x.signal:» acorda um único processo » se não existem processos bloqueados, a operação

não produz efeitos


Se a operação x.signal é executada por um processo P0 e existe um processo P1 bloqueado, P0 e P1 podem executarse P1 é acordado, P0 e P1 ficam ativos simultaneamente no monitorPossibilidades:– a) P0 acorda P1 e espera que P1 libere o

monitor, ou se bloqueia a espera de outra condição

– b) P1 espera que P0 libere o monitor, ou espera por outra condição

Brinch Hansen (Pascal Concorrente):– P0 executa signal e libera o monitor ( o signal

é a última instrução da procedure )


Programa Pascal Concorrente:type resource = monitor

varfree : boolean ;

x : queue ;procedure entry request ;

beginif not free themdelay ( x ) ;

free : = false ;end

procedure entry release ;begin

free : = true ;continue ( x ) ;

endbegin

ree : = true;end.

Programa Pascal Concorrente:Type user = process ( r = resource );begin

r.request ;……

r.release ;end;

Type user1 = process ( r = resource );begin

r.request ;……

r.release ;end;

Beginvar

p0 : user ;p1 : user1 ;m : resource ;

init po ( m ) ;init p1 ( m ) ;

end.


Implementação de Semáforo:Type semaphore = monitor ;

var busy = boolean ;nonbusy : condition ;

procedure entry Pbegin

if busy than nonbusy.wait ;

busy = free ;end;

Procedure entry Vbegin

busy = false ;nonbusy.signal ;

end ;begin

busy = false ;end.


Implementação de Semáforo n bin:Type semaphore = monitor ;

var nproc = int ;non_busy : condition ;

procedure entry Pbegin

nproc--;if nproc<0 then

non_busy.wait ;end;

Procedure entry Vbegin

nproc++;non_busy.signal ;

end ;procedure semaInit(int I)begin

nproc = i;end.


Solução para o Problema dos Filósofos:

Type philosophers = monitorvar

state : array [ 0…4 ] of ( thinking, hungry, eating ) ;self : array [ 0…4 ] of condition ;

procedure entry pickup ( I = 0…4 )begin

state [ 1 ] = hungry ;test ( I ) ;if state [ I ] =/ eating them self [I ]. Wait ;

end ;procedure entry putdown ( I : 0…4 )

begin state [ I ] = thinking ;test ( I-1 mod5 ) ;test ( I + 1 mod5 ) ;

end;


Solução para o Problema dos Filósofos:

Procedure test ( k : 0…4 )begin

if ( state [ k-1 mod5 ] =! eatingand state [ k ] = hungryand state [ k + 1 mod 5 ] =! eating ) thembegin

state [ k ] = eating ;self [ k ] . Signal ;

end ;end ;

begin for I = 0 to 4 do

state [ I ] = thinking ;end.

Implementação de Monitor com Semáforo:– cada monitor é representado por um semáforo mutex

inicializado com 1. P( mutex ): entrar no monitor V ( mutex ): liberar monitor

– semáforo next inicializado com 0 para um processo sinalizador se bloquear

– next count : contém o No. de processos bloqueados em next


P ( mutex ) ;“ corpo da procedure entry”

if next-count > 0 themv ( next ) ;

elseV ( mutex ) ;


– Para cada variável condition, associar um semáforo x-sem e uma variável inteira x-count

X.wait : x-count = x.count + 1 ;if next-count > 0 them

V ( next ) ;else

V ( monitor ) ;P ( x-sem ) ;x-count = x-count-1 ;

X.signal : if x-count > 0 thembegin

next-count = next-count + 1 ;V ( x-sem ) ;P ( next ) ;next-count = next-count - 1 ;

end ;

265

Software de entrada esaída

266

Software E/S

Uma das principais funções do SO é controlar os dispositivos de E/S– Para isso deve:

» emitir comandos para os dispositivos

» tratar interrupções

» tratar erros

» prover uma interface entre os dispositivos e o resto do sistema

267

Software E/S

Estruturação do software de E/S– quatro níveis

» tratamento de interrupções

» drivers dos dispositivos

» software do SO independente do dispositivo

» software ao nível do usuário

268

Software E/S

Tratamento de interrupções– quando uma interrupção ocorre, uma procedure

específica é ativada de modo a desbloquear o driver

– o efeito de uma interrupção é que um processo que estava previamente bloqueado está agora apto a rodar

269

Software E/S

Drivers dos dispositivos– todo código dependente do dispositivo está em

um driver do dispositivo

– o trabalho do driver é aceitar requisições e providenciar para que sejam executadas

– se o driver esta disponível, a requisição é processada imediatamente, caso contrário, entrará em uma fila de requisições

270

Software E/S

Execução de uma requisição para um disco– determinar o posicionamento do braço no

cilindro próprio

– determinar as operações que são requeridas:» Ex. leitura, escrita, etc.

– escrever as operações nos registradores do controlador

271

Software E/SSoftware independente do dispositivo– Funções básicas

» desenvolver as funções de E/S que são independentes do dispositivo

» prover interface uniforme para o nível usuário

– Funções:» mapeamento do nome simbólico no driver apropriado

» interface uniforme para os drivers

» identificação dos dispositivos

» prover tamanho de bloco independente do dispositivo

» etc.

272

Software E/S

Software à nível do usuário– Rotinas de biblioteca

» read

» write

» open

» close

» etc.

273

Software E/S

Processos dousuário

Software independentedo dispositivo

Tratamento de interrupções

Hardware

Níveis lógicos de um sistema de entrada e saída

274

Software E/S

Exemplo de requisição para um dispositivo blocado– Tipo: operação

– dispositivo: menor número

– posição: endereço do dispositivo

– número de processo: requisitante da e/s

– endereço: do processo requisitante

– contador: bytes a transferir

Resposta– número do processo: requisitante

– status: bytes transferidos ou erro

275

Software E/SEstrutura principal de um driver

message msg; /* buffer de msg */

IO_task (){int r, caller ;initialize ;while (true) {

RECEIVE(any, &msg) ;caller = msg.source ;switch (msg.type) {

case read: r = do_read(); break ;case write: r = do_write()); break;case other: r = do_other(); break; default: r = error;}

}}

276

Gerência de Memória

277


Memória:» central em sistemas de computador

» CPU e sistema de I/O interagem com a memória

» é um conjunto (array) de bytes ou palavras, cada um com seu próprio endereço

» CPU faz busca e armazenamento na memória

» um programa deve ser carregado na memória para ser executado

278


Memória

CPU memória sistemaI/o

279

Conceitos Básicos

UCP– é composta de circuitos eletrônicos

– coordena e controla todas as operações do sistema

– é formada por processador e memória» processador:

unidade de controle (UC)

unidade lógica-aritmética (ULA)

» memória unidade de armazenamento de instruções e dados

280

Unidade aritmética elógica

UCP

Memória

Registradoresespeciais

012345...

N

Representação esquemática da UCP

unidade de controle

281

Conceitos Básicos

Unidade de controle– controla todas as operações do computador

– é formada por:» registrador de controle

» registrador de instrução

» decodificador

» relógio

» sequenciador

282

Conceitos Básicos

Registrador de controle (contador de programa - PC)– contém o endereço de memória da próxima

instrução a executar

Registrador de instrução (RI)– contém a instrução que está sendo executada a

cada momento

– cada instrução contém:» código da operação

» operandos ou endereços de memória dos mesmos

283

Conceitos Básicos

Decodificador– extrai e analisa o código de operação da

instrução que está em execução (que está no RI)

– emite os sinais necessários para a sua execução

Relógio– proporciona uma sucessão de impulsos elétricos

a intervalos constantes que sinalizam os instantes de inicio de execução dos passos que constituem cada instrução

284

Conceitos Básicos

Sequenciador– gera ordens sincronizadas pelos impulsos do

relógio que fazem com que a instrução carregada no RI seja executada passo a passo

285

Conceitos Básicos

Memória Principal– é a parte da UCP que armazena instruções e

dados necessários para que um programa seja executado

– é constituída por células ou posições de memória numeradas de forma consecutiva

– é volátil

– permite acesso direto

286

Conceitos Básicos

Memória Principal (cont.)– palavra de memória: conjunto de células de

memória que podem ser lidas ou escritas de uma só vez

– em geral é endereçada por byte

– possui dois registradores para as operações de leitura e gravação: Registrador de endereço de memória e Registrador intermediário (buffer)

287

Conceitos Básicos

Memória Principal (cont.)– Registrador de endereço de mémória

» contém o endereço de memória onde se encontra ou onde vai ser gravada a informação (instrução ou dado)

– Registrador Intermediário (buffer)» leitura: recebe a informação da memória

» escrita: contém a informação a ser gravada

– Seletor: seleciona a célula de memória cujo endereço se encontra no registrador de endereços para a transferência (leitura/escrita)

288

1

2

3

...

...

32

33...

N

Registrador de endereço de memória

Registrador intermediário (buffer)

Seletor Memória principal

Visão esquemática da memória principal de um computador

289

Conceitos Básicos

Execução de um programa– o programa deve estar na memória

– as instruções são executadas uma a uma

Fases do processamento de uma instrução– Busca

» a instrução é levada da memória para a unidade de controle

– Execução» realização das ações internas contidas na instrução

290

Conceitos Básicos

» Fase de Busca de uma instrução a unidade de controle (UC) envia uma microordem para que o conteúdo do program counter (PC), seja transferido para o registrador de endereço de memória (MAR)

o seletor transfere o conteúdo do endereço de memória constante no MAR para o registrador intermediário de memória (MBR)

a instrução é transferida do MBR para o registrador de instrução (RI)

o decodificador interpreta a instrução que acaba de chegar no RI

o program counter se auto-incrementa (com o uso da unidade aritmética e lógica)

291

Conceitos Básicos

Ex. Instrução de três operandos– possui o código da operação e três operandos:

os dois primeiros contém os operandos, e o terceiro o lugar onde será armazenado o resultado da operação.

– EX. ADD a, b, c

operador operando1 operando2 operando3

292

Conceitos Básicos

» Fase de Execução de uma instrução (com três operandos)

o end. do primeiro operando do RI é transferido para o MAR

o seletor faz a leitura da posição de memória apontada por MAR e deposita seu conteúdo no MBR

esse valor é transferido para o registrador de operando 1 (RO1) da unidade aritmética e lógica

293

Conceitos Básicos


o end. do segundo operando é transferido do RI para o MAR

o seletor faz a leitura da posição de memória apontada por MAR e deposita seu conteúdo no MBR

esse valor é transferido para o registrador de operando 2 (RO2) da unidade aritmética e lógica

o sequenciador envia uma micro-ordem para a unidade aritmética e lógica para que seja executada a operação, e o resultado fica armazenado no registrador de resultados (RR)

294

Conceitos Básicos


O conteúdo do registrador de resultados (RR) é transferido para o registrador intermediário de memória (MBR)

é transferido do registrador de instrução (RI) para o registrador de endereço de memória (MAR) o endereço de memória onde o resultado deverá ser armazenado

o reultado é transferido do MBR para o endereço constante no registrador de endereço de memória (MAR)

295


Memória física e Memória virtual:– Física:

» é a memória do hardware

» começa geralmente no endereço físico 0 e continua até um endereço qualquer

» certas posições são reservadas pelo hardware para objetivos especiais (ex. vetor de interrupções)

296

Gerência de memória Memória física e Memória virtual (cont.)– Virtual:

» é a memória que o processo enxerga

» é o espaço virtual de um processo

» o maior endereço virtual é limitado pela arquitetura da máquina (No. de bits usados para endereçar). EX.

PDP-10 (18 bits)==>256 k

PDP-11 (16 bits)==> 64 k

» o espaço virtual pode ser maior que o espaço físico, especialmente se é usada paginação/segmentação

» um processo pode acessar qualquer parte de seu espaço virtual

297


memória física e memória virtual (cont.)– Virtual:

» um processo pode acessar qualquer parte de seu espaço virtual

código

dados

pilha

0

n

298


Tradução de endereço:– processo trata com endereços virtuais

– em todo acesso deve haver uma tradução de endereços

– isto significa que a tradução não deve ser feita por software - desempenho

299


Tradução de endereço (cont.)

memória física

kernel

proc a proc b0 10 k13 k

tradução de endereço

0 19 k

tradução de endereço

0

300


Monoprogramação– existe um único processo na memória em

execução e ao mesmo é permitido usar toda a memória

Multiprogramação– existem vários processos na memória aptos à

executar e um em execução

301


Monoprogramação:– esquema mais simples possível

– um processo por vez na memória

– o processo pode usar toda a memória

– a memória é dividida entre o sistema operacional e o processo do usuário

302


Monoprogramação (cont.)

operatingsystem in Ram

userprogam

operatingsystem inRam

user

program

devicedrivers inRomuserprogramoperatingsystem inRam

Formas de organizar a memória com o sistema operacionale um programa de usuário

303

Sistemas que suportam Multiprogramação

Proteção de hardware:A. registradores limite0

monitor

usuário 1

usuário 2

usuário 3

usuário 4

limite inferior

limite superior

128 k

limiteinferior

limitesuperior

end sim sim

não não

CPU > < mem.

trap parao sistema operacional

304


Proteção de hardware: (cont.)b: registradores base e limite

CPU

limite base

+< mem.

end sim

não

trap para osistema operacional

mem.

305


Proteção de hardware:– com registradores limite muitos processos

podem residir na memória simultaneamente

– divisão da memória entre os processos (partições fixas, partições variáveis)

306


Partições Fixas– tamanho fixo das partições,

– ex.: memória de 32K, dividida em:

10K - monitor residente04K - processos pequenos06K - processos médios12K - processos grandes

– quando o processo entra no sistema, é colocado emuma fila de processos

307


Partições Fixas (cont.)– o scheduler verifica sua necessidade de

memória, que partições estão disponíveis e carrega o processo em uma das partições

– o grau de multiprogramação é determinado pelo No. de partições

308

Sistemas que suportam Multiprogração

Partições Fixas: (cont.)– alocação de memória para os processos

» a) classificá-los de acordo com suas necessidades de memória (especificada pelo usuário ou pelo sistema)

» b) cada região tem sua própria fila

2K 1K 2K

3K 4K

7K 11K 8K

f 2

f 6

f 12

......

...............

.......

309


Partições Fixas (cont.)– alocação de memória para os processos

» c) uma única fila

5K 2K 3K 7K 7K .........monitor

2K

6K

12K

310


Fragmentação– interna: tamanho da partição maior que o

tamanho do processo

– externa: partição não usada é menor que o tamanho do processo esperando

311


Partições variáveis – o sistema operacional mantém uma tabela

indicando que partes da memória estão disponíveis e quais estão ocupadas

– inicialmente toda a memória esta disponível, considerada como um bloco único

– quando um processo chega e necessita memória é pesquisado um bloco com tamanho suficiente para contê-lo

312


Partições variáveis (cont.)– quando um processo termina libera sua

memória, que é reincorporada ao conjunto disponível

– características:» existem blocos livres de diferentes tamanhos

» se um bloco é muito grande para um processo, é dividido em dois, um alocado para o processo e o outro retorna para os blocos livres

313


Partições variáveis (cont.)– características:

» quando um processo termina libera a memória, sendo esta colocada no conjunto de blocos livres

» se o bloco liberado é adjacente à outo livre, podem ser agrupados formando um único

– Que bloco alocar?» first-fit: o primeiro com tamanho suficiente

» best-fit: o menor com tamanho suficiente

» worst-fit: o maior

314


O software determina a diferença entre Partições Fixas e Partições Variáveis

dois registradores contém os limites (superior e inferior)

» quando um processo é selecionado, o dispatchercarrega os valores nos registradores

– a utilização de memória é geralmente melhor no mvt que no mft

315


Compactação:– unir os blocos de memórias disponíveis em um

único bloco

– somente possível se o sistema suporta relocação dinâmica, em tempo de execução (registradores base e limite)

316

Sistemas que movimentam processos entre a memória principal e o disco

Swapping– O esquema de gerência de memória de sistemas

monousuário foi usado por dois dos primeiros sistemas timesharing: CTSS e Q-32

– memória dividida em duas partes:» 1. monitor residente

» 2. processo do usuário sendo executado correntemente

317

Swapping

Swapping (cont.)– quando o processo executando perde o

processador:» conteúdo da memória do usuário é gravado no disco

» novo processo é lido para a memória

“Swapping”

318

Swapping

Swapping: (cont.)

monitor

área dousuário

swap outlimite

memória

“swapping”

swap in

Disco

usuário1

usuário2

319

Swapping

memória auxiliar:– swapping requer memória auxiliar

– normalmente um disco

– deve ser grande o bastante para acomodar cópia de todas as “imagens de memória dos processos dos usuários”

– lista “ready” contém processos que estão em disco e que estão aptos para rodar

320

Swapping

memória auxiliar: (cont.)– uma variável indica o processo que está em

execução

– quando o scheduling decide executar um processo chama o dispatcher

Dispatcher:– verifica se o processo selecionado está na

memória

321

Swapping

Dispatcher: (cont.)– se não estiver, faz swap out do processo na

memória

– faz swap in do processo selecionado

– restaura os registradores

– transfere o controle para o processo selecionado

322

Swapping

Tempo de swap– maior parte do tempo de swap é o tempo de

transferência

– proporcional ao tamanho de memória a ser transferida

323

Swapping

Tempo de swap: (cont.)– o S.O deve ser informado com exatidão do

tamanho da memória do usuário

– o tempo de transferência diminui com o aumento da velocidade de transferência dos dispositivo

324

Paginação

Endereço gerado pela CPU contém duas partes:– No. da página: (p)

» endereça uma tabela de páginas

– deslocamento: (d)» combinado com o endereço base da página define o

endereço físico de memória

325

Tradução de endereço

f dd p

f

endereço físicoendereço lógico

CPU

memóriafísica

326

Paginação

tradução de endereço:– memória física: dividida em frames

– memória lógica: pages

– um programa para ser executado tem suas pages carregadas em quaisquer framesdisponíveis

– o tamanho da página é definido pelo hardware

327

Paginação

Tradução de endereço: (cont.)

u: endereço lógicoP: tamanho da páginap: número da páginad: deslocamento

p = u div Pd = u mod P

4 words

ex.: memória física = 32 wordsP : 4 words

total de páginas : 8

328

Paginação

tradução de endereço: (cont.)endereço lógico0 - p = 0 div 4 = 0 (page)

d = 0 mod 4 = 0 (deslocamento)1 - p = 1 div 4 = 0 (page)



d = 15 mod 4 = 3 (deslocamento)

329

Paginação

scheduling:– quando o processo chega, o scheduling verifica

o No. de páginas de que ele precisa

– verifica na lista de frames disponíveis se existe um número suficiente

– existindo, aloca para o processo o No. que ele necessita

330

Paginação0 a1 b2 c3 d4 e5 f6 g7 h8 i9 j10 l11 m 12 n13 o14 p15 q

memórialógica

o 51 62 13 2

tabela depáginas

0

4 ijkl

8 mnop

12

16

20 abcd

24 efght

28

memóriafísica

331

Paginação

implementação da tabela de páginas:– conjunto de registradores:

» recarregados como qualquer outro

» carregados/modificados por instruções especiais

» somente se a tabela de páginas é pequena

– na memória principal (um registrador-pagetable base register-(ptbr) aponta para a tabela de páginas)

» o tempo de acesso a uma posição de memória é o problema

332

Paginação

implementação da tabela de página: (cont.)– acessar end. i

» acessar tabela de páginas (uso do ptbr+ No.pagedesloc.) (1o. acesso à memória)

» produz um No. de frame, combinado com deslocamento produz end i

» acessar a posição i na memória física (2o. acesso)

» dois acessos para acessar uma palavra

333

Paginação

implementação da tabela de página: (cont.)– hardware especial: (memória associativa,

memória endereçável pelo conteúdo)» mais rápida que a memória

» contém poucas entradas da tabela de páginas

» um endereço lógico gerado pela CPU é comparado com todas as entradas da tabela de páginas simultaneamente, a qual contém número de página/número de frame (na memória associativa)

334

Paginação

implementação da tabela de páginas: (cont.)– hardware especial: (memória associativa,

memória endereçável pelo conteúdo)» se o número da página é encontrado, o No. da frame é usado

imediatamente para acessar a memória

» se o número da página não é encontrado, é feito um acesso a tabela de páginas, na memória principal, para obter o No. da frame que é usado para acessar a memória

» o No. da página e o No. da frame são colocados na memória associativa, de modo a ser encontrado rapidamente na próxima referência

335

Paginação

compartilhamento de páginas:– particularmente importante em sistemas time-

sharing

– permite compartilhamento de código

proteção:» um bit de proteção em cada página

» o bit define se a página é read-only ou read-write

336

Paginação

ED1ED2ED3D1P1

3461

ED1ED2ED3D3P3

3468

012345678910

D1D3

ED1ED2

ED3D2

compartilhamentode

código

ED1ED2ED3D2P2

3467

337

Segmentação

um programa é um conjunto de:– subrotinas

– funções

– estruturas de dados (tabelas, etc.) referidos pelo nome

– cada um é um segmento de tamanho variável

– segmentação é um esquema de gerência de memória que suporta esta visão

338

Segmentação (cont.)

– cada segmento tem um nome e um tamanho (end. é especificado pelo nome do segmento e pelo deslocamento)

– compilador pascal cria segmentos para:» variáveis globais

» código de cada procedure

» código de cada function

» variáveis locais de procedures

» variáveis locais de functions

339

Segmentação

(s d)

s

<d

+yes

trap; addressing error

CPU

segment table

memory

limite base

segmentation hardware

340

Segmentação

Hardware:– end => No. seg e deslocamento

» a tab. seg é um array de par de registradores base e limite

– Implementação:» registradores:

ex.: pdp-11/45 => 8 registradores de segmento

341

Segmentação

– Implementação: (cont.)» registradores:

endereço de 16 bits

15

13 12s d

0

No.segmento

3 bits => 8seg.13 bits => 8K desloc.muitos segmentos??

desloc.

342

Segmentação

Hardware: (cont.)– tabela de segmentos na memória

» uso de dois registradores:STBR: segment table base register

STLR: segment table length register

» endereço: (s,d)

deslocamento

segmento

343

Segmentação

Hardware: (cont.)– tabela de segmentos na memória (cont.)

» para um endereço lógico (s,d) a. s < STLR ? não => erro b. s + STBR c. endereço = (end. base do segmento) + d

» requer dois acessos à memória (como na paginação)

344

Segmentação

Hardware: (cont.)– uso de memória associativa para manter as

entradas da tabela de segmentos mais recentemente usadas

» proteção:bits de proteção para cada entrada na tabela de segmentos

existência de segmentos na tabela read only (código), tentativa de escrita verificada pelo hardware

limites de um array (se for um segmento) verificados pelo hardware

Sistemas Operacionais

Arquivos

346

Arquivos

Entidades lógicas mapeadas pelo S.O. em dispositivos físicos

Contém informações definidas pelo proprietário (dados e programas)

Possui um nome e é referenciado pelo mesmo

O sistemas operacional possui suporte (chamadas de sistema) para manipulação de arquivos.

347

Tipos de Arquivos

Regulares : contém informações dos usuários

Diretórios : são arquivos mantidos pelo sistema e que possuem a estrutura do sistema de arquivos

Caractere especial : são arquivos relacionados ao I/O serial (terminais, impressoras, linhas de comunicação, etc)

Bloco especial : são relacionados ao I/O de blocos (discos)

348

Arquivos Regulares

Ex : executável UNIX» n mágico identifica arquivo como

executável

Nro mágicoText sizeData sizeBss sizS. table sreEntry point//////////////////////////TextDataRelocaçãoT. símbolos

16 bits

header

349

Operações sobre arquivos

create

delete

open

close

read

write

append

seekget attributesset attributesrename

350

Chamadas de sistema

Exemplo de programa que utiliza chamadas de sistema

/* copia source para destino */#include <sys/types.h>#include <fcntl.h>#include <stdlib.h>#include <unistd.h>

#define DUP_SIZE 4096 /* unidade de R/W */#define MODE 0666 /* modo de RW-RW-RW- */

main (int argc, char *argv[]){

int src,dst,in,out;char buf[BUF_SIZE];if(argc!=3) exit();

/* abre src e cria dest */

src = open(argv[1],O_rdONLY);if(src<0) exit();dst = create(argv[2],MODE);if(dst<0) exit();

/*copia do arquivo*/

while(1){in = read(src,buf,BUF_SIZE);if(in<=0) break;out = write(dst,buf,in);if(out<=0) break;

}close(src);close(dst);}

351

Diretórios

Contém informações que permitem acessar aos arquivos

Possui várias entradas, uma por arquivo

Informações sobre cada arquivo:

nometipotamanhoproprietárioproteção

data de criaçãodata da última modificaçãolista de blocos usados

352

Organização de diretórios

Cada entrada contém o nome e os atributos do arquivo

Cada entrada contém o nome do arquivo e um ponteiro para uma estrutura de dados com os atributos

353

Organização de diretórios

games atribmail atribprogs atrib

gamesmailprogs

Estrutura de dadoscontendo os atributos

354

Quantidade de diretórios

Um único diretório contendo os arquivos de todos os usuários

Um diretório por usuário

355


C

A

D

B

A

root

B

E F

root

C

G

...

356


Normalmente existe um diretório por usuário

Cada usuário pode criar diretórios

357


R

A B C

B2A1 B1 C1 C2 C3

Sistema de arquivos hierárquico

358

UNIX

Estrutura hierárquica– Ex : abrir o diretório /usr/ast/cap1

1 .1 ..4 bin7 dev

14 lib9 etc6 usr8 tmp

root

modotamanho

data132…………

6 .1 ..

726 ast

I-node 6/usr Bloco 132

359

UNIX

modotamanho

data406…………

26 .6 ..64 cap111 cap2

102 cap381 cap413 cap5

modotamanho

data191…………

I-node 26/ast Bloco 406

I-node 64cap1

360

Nomes

Absolutos: consiste do caminho desde o root até o arquivo

Relativo: utilizado juntamente com o conceito de diretório corrente. Todos os nomes de arquivo que não começam com o separador (/,\), são considerados relativos ao diretório corrente. Ex. Se o diretório corrente é mail, o comando cpusu1 usu1_message copia o arquivo /usr/spool/mail/usu1 para o arquivo /usr/spool/mail/usu1_message

361

Operações em diretórios

Create

delete

list

rename

362

Armazenamento de Arquivos

Alocação Contígua– Ex: arquivo com 150k, blocos de 1k, seriam

alocados 150 blocos consecutivos ao arquivo» simples de implementar

» o arquivo pode ser lido de maneira eficiente

– Problemas: determinar o tamanho do arquivo a priori

– fragmentação externa

363

Armazenamento de arquivos

Lista encadeada– Ex: bloco de 1k, 1022 bytes armazenam

informações, 2 bytes endereçam o próximo bloco

– Problema : ? - acesso randômico

364

Lista encadeada com tabela na memória

Cada apontador de bloco de disco é armazenado em uma tabela na memória

Para identificar um bloco não é necessário nenhum acesso a disco (acesso randômico)

365


Bloco físico

Arquivo A

Arquivo B

0

1

2 10

3 11

4 7

5

6 3

7 2

8

9

10 12

11 14

12 0

13

14 0

15

Lista encadeada com tabela na memória

366


Nós-I - nós índice– associa a cada arquivo uma tabela

– nó-I - tem atributos do arquivo endereços de blocos

– primeiros blocos - endereço no nó-I

– arquivos grandes» bloco indireto simples

» bloco indireto duplo

» bloco indireto triplo

367


UNIX– cada arquivo possui uma tabela (i-node) no

disco

– cada i-node possui informações sobre o arquivo e o endereço de 10 blocos (os primeiros)

– possui um bloco de indireção

– possui um bloco de dupla indireção

– possui um bloco de tripla indireção

368


Indireção: se bloco possui 1M, e são necessários 4 bytes para endereçar um bloco, contém 256 blocos: tamanho do arquivo: 266 blocos

Dupla Indireção: aponta para um bloco que contém 256 ponteiros (de 256 blocos cada) tamanho do arquivos:

. 266 + 2562 = 65.802 blocos

Tripla Indireção: 16 Gigabytes

369

Compartilhamento de arquivos

O diretório contém a lista dos blocos que pertencem ao arquivo– é feita uma cópia dos blocos para o diretório do

arquivo “link”

– Problema: não existe compartilhamento, mudanças em uma versão não são vistas em outra

370


Soluções– 1a. Solução: os blocos não fazem parte do

diretório, mas sim de estruturas de dados associadas aos descritores. O diretório aponta para essa estrutura de dados

– 2a. Solução: “link” simbólico - o diretório contém o nome do arquivo “linkado”

371

Problema da primeira solução

Owner: Ccount: 1

Owner: Ccount: 2

C C B

arquivo arquivo

372

Problema da primeira solução

Se C deleta o arquivo:

Owner: Ccount: 1

B

arquivo

problema

373


Segunda solução– não existe o problema de deleção do arquivo

por parte do proprietário

– Problema: número de acessos a disco pode ser elevado

– Vantagem: link de arquivos em máquinas diferentes

374

Problemas dos “links”

Ex: copiar um diretório completo para gerar um backup (um arquivo “link” será copiado mais de uma vez)

375

Gerência de blocos livres

Lista de blocos livres– consiste em manter uma lista linkada de blocos

livres

– Ex: Bloco de 1k, 2 bytes para identificar bloco livre, cada bloco contém 512 entradas. Quantos blocos são necessários para manter a lista de um disco de 80M?

376

Gerência de blocos livres

Mapa de bits– um disco com n blocos necessita um mapa de n

bits

– blocos livres representados por 1, ocupados por 0.

– Quantos blocos de 1k são necessários para um disco de 80M?

377

Deadlock

378

Deadlock

Modelo de sistema

Um sistema consiste de um número finito de recursos a ser distribuído entre um número de processos competindo pelos mesmos

Recursos

São quaisquer entidades que puderem ocasionar bloqueio de processos. Um bloqueio ocorre quando um recurso não está disponível e é requisitado por um processo. Ex. de recursos:

Dispositivos de E/SMemóriaregião crítica

379

Deadlock

Deadlock

É uma situação na qual processos estão bloqueados à espera de recursos que jamais serão liberados

Exemplo clássico de deadlock

P1: ... R (R1); ... R(R2); ... L(R1,R2)P2: ... R (R2); ... R(R1); ... L(R1,R2)

O deadlock ocorre quando os dois processos adquirem o primeiro recurso que necessitam

380

Deadlock

Tipos de recursos

Serialmente reusáveisConstituídos de um número fixo de unidades idênticas,

cada uma podendo ser utilizada de forma independente das demais. Após uma unidade ter sido utilizada por um processo, pode ser reutilizada por outro, de forma serial. Cada unidade pode estar em um dos seguintes estados:

alocadadisponível

381

Deadlock

Recursos consumíveis

São constituídos por um número variado de unidades que são criadas e consumidas dinamicamente pelos processos. Os processos que produzem as unidades são denominados produtores e os processos que consomem as unidades são denominados consumidores.

São características dos sistemas de processos cooperantes (trocas de mensagens, sinas de sincronização)

382

Deadlock

Condições necessárias para a ocorrência de dealock

Quando um processo que já tem um recurso puder requisitar um outro recurso

Quando os recursos não puderem ser confiscados temporariamente para serem alocados a outros processos

Quando for possível a formação de um ciclo no qual cada processo está bloqueado à espera de recursos que estão alocados para outros processos de mesmo ciclo

383

Deadlock

RepresentaçãoP1

P2

alocação

alocaçãorequisição

R2R1

P1

P2 possui uma unidade de R1

R1

P2

P1

R1

P2

P1 requisita duas unidades de R1R1

P2P1

P1 adquire duas unidades deR1

384

Deadlock

Métodos para tratamento de deadlock

1- Detectar2- Eliminar as condições necessárias3- Evitar4- Recuperar

385

Deadlock

Detecção de deadlocks

É possível, pela análise dos grafos, determinar se existe um deadlock.“ Existe deadlock se as requisições para alguns processos nunca serão atendidas ”

Redução de grafos

É uma maneira simples de examinar grafos para determinar se existe deadlock“ Um grafo pode ser reduzido em relação a um processo se todas as requisições do processo podem ser garantidas ”

386

Deadlock

“ Os processos que não podem ser reduzidos são os que estão em deadlock “

Teorema:“ Não existe processos em deadlock se e somente se o grafo é completamente redutível “

387

Deadlock

Podemos reduzir o grafo por P1 porque suas requisições podem ser garantidas a redução é feita retirando-se as arestas de/para o processo

P1

P2

R2R1

P1

P2

R2R1

O grafo foi completamente reduzido

P1

P2

R2R1

P2 pode, agora, ter suas requisições atendidas

388

Deadlock

Algoritmo de detecção de deadlock

um único recurso com muitas unidadesestruturas de dados

REQ

1 number of processes

.......

ALLOC


.......

REDUCED


.......

AVAIL: número de unidades presentemente disponíveis

389

DeadlockAlgoritmo

beginfor (i=1 to numberofprocess)

reduced(i) := false,reducedprocess:=0;

“ Repeti até que não seja mais possível reduzir “loop

exit when not reductionreduction := false;for ( P = 1 to numberofprocess) {

if (not reduced(P)) {if (req(P) <= avail) then {

reduced(P) := true;reducedprocess := reducedprocess +1;reduction := true;avail := avail + aloc(P);

}}

}end loopcompletelyreduced := (reducedprocess = numberofprocess);

end;

390

DeadlockAlgoritmo para vários recursos com várias unidades por recurso

req : matrizalloc : matrizavail : vetor

R0 R1 R2

P0P1P2

P0

P1P2

0 1 2

Requisição

Alocação

0

10

11

0

000

100

Avail

110

000

391

DeadlockAlgoritmo para vários recursos com várias unidades por recurso

req : matrizalloc : matrizavail : vetor

A linha if (req(P) <= avail) then é substituída porreducedbyp := truefor (R = 1; R <= numberofressources; R++) {

if req(P)(R) > avail(R) then {reducedbyp := false;

}if (reducedbyp) then

A linha avail := avail + aloc(P); é substituída porfor (R = 1; R <= numberofressources; R++) {

avail(R) := avail(R) + aloc(P)(R);}

392

Deadlock

Quando executar o algoritmo

Quando uma requisição não pode ser satisfeitaQuando existe suspeita de deadlock

Ex: Um processo está bloqueado há muito tempo

393

DeadlockRecuperação de deadlock

Quando o algoritmo de detecção de deadlock determina a existência de um deadlock, muitas ações são possíveis:a) Terminação de processos

Terminar todos os processosreexecução

escolher uma vítima por vez até que o deadlock seja eliminado

escolher criteriosamentereexecutar o algoritmo de detecção

Problema da reexecução de um processonem sempre é possívelex. atualização de base de dados

394

Deadlock

Recuperação de deadlock

b) Preempção de recursosRecursos são retirados de processos no ciclo e entregues a outros, no mesmo ciclo, até que o deadlock seja eliminado.Problema: A escolha da vítima

c) RollbackOs processos possuem checkpoints, em que,

periodicamente, o estado é gravado em um arquivo (imagem de memória, recursos)

quando um deadlock é detectado, o processo é rolledback até antes de pedir um recurso

o recurso é atribuído a um outro processo no ciclo

395

Deadlock

Eliminar condições necessárias

Previne-se situações de deadlock eliminando-se pelo menos uma das condições necessárias para sua ocorrência

a) Quando um processo que já tem um recurso pode solicitar outro

esta condição é eliminada se todo processo solicitar todos os recursos necessários antes de iniciar a execução

396

Deadlock

Eliminar condições necessáriasb) Quando os recursos não podem ser confiscados temporariamente para serem alocados a outros processos

Um processo pode requisitar e liberar recursos, mas quando requisitar um recurso não disponível deve liberar os que estava utilizando e, então solicitar todos coletivamente

c) Quando é possível a formação de um ciclo no qual cada processo esta bloqueado a espera de recursos que estão alocados para outros processos do mesmo ciclo

esta condição é eliminada se os recursos existentes são hierarquizados e os processos são obrigados a solicitá-los na ordem crescente dessa hierarquia

397

Deadlock

Conj. recursos

r = { r1, r2, r3, ... ,rn}função f = r -> N onde N é o conjunto dos números naturaisf(disco) = 1f(fita) = 2f(impressora) = 3

Processo que requisita r(I) somente pode requisitar r(j) se e somente se f(rj) > f(ri) ou somente requisita rj após liberar rise f(ri) > f(rj)

398

Deadlock

Evitar deadlocksabordagem: aumentar informação sobre o uso de recursos

Os recursos são requisitados quando necessáriosO sistema deve decidir se a requisição pode ser atendida

sem gerar deadlockOs algoritmos necessitam que os processos declarem o

máximo de recursos, de cada tipo, necessários

399

Deadlock

Estado seguro/não seguro

Se o sistema consegue alocar recursos para cada processo, em alguma ordem, e ainda evitar deadlock, o estado é seguro“ O estado é seguro se existe uma seqüência segura ““ O estado é não seguro se não existe uma seqüência segura ““ O estado de deadlock é um estado não seguro ““ Nem todo estado não seguro é um estado de deadlock “

400

Deadlock

Estado seguro/não seguro

Com a informação de número máximo de recursos necessários para cada processo é possível construir um algoritmo que assegura que o sistema nunca entrará em deadlock

O algoritmo examina dinamicamente o estado de alocaçãode recursos para assegurar que não existe uma espera circular

O estado de alocação é definida pelo número de disponíveis, alocados e demanda máxima de cada processo

401

DeadlockExemplo

Possui MáximoP0 3 10P1 2 4P2 2 8Número de unidades do recurso:12, disponível:5



402

Deadlock

Suponhamos que:

P1 solicita duas unidades, é atendido e termina, liberando as quatro unidades que possuía

O número de unidades disponíveis é 4P0 solicita 5 unidadesP2 solicita 5 unidades

DEADLOCK

O sistema passou de um estado seguro para não seguro

403

Deadlock

Algoritmo para evitar deadlocks

Baseado no estadoDijkstra 1965Banker`s algorithm

404

DeadlockProc Tape Printer DriverP0 2 0 0P1 0 0 0P2 1 1 1P3 1 1 0

Matriz alocaçãoP0 1 1 1P1 2 1 1P2 0 0 0P3 1 0 1

Matriz necessidadeP0 3 1 1P1 2 1 1P2 1 1 1P3 2 1 1

Matriz máximo1 0 0vetor disponível

405

Deadlock

Estrutura de dados

Available: Vetor que indica o número de unidades disponíveis de cada tipo de recurso

Max: Matriz que define, para cada processo, o número máximo de unidades, de cada tipo de recurso, necessárias

Allocation: Matriz que define o número de unidade, de cada tipo de recurso, alocadas presentemente para cada processo

Need: Matriz que indica o número de unidades, de cada recurso, necessárias para cada processo (Max_Allocation)

406

Deadlock

Deadlock

Para uma requisição request (P,i) = k o processo P esta solicitando k unidades do recurso iif (request(P,i) <= need(P,i)) {

if (request(P,i) <= available(i)) {available(i) = available(i) - k;allocation(P,i) = allocation(P,i) + k;need(P,i) = need(P,i) - k;

}safe_state();

} elseerro;

407

Deadlock

Safe_state: Estrutura de dados:temp: vetorFinish: vetortemp[i] = available[i];finish[i] = false; “para todo i “continue = true;while(continue) {

continue = false;if (need(i) <= temp(i) and finish(i) = false) {

temp(i) = temp(i) + allocation(i);finish(i) = true;continue = true;

}}if finish(i) = true para todo i then

o sistema esta em um estado safe

408

Estudo de Casos

410

Unix

Shell

núcleo

hardware

411

Conteúdo

1 - Histórico

2 - Visão do Usuário

3 - Serviços do sistema

4 - Arquitetura do sistema

Entidades: Arquivos

Processos

5 - Bibliografia

412

Visão do usuário

Sistema de arquivos– Hierárquico– Criação / destruição de arquivos– Crescimento dinâmico de arquivos– Proteção

Exercício: fazer um programa COPY

413

Visão do usuário (cont.)

Ambiente de execução– Programa: arquivo executável– Processo: programa em execução– Processos solicitam os serviços do núcleo

com o uso de chamadas de sistema. Ex.: fork, exec, etc.

Exercício: fazer um programa com fork

414

Shell

Interface entre o usuário e o sistemaInterpretador de comandosExecuta:– comandos simples– comandos compostos– redirecionamento de I/O– pipe– if then else; for; while;– etc;

415

Shell (cont.)

Funcionamento: (detalhar)while (1) {

ler comando;criar filho para executar;}

Exercício: fazer um shell simplificado

416

Serviços do Sistema

Controlar processos;Escalonar;Alocar / liberar memória;Gerenciar memória secundária;E / S.

417

Arquitetura do Sistema

Biblioteca

Interface

Comunicação

Hardware

Sub-sistema

de gerência

de processos


Scheduling


Cache

Carac. Blocos

Programas

Nível Núcleo

Nível Usuário

418

Arquivos

419

Representação Interna dos Arquivos

Fornecida por um i-node;I-node: contém a descrição do arquivo;Cada arquivo contém um i-node;Mais de um nome pode estar associado a um i-node;O sistema gerencia os arquivos com três tabelas:– Tabela de arquivos abertos: uma por processo– Tabela de arquivos: global – Tabela de i-nodes: global

420

Tabelas usadas para acesso aos arquivos

Tab. I-nodesTab. Arq. Abertos Tab. Arquivos

421

I-nodes

Proprietário;Tipo de arquivo (ordinário, diretório, bloco especial, caracter especial, fifo(pipe));Direitos de acesso;Datas de acesso (acesso, modificação, modificação de i-node);Número de links;Lista de blocos;Tamanho do arquivo;

422

I-nodes (cont.)

– Proprietário– Grupo

– Tipo– Permissões

– Acessado– Modificado

– Tamanho– Blocos de dados

JoséParsysOrdinárioRWX R_X R_X08 July 1999 21:0008 July 1999 21:007820 bytes32,27,85,31,84,92,23,55,30,77IndireçãoDupla indireçãoTripla indireção

423

I-node na Memória

Estado do I-node– Bloqueado / não bloqueado– Processos bloqueados

Número do periférico;Número do i-node;Contador de referências;

424

Estrutura do sistema de arquivos

Boot: contém o código de boot;Super bloco: descreve o sistema de arquivos (lista de blocos livres, número de arquivos, tamanho das outras áreas);Lista de i-nodes: configurável pelo administrador, referenciados por um índice.

boot super bloco lista i-nodes blocos dados

425

Tamanho dos arquivos

10 blocos diretos (1 K) = 10 K1 indireto c/ 256 diretos = 256 K1 duplo indireto c/ 256 diretos = 64 M1 tripla indireção c/ 256 dupla indireção= 16 G

426

Conversão de um caminho de acesso em um i-node

(/usr/parsys/ep/artigo)

/

ctc

pass

usr 12

I-node 12proprietário

134

bloco 134

ep 25

jn

im

Direitos de acesso

427

Conversão de um caminho de acesso em um i-node (cont.)

Bloco 256

(artigo)

pum 5

mpi 11

artigo 13

aulas 27

prog 89

I-node 25

prop

direitos

tipo

256

I-node 13(artigo)

prop

direitos

tipo

bloco 0

bloco 1

428

Chamadas de Sistema

open

closeread

writecreate

mkdircd

pipe

429

open

fd = open ( nome, modo );transformar “nome” em i-nodeif (ñ existe ou acesso ñ permitido)

return (erro);Alocar uma entrada da Tabela de ArquivosAtribuir à Tabela de Arquivos o i-nodeInicializar contador de deslocamentoAlocar uma entrada na Tabela de AAAtribuir à TAA o índice da Tabela de ArquivosReturn( índice da TAA )

430

open (cont.)

TAA T-Arquivos T-Inodes

012

T-Arquivos: - apontador p/ tabela de i-nodes- deslocamento (byte corrente)- direito (leitura / escrita)- contador de referências

431

pipe

Alocar um i-nodeAlocar um elemento da tabela de arquivos (em escrita)Alocar um elemento da tabela de arquivos (em leitura)Inicializar o contador de referência do i-node em 2Alocar um par de entradas em TAA (processo)Atribuir os elementos da tabela de arquivosRetornar (elementos da TAA)

432

Exemplo de Programamain() {

int fds (2);

char c ;pipe (fds);

pid = fork () ;

if pid != 0 {for ( ; ; ){

c = getchar () ;

write (fds (1),&c, sizeof (char)));}

else {

read ( fds (0), &c, sizeof (char));printf (“%c\n”, c) ;

}

}

433

Processos

434

Controle de processos

fork

kill

exec

exit

wait

435

exec

acessar o arquivoverificar se é executávelalocar memória (código, dados, pilha)efetuar a carga liberar a região de memória usada anteriormente

436

fork

fork()– Cria uma cópia exata do processo original,

incluindo registradores, descritores de arquivos, etc;

– Cada processo tem seu próprio espaço de endereçamento;

– Retorna um valor (zero para o filho, o piddo filho para o pai);

437

fork (cont.)

Procurar uma entrada livre na tabela de processos;Alocar memória;Copiar a imagem do pai para o filho;Colocar no descritor o mapa de memória do filho;Fabricar um pid para o filho;Sinalizar ao pai final de operação;

438

Exemplo de uso: shell

While (1){

read_command ( command, par );pid = fork();

if (pid != 0)if not background wait();

else exec(command, par);

}

Sistemas_Operacionais_Parte4

Documents

Transcript of Sistemas_Operacionais_Parte4