MOS 4th Respostas

21/08/2021 SISTEMAS OPERACIONAIS MODERNOS
Página 1
MODERNO
OPERATIVO
SISTEMAS
QUARTA EDIÇÃO
SOLUÇÕES DE PROBLEMAS
ANDREW S. TANENBAUM
HERBERT BOS
Vrije Universiteit
Amsterdã, Holanda
PRENTICE HALL
RIO SELIM SUPERIOR, NJ 07458
https://translate.googleusercontent.com/translate_f 1/81
© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.
Página 2
Copyright Pearson Education, Inc. 2014
Página 3
SOLUÇÕES PARA O CAPÍTULO 1 PROBLEMAS
1. Um sistema operacional deve fornecer aos usuários uma máquina estendida, e

deve gerenciar os dispositivos de E / S e outros recursos do sistema. Até certo ponto,
essas são funções diferentes.
2. Obviamente, existem muitas respostas possíveis. Aqui estão alguns.

Sistema operacional mainframe: Processamento de sinistros em uma seguradora.
Sistema operacional do servidor: serviço de conversão de voz em texto para Siri.
Sistema operacional multiprocessador: Edição e renderização de vídeo.
Sistema operacional de computador pessoal: aplicativo de processamento de texto.
Sistema operacional de computador portátil: sistema de recomendação baseado em contexto.
Sistema operacional embutido: Programação de um gravador de DVD para gravação de TV.
Sistema operacional do nó do sensor: Monitorando a temperatura em uma área selvagem.
Sistema operacional em tempo real: Sistema de controle de tráfego aéreo.
Sistema operacional de cartão inteligente: Pagamento eletrônico.
3. Em um sistema de compartilhamento de tempo, vários usuários podem acessar e realizar cálculos
em um sistema de computação simultaneamente usando seus próprios terminais. Multipro-
Os sistemas de gramática permitem que um usuário execute vários programas simultaneamente. Tudo
os sistemas de compartilhamento de tempo são sistemas de multiprogramação, mas nem todos os multiprogramas
sistemas de gerenciamento são sistemas de compartilhamento de tempo, uma vez que um sistema de multiprogramação pode
executado em um PC com apenas um usuário.
4. A evidência empírica mostra que o acesso à memória exibe o princípio da localidade

de referência, onde se um local for lido, então a probabilidade de acessar
locais próximos é muito alto, particularmente os seguintes locais de memória
ções. Assim, ao armazenar em cache uma linha inteira de cache, a probabilidade de um acerto de cache a seguir é
aumentou. Além disso, o hardware moderno pode fazer uma transferência em bloco de 32 ou 64 bytes
em uma linha de cache muito mais rápido do que ler os mesmos dados como palavras individuais.
5. A principal razão para a multiprogramação é dar à CPU algo para fazer
enquanto espera a conclusão da E / S. Se não houver DMA, a CPU está totalmente ocupada
tentou fazer I / O, então não há nada a ganhar (pelo menos em termos de utilidade da CPU
zação) por multiprogramação. Não importa quanto I / O um programa faça, o
A CPU estará 100% ocupada. Isso, é claro, assume que o maior atraso é a espera
enquanto os dados são copiados. Uma CPU poderia fazer outro trabalho se o I / O fosse lento para
outros motivos (chegar em uma linha serial, por exemplo).
6. O acesso a dispositivos de E / S (por exemplo, uma impressora) é normalmente restrito a diferentes usuários.
Alguns usuários podem ter permissão para imprimir quantas páginas quiserem, alguns usuários
pode não ter permissão para imprimir, enquanto alguns usuários podem estar limitados a imprimir
apenas um certo número de páginas. Essas restrições são definidas pelo administrador do sistema
tratadores com base em algumas políticas. Essas políticas precisam ser aplicadas para que o usuário
os programas de nível não podem interferir neles.
Página 4
2 SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 1
7. Ainda está vivo. Por exemplo, a Intel faz CPUs Core i3, i5 e i7 com uma variedade
variedade de propriedades diferentes, incluindo velocidade e consumo de energia. Todos esses
as máquinas são arquitetonicamente compatíveis. Eles diferem apenas no preço e por
força, que é a essência da ideia de família.
8. Uma tela de texto monocromática de 25 × 80 caracteres requer um buffer de 2.000 bytes. o

O bitmap colorido de 24 bits de 1200 × 900 pixels requer 3.240.000 bytes. Em 1980 estes
duas opções teriam custado $ 10 e $ 15.820, respectivamente. Para preços atuais,
verifique quanto de RAM custa atualmente, provavelmente centavos por MB.
9. Considere a justiça e o tempo real. Justiça requer que cada processo seja allo-
cado seus recursos de uma forma justa, sem processo obtendo mais do que o seu justo
compartilhado. Por outro lado, o tempo real requer que os recursos sejam alocados com base
nos momentos em que diferentes processos devem completar sua execução. Um verdadeiro
o processo de tempo pode obter uma parcela desproporcional dos recursos.
10. A maioria das CPUs modernas oferece dois modos de execução: modo kernel e usuário
modo. A CPU pode executar todas as instruções em seu conjunto de instruções e usar
todos os recursos do hardware ao executar no modo kernel. No entanto, pode
execute apenas um subconjunto de instruções e use apenas um subconjunto de recursos quando
ecutando no modo de usuário. Ter dois modos permite que os designers executem programas de usuário
gramas no modo de usuário e, assim, negar-lhes o acesso às instruções críticas.
11. Número de cabeças = 255 GB / (65536 * 255 * 512) = 16

Número de pratos = 16/2 = 8
O tempo para a conclusão de uma operação de leitura é tempo de busca + latência rotacional +
tempo de transferência. O tempo de busca é de 11 ms, a latência rotacional é de 7 ms e o
o tempo de transferência é de 4 ms, portanto, a transferência média leva 22 ms.
12. As opções (a), (c) e (d) devem ser restritas ao modo kernel.
13. Pode demorar 20, 25 ou 30 ms para concluir a execução desses programas de

pendente de como o sistema operacional os programa. Se P0 e P1 são programados
usado na mesma CPU e P2 está programado na outra CPU, levará 20
mseg. Se P0 e P2 estão programados na mesma UCP e P1 está programado na
outra CPU, demorará 25 mseg. Se P1 e P2 estão programados na mesma CPU
e P0 está programado na outra UCP, levará 30 mseg. Se todos os três estiverem ligados
a mesma CPU, levará 35 mseg.
14. A cada nanossegundo uma instrução emerge do pipeline. Isso significa que
máquina está executando 1 bilhão de instruções por segundo. Não importa nada
quantos estágios o pipeline tem. Um pipeline de 10 estágios com 1 nseg por estágio
também executaria 1 bilhão de instruções por segundo. Tudo o que importa é como
frequentemente, uma instrução concluída aparece no final do pipeline.
Página 5
SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 1 3
15. Tempo médio de acesso =

0,95 × 1 nseg (a palavra está no cache)
+ 0,05 × 0,99 × 10 nseg (a palavra está na RAM, mas não no cache)
+ 0,05 × 0,01 × 10.000.000 nseg (apenas palavra no disco)
= 5001,445 nseg
= 5,001445 μ seg
16. Talvez. Se o autor da chamada recuperar o controle e substituir os dados imediatamente,
quando a gravação finalmente ocorrer, os dados errados serão gravados. No entanto, se o
o driver primeiro copia os dados para um buffer privado antes de retornar, então o chamador
pode continuar imediatamente. Outra possibilidade é permitir o
chamador para continuar e dar um sinal quando o buffer pode ser reutilizado, mas isso
é complicado e sujeito a erros.
17. Uma instrução trap muda o modo de execução de uma CPU do modo de usuário
para o modo kernel. Esta instrução permite que um programa de usuário invoque funções
no kernel do sistema operacional.
18. A tabela de processos é necessária para armazenar o estado de um processo que está atualmente suspenso
suspenso, pronto ou bloqueado. Sistemas modernos de computadores pessoais têm
dezenas de processos em execução, mesmo quando o usuário não está fazendo nada e nenhum pro
gramas estão abertos. Eles estão verificando se há atualizações, carregando e-mail e muitos outros
coisas, em um sistema UNIX, use o comando ps -a para vê-los. Em um Windows
sistema, use o gerenciador de tarefas.
19. A montagem de um sistema de arquivos faz com que todos os arquivos já estejam no diretório do ponto de montagem
inacessível, portanto, os pontos de montagem normalmente estão vazios. No entanto, um administrador de sistema
trator pode querer copiar alguns dos arquivos mais importantes normalmente localizados em
o diretório montado para o ponto de montagem para que possam ser encontrados em seus
caminho incorreto em uma emergência quando o dispositivo montado estava sendo reparado.
20. A bifurcação pode falhar se não houver slots livres restantes na tabela de processo (e possivelmente se
não há memória ou espaço de troca restante). O Exec pode falhar se o nome do arquivo fornecido
não existe ou não é um arquivo executável válido. O desvinculação pode falhar se o arquivo for
desvinculado não existe ou o processo de chamada não tem autoridade para
desvincule-o.
21. Multiplexação de tempo: CPU, placa de rede, impressora, teclado.
Multiplexação espacial: memória, disco.
Ambos: display.
22. Se a chamada falhar, por exemplo, porque fd está incorreto, ele pode retornar -1. Pode
também falham porque o disco está cheio e não é possível gravar o número de
bytes solicitados. Em uma terminação correta, ele sempre retorna nbytes .
Página 6
23. Ele contém os bytes: 1, 5, 9, 2.
24. Hora de recuperar o arquivo =

1 * 50 ms (tempo para mover o braço sobre a faixa 50)
+ 5 ms (tempo para o primeiro setor girar sob a cabeça)
+ 10/200 * 1000 ms (leitura de 10 MB)
= 105 ms
25. Arquivos especiais de bloco consistem em blocos numerados, cada um dos quais pode ser lido ou
escrito independentemente de todos os outros. É possível buscar qualquer bloco
e comece a ler ou escrever. Isso não é possível com arquivos especiais de caracteres.
26. As chamadas do sistema não têm realmente nomes, a não ser no sentido de documentação.
Quando o procedimento da biblioteca lê armadilhas para o kernel, ele coloca o número do
chamada de sistema em um registro ou na pilha. Este número é usado para indexar em um ta-
ble. Não há realmente nenhum nome usado em qualquer lugar. Por outro lado, o nome de
o procedimento da biblioteca é muito importante, uma vez que é o que aparece no pro
grama.
27. Isso permite que um programa executável seja carregado em diferentes partes do ma-
memória da chine em diferentes execuções. Além disso, permite que o tamanho do programa exceda o
tamanho da memória da máquina.
28. No que diz respeito à lógica do programa, não importa se uma chamada para um li-
procedimento brary resulta em uma chamada de sistema. Mas se o desempenho é um problema, se um
tarefa pode ser realizada sem uma chamada de sistema, o programa será executado mais rapidamente.
Cada chamada do sistema envolve tempo extra na mudança do contexto do usuário para
o contexto do kernel. Além disso, em um sistema multiusuário, o sistema operacional
pode agendar outro processo para ser executado quando uma chamada de sistema for concluída, mais
retardando o progresso em tempo real de um processo de chamada.
29. Várias chamadas UNIX não têm contrapartida na API Win32:
Link : um programa Win32 não pode se referir a um arquivo por um nome alternativo ou vê-lo em
mais de um diretório. Além disso, tentar criar um link é uma maneira conveniente
para testar e criar um bloqueio em um arquivo.
Monte e desmonte : um programa do Windows não pode fazer suposições sobre o stan-
nomes de caminho dard porque em sistemas com várias unidades de disco o nome da unidade
parte do caminho pode ser diferente.
Chmod : o Windows usa listas de controle de acesso.
Kill : os programadores do Windows não podem matar um programa com comportamento inadequado que não seja co-
operativo.
Página 7
30. Cada arquitetura de sistema tem seu próprio conjunto de instruções que pode executar.
Assim, um Pentium não pode executar programas SPARC e um SPARC não pode ex-
programas ecute Pentium. Além disso, diferentes arquiteturas diferem na arquitetura de barramento
usado (como VME, ISA, PCI, MCA, SBus, ...), bem como o tamanho da palavra do
CPU (geralmente 32 ou 64 bits). Por causa dessas diferenças de hardware, não é
viável construir um sistema operacional totalmente portátil. Altamente
sistema operacional portátil consistirá em duas camadas de alto nível - um ma-
camada dependente da quina e uma camada independente da máquina. O ma-
camada dependente de quina aborda as especificidades do hardware e deve ser im-
implantado separadamente para cada arquitetura. Esta camada fornece um uniforme
superfície na qual a camada independente da máquina é construída. A máquina-inde-
a camada pendente deve ser implementada apenas uma vez. Para ser altamente portátil, o tamanho
da camada dependente da máquina deve ser mantida o menor possível.
31. A separação da política e do mecanismo permite que os designers do sistema operacional implementem um
pequeno número de primitivos básicos no kernel. Essas primitivas são simplificadas,
porque não dependem de nenhuma política específica. Eles podem então ser usados
para implementar mecanismos e políticas mais complexos no nível do usuário.
32. A camada de virtualização apresenta maior uso de memória e processador

sobrecarga, bem como sobrecarga de desempenho aumentada.
33. As conversões são diretas:
(a) Um nanoear é 10 -9 × 365 × 24 × 3600 = 31.536 mseg.

(b) 1 metro
(c) Existem 2 50 bytes, o que corresponde a 1.099.511.627.776 bytes.
(d) É 6 × 10 24 kg ou 6 × 10 27 g.
Página 8
1. A transição do bloqueado para o funcionamento é concebível. Suponha que um processo

é bloqueado no I / O e o I / O termina. Se a CPU estiver ociosa, o processo
isso poderia ir diretamente de bloqueado para em execução. A outra transição que falta,
de pronto para bloqueado, é impossível. Um processo pronto não pode fazer I / O ou qualquer outro
outra coisa que pode bloqueá-lo. Apenas um processo em execução pode bloquear.
2. Você poderia ter um registro contendo um ponteiro para a tabela de processo atual
entrada. Quando o I / O for concluído, a CPU armazenará o estado atual da máquina em
a entrada atual da tabela de processos. Em seguida, iria para o vetor de interrupção para o
interromper o dispositivo e buscar um ponteiro para outra entrada da tabela de processo (o ser-
vice procedimento). Este processo seria então iniciado.
3. Geralmente, as linguagens de alto nível não permitem o tipo de acesso ao disco rígido da CPU
ware que é necessário. Por exemplo, um manipulador de interrupção pode ser necessário para
habilitar e desabilitar a interrupção de serviço de um determinado dispositivo, ou para manipular
dados dentro da área de pilha de um processo. Além disso, as rotinas de serviço de interrupção devem ser executadas
o mais rápido possível.
4. Existem vários motivos para usar uma pilha separada para o kernel. Dois de
eles são os seguintes. Primeiro, você não quer que o sistema operacional trave
porque um programa de usuário mal escrito não permite espaço de pilha suficiente.
Em segundo lugar, se o kernel deixa os dados da pilha no espaço de memória de um programa do usuário após
retorno de uma chamada de sistema, um usuário mal-intencionado pode ser capaz de usar esses dados para
descobrir informações sobre outros processos.
5. A chance de todos os cinco processos estarem ociosos é 1/32, então o tempo ocioso da CPU é 1/32.
6. Há espaço suficiente para 14 processos na memória. Se um processo tem um I / O de
p , então a probabilidade de que todos estejam esperando por E / S é p 14 . Equacionando isso
para 0,01, obtemos a equação p 14 = 0,01 . Resolvendo isso, obtemos p = 0,72, então
pode tolerar processos com até 72% de espera de E / S.
7. Se cada trabalho tiver 50% de espera de E / S, demorará 40 minutos para ser concluído no
ausência de competição. Se executado sequencialmente, o segundo terminará 80 min-
utes após o primeiro iniciar. Com duas tarefas, a utilização aproximada da CPU é
1 - 0,5 2 . Assim, cada um obtém 0,375 minuto de CPU por minuto de tempo real. Para
acumular 20 minutos de tempo de CPU, um trabalho deve ser executado por 20 / 0,375 minutos, ou
cerca de 53,33 minutos. Assim, executando sequencialmente, os trabalhos terminam após 80 minutos
utes, mas correndo em paralelo, eles terminam após 53,33 minutos.
8. A probabilidade de que todos os processos estejam esperando por I / O é 0,4 6, que é

0,004096. Portanto, a utilização da CPU = 1 - 0. 004096 = 0: 995904.
Página 9
9. O processo do cliente pode criar threads separados; cada tópico pode buscar um diferente
parte do arquivo de um dos servidores espelho. Isso pode ajudar a reduzir o tempo de inatividade.
Claro, há um único link de rede sendo compartilhado por todos os threads. Esse link
pode se tornar um gargalo à medida que o número de threads se torna muito grande.
10. Seria difícil, senão impossível, manter o sistema de arquivos consistente. E aí-
presume que um processo cliente envie uma solicitação ao processo servidor 1 para atualizar um arquivo.
Este processo atualiza a entrada do cache em sua memória. Pouco depois, outro
o processo do cliente envia uma solicitação ao servidor 2 para ler esse arquivo. Infelizmente, se o
arquivo também é armazenado em cache lá, o servidor 2, em sua inocência, retornará dados obsoletos. Se
o primeiro processo grava o arquivo no disco após armazená-lo em cache, e o servidor 2
verifica o disco em cada leitura para ver se sua cópia em cache está atualizada, o sistema
pode ser feito para funcionar, mas é precisamente todos esses acessos de disco que o cache
sistema está tentando evitar.
11. Não. Se um processo de thread único for bloqueado no teclado, ele não pode bifurcar.
12. Um thread de trabalho será bloqueado quando precisar ler uma página da Web do disco. Se
threads de nível de usuário estão sendo usados, esta ação irá bloquear todo o processo,
destruindo o valor do multithreading. Portanto, é essencial que os threads do kernel
são usados para permitir que alguns threads sejam bloqueados sem afetar os outros.
13. Sim. Se o servidor estiver totalmente vinculado à CPU, não há necessidade de ter vários
tópicos. Isso apenas adiciona complexidade desnecessária. Por exemplo, considere um tele
número de assistência da lista telefônica (como 555-1212) para uma área com 1 milhão
pessoas. Se cada registro (nome, número de telefone) tiver, digamos, 64 caracteres, o en-
O banco de dados de pneus ocupa 64 megabytes e pode ser facilmente mantido na memória do servidor
para fornecer pesquisa rápida.
14. Quando uma thread é parada, ela tem valores nos registradores. Eles devem ser salvos,
exatamente como quando o processo é interrompido. os registros devem ser salvos. Multiprograma-
ming threads não é diferente de processos de multiprogramação, então cada thread
precisa de sua própria área de registro para salvar.
15. Threads em um processo cooperam. Eles não são hostis um ao outro. Se rendimento-
se for necessário
geralmente para oprogramador
é o mesmo bem da aplicação, um fioocederá.
que escreve códigoAfinal,
para todos eles.
16. Threads em nível de usuário não podem ser interrompidos pelo relógio, a menos que todo o processo '
quantum foi usado (embora interrupções de clock transparentes possam acontecer).
Threads no nível do kernel podem ser eliminados individualmente. No último caso, se um
thread é executado por muito tempo, o relógio irá interromper o processo atual e, portanto, o
tópico atual. O kernel está livre para escolher um tópico diferente do mesmo proc-
essencial para executar o próximo, se assim o desejar.
Página 10
17. No caso de thread único, os acessos do cache demoram 12 ms e os erros do cache demoram
87 mseg. A média ponderada é 2/3 × 12 + 1/3 × 87. Assim, a média
a busca leva 37 ms e o servidor pode fazer cerca de 27 por segundo. Para um multi
servidor encadeado, toda a espera pelo disco é sobreposta, de modo que cada solicitação
leva 12 ms e o servidor pode processar 83 solicitações de 1/3 por segundo.
18. A maior vantagem é a eficiência. Nenhuma armadilha para o kernel é necessária para
trocar tópicos. A maior desvantagem é que, se um thread bloqueia, todo o
blocos de processo.
19. Sim, isso pode ser feito. Após cada chamada para pthread create , o programa principal poderia
faça uma junção pthread para esperar até que a thread recém-criada saia antes de criar-
ing o próximo tópico.
20. Os ponteiros são realmente necessários porque o tamanho da variável global é

desconhecido. Pode ser qualquer coisa, desde um caractere até uma matriz de ponto flutuante
números. Se o valor fosse armazenado, seria necessário dar o tamanho para criar
ate global , o que está certo, mas de que tipo deve o segundo parâmetro de
set global be, e que tipo deve ser o valor de read global ?
21. Pode acontecer que o sistema de execução esteja precisamente no ponto de bloqueio ou
desbloqueando um thread e está ocupado manipulando as filas de agendamento. Esse
seria um momento muito inoportuno para o manipulador de interrupção do relógio começar
inspecionar essas filas para ver se era hora de fazer a troca de thread, uma vez que
pode estar em um estado inconsistente. Uma solução é definir um sinalizador quando o tempo de execução
sistema é inserido. O manipulador do relógio veria isso e definiria seu próprio sinalizador, então
Retorna. Quando o sistema de tempo de execução terminasse, ele verificaria o sinalizador do relógio, consulte
que ocorreu uma interrupção de relógio, e agora execute o manipulador de relógio.
22. Sim, é possível, mas ineficiente. Um tópico que deseja fazer uma chamada de sistema primeiro
define um despertador e, em seguida, faz a chamada. Se a chamada for bloqueada, o temporizador retorna con
trol para o pacote de threads. Claro, na maioria das vezes a chamada não bloqueia,
e o cronômetro deve ser zerado. Assim, cada chamada de sistema que pode bloquear deve
ser executado como três chamadas de sistema. Se os cronômetros dispararem prematuramente, todos os tipos de
problemas se desenvolvem. Esta não é uma maneira atraente de construir um pacote de threads.
23. Sim, ainda funciona, mas ainda está ocupado esperando, é claro.
24. Certamente funciona com agendamento preventivo. Na verdade, foi projetado para isso
caso. Quando o planejamento não é preventivo, ele pode falhar. Considere o caso em
cujo turno é inicialmente 0, mas o processo 1 é executado primeiro. Vai ficar em loop para sempre e
nunca libere a CPU.
25. O problema de inversão de prioridade ocorre quando um processo de baixa prioridade está em seu
região crítica e de repente um processo de alta prioridade fica pronto e é
agendado. Se usar a espera ocupada, será executado para sempre. Com threads em nível de usuário,
não pode acontecer que um thread de baixa prioridade seja repentinamente interrompido para permitir um
Página 11
execução de thread de alta prioridade. Não há preempção. Com threads em nível de kernel
este problema pode surgir.
26. Com o agendamento round-robin funciona. Mais cedo ou mais tarde, L será executado e, eventualmente,
provavelmente deixará sua região crítica. A questão é que, com o agendamento prioritário, L nunca
consegue correr; com round robin, ele obtém uma fração de tempo normal periodicamente, então
ele tem a chance de deixar sua região crítica.
27. Cada thread chama procedimentos por conta própria, portanto, deve ter sua própria pilha para o
variáveis locais, endereços de retorno e assim por diante. Isso é igualmente verdadeiro para o nível do usuário
threads como para threads no nível do kernel.
28. Sim. O computador simulado pode ser multiprogramado. Por exemplo, enquanto
o processo A está em execução, ele lê alguma variável compartilhada. Em seguida, um simulado
O tique do relógio acontece e o processo B é executado. Ele também lê a mesma variável.
Em seguida, adiciona 1 à variável. Quando o processo A é executado, se também adiciona 1 ao
variável, temos uma condição de corrida.
29. Sim, funcionará como está. Em um determinado instante de tempo, apenas um produtor (consumidor)
pode adicionar (remover) um item para (do) buffer.
30. A solução satisfaz a exclusão mútua, uma vez que não é possível para ambos os processos
esses para estar em sua seção crítica. Ou seja, quando o turn é 0, P0 pode executar seu
seção crítica, mas não P1 . Da mesma forma, quando a curva é 1. No entanto, isso pressupõe
P0 deve ser executado primeiro. Se P1 produz algo e o coloca em um buffer, então
enquanto P0 pode entrar em sua seção crítica, ele encontrará o buffer vazio e
quadra. Além disso, esta solução requer alternância estrita dos dois processos, que
é indesejável.
31. Para fazer uma operação de semáforo, o sistema operacional primeiro desativa as interrupções.
Em seguida, ele lê o valor do semáforo. Se estiver fazendo um down e o sema-
phore é igual a zero, ele coloca o processo de chamada em uma lista de processos bloqueados
associado ao semáforo. Se estiver fazendo um up , deve verificar se há algum
os processos são bloqueados no semáforo. Se um ou mais processos são bloqueados
ed, um deles é removido da lista de processos bloqueados e executado
nable. Quando todas essas operações forem concluídas, as interrupções podem ser
ativado novamente.
32. Associado a cada semáforo de contagem estão dois semáforos binários, M , usados
para exclusão mútua, e B , usado para bloqueio. Também associado a cada
o semáforo de contagem é um contador que contém o número de até s menos o número
ber de baixo s, e uma lista de processos bloqueada nesse semáforo. Para implementar
mento para baixo , um processo primeiro ganha acesso exclusivo ao semáforos, contador,
e lista, fazendo um baixo em M . Em seguida, diminui o contador. Se for zero ou
mais, ele apenas sobe em M e sai. Se M for negativo, o processo é colocado em
a lista de processos bloqueados. Em seguida, um up é feito em M e um down é feito em
B para bloquear o processo. Para implementar -se , em primeiro lugar M é para baixo ed para obter mútua
Página 12
exclusão e, em seguida, o contador é incrementado. Se for mais do que zero, ninguém

foi bloqueado, então tudo o que precisa ser feito é se M . Se, no entanto, o contador
agora é negativo ou zero, algum processo deve ser removido da lista. Finalmente,
um up é feito em B e M nessa ordem.
33. Se o programa opera em fases e nenhum dos processos pode entrar na próxima fase
até que ambos tenham terminado a fase atual, faz todo o sentido usar um
barreira.
34. Com threads de kernel, uma thread pode bloquear em um semáforo e o kernel pode ser executado
algum outro segmento no mesmo processo. Conseqüentemente, não há problema
usando semáforos. Com threads em nível de usuário, quando um thread bloqueia em um sem-
na hora, o kernel pensa que todo o processo está bloqueado e não o executa nunca
novamente. Conseqüentemente, o processo falha.
35. É muito caro de implementar. Cada vez que qualquer variável que aparece em um
predicado no qual algum processo está aguardando mudanças, o sistema de tempo de execução deve
reavalie o predicado para ver se o processo pode ser desbloqueado. Com o
Monitores Hoare e Brinch Hansen, os processos só podem ser despertados em um sinal
nal primitivo.
36. Os funcionários se comunicam passando mensagens: pedidos, comida e sacolas em

este caso. Em termos do UNIX, os quatro processos são conectados por tubos.
37. Não leva a condições de corrida (nada se perde), mas é eficaz
ocupado esperando.
38. Vai demorar nT segundos.
39. Três processos são criados. Após a bifurcação do processo inicial, há dois processos
esses correndo, um pai e um filho. Cada um deles então se bifurca, criando dois
processos tradicionais. Em seguida, todos os processos são encerrados.
40. Se um processo ocorrer várias vezes na lista, ele obterá vários quanta por
ciclo. Esta abordagem pode ser usada para dar aos processos mais importantes uma maior
parte da CPU. Mas quando o processo é bloqueado, é melhor que todas as entradas sejam refeitas
movido da lista de processos executáveis.
41. Em casos simples, pode ser possível ver se I / O será limitante, olhando para
Código fonte. Por exemplo, um programa que lê todos os seus arquivos de entrada em buffers em
o início provavelmente não será vinculado a I / O, mas um problema de leitura e gravação
incrementalmente para um número de arquivos diferentes (como um compilador) é provável que seja
Limite de E / S. Se o sistema operacional fornece um recurso como o UNIX ps
comando que pode dizer a quantidade de tempo de CPU usado por um programa, você
pode comparar isso com o tempo total para concluir a execução do programa.
Obviamente, isso é mais significativo em um sistema em que você é o único usuário.
Página 13
42. Se o tempo de mudança de contexto for grande, então o valor quântico de tempo deve ser
proporcionalmente grande. Caso contrário, a sobrecarga da troca de contexto pode ser
bastante alto. A escolha de grandes valores quânticos de tempo pode levar a um sistema ineficiente
tem se os tempos de burst típicos da CPU forem menores que o quantum de tempo. Se contexto
a comutação é muito pequena ou insignificante, então o valor quântico de tempo pode ser escolhido
sen com mais liberdade.
43. A eficiência da CPU é o tempo útil da CPU dividido pelo tempo total da CPU.
Quando Q ≥ T , o ciclo básico é para o processo funcionar para T e sofrer um
interruptor processo para S . Assim, (a) e (b) têm uma eficiência de T / ( S + T ). Quando
o quantum é mais curto do que T , cada execução de T exigirá interruptores de processo T / Q ,
desperdiçando um tempo ST / Q . A eficiência aqui é então
T
T + ST / Q
que se reduz a Q / ( Q + S ), que é a resposta para (c). Para (d), nós apenas sub-
substitua Q por S e descubra que a eficiência é de 50%. Finalmente, para (e), como Q → 0 o
a eficiência vai para 0.
44. O trabalho mais curto primeiro é a maneira de minimizar o tempo médio de resposta.
0 < X ≤ 3: X , 3, 5, 6, 9.
3 < X ≤ 5: 3, X , 5, 6, 9.
5 < X ≤ 6: 3, 5, X , 6, 9.
6 < X ≤ 9: 3, 5, 6, X , 9.
X > 9: 3, 5, 6, 9, X .
45. Para round robin, durante os primeiros 10 minutos, cada trabalho obtém 1/5 da CPU. No
ao final de 10 minutos, C termina. Durante os próximos 8 minutos, cada trabalho recebe 1/4
da CPU, após o qual D termina. Então, cada um dos três empregos restantes
obtém 1/3 da CPU por 6 minutos, até que B termine e assim por diante. O acabamento
tempos para os cinco trabalhos são 10, 18, 24, 28 e 30, por uma média de 22 minutos.
Para agendamento de prioridade, B é executado primeiro. Após 6 minutos, está concluído. O outro
os trabalhos terminam em 14, 24, 26 e 30, por uma média de 18,8 minutos. Se os trabalhos forem executados
na ordem de A a E , eles terminam em 10, 16, 18, 22 e 30, para uma média de
19,2 minutos. Finalmente, o trabalho mais curto primeiro rende tempos de acabamento de 2, 6, 12, 20,
e 30, por uma média de 14 minutos.
46. Na primeira vez, ele obtém 1 quantum. Em execuções sucessivas, ele obtém 2, 4, 8 e 15, então
deve ser trocado 5 vezes.
47. Cada chamada de voz precisa de 200 amostras de 1 mseg ou 200 mseg. Juntos eles usam
400 ms de tempo de CPU. O vídeo precisa de 11 mseg 33 1/3 vezes por segundo para um
total de cerca de 367 mseg. A soma é 767 ms por segundo de tempo real, então o
o sistema é programável.
Página 14
48. Outro fluxo de vídeo consome 367 ms de tempo por segundo para um total de
1134 ms por segundo de tempo real, portanto, o sistema não pode ser programado.
49. A sequência de previsões é 40, 30, 35 e agora 25.

50. A fração da CPU usada é 35/50 + 20/100 + 10/200 + x / 250. Ser estar
programável, deve ser menor que 1. Portanto, x deve ser menor que 12,5 mseg.
51. Sim. Haverá sempre pelo menos um garfo grátis e pelo menos um filósofo
que pode obter os dois garfos simultaneamente. Portanto, não haverá impasse.
Você pode tentar isso para N = 2, N = 3 e N = 4 e então generalizar.
52. Cada chamada de voz é executada 166,67 vezes / segundo e usa até 1 ms por burst, então
cada chamada de voz precisa de 166,67 mseg por segundo ou 333,33 mseg para os dois
eles. O vídeo é executado 25 vezes por segundo e usa até 20 ms cada vez, por um
total de 500 ms por segundo. Juntos, eles consomem 833,33 ms por segundo,
então sobra tempo e o sistema pode ser programado.
53. O kernel pode agendar processos por qualquer meio que desejar, mas dentro de cada
processo ele executa threads estritamente em ordem de prioridade. Ao permitir que o processo do usuário seja definido
a prioridade de seus próprios threads, o usuário controla a política, mas o kernel
les o mecanismo.
54. Se um filósofo bloqueia, os vizinhos podem mais tarde ver que ela está com fome, verificando
seu estado, em teste , para que ele possa ser acordado quando os garfos estiverem disponíveis.
55. A mudança significaria que depois que um filósofo parou de comer, nenhum de seus
os vizinhos podem ser escolhidos a seguir. Na verdade, eles nunca seriam escolhidos. E aí-
pose que o filósofo 2 acabou de comer. Ele faria um teste para filósofos 1
e 3, e nenhum seria iniciado, embora ambos estivessem com fome e ambos
garfos estavam disponíveis. Da mesma forma, se o filósofo 4 terminou de comer, o filósofo 3
não seria iniciado. Nada o faria começar.
56. Variação 1: os leitores têm prioridade. Nenhum escritor pode iniciar quando um leitor está ativo.
Quando um novo leitor aparece, ele pode começar imediatamente, a menos que um escritor esteja cur-
atualmente ativo. Quando um escritor termina, se os leitores estão esperando, eles estão todos iniciados,
independentemente da presença de escritores em espera. Variação 2: os escritores têm antes
ity. Nenhum leitor pode começar quando um escritor está esperando. Quando o último processo ativo
termina, um escritor é iniciado, se houver; caso contrário, todos os leitores (se houver)
são iniciados. Variação 3: versão simétrica. Quando um leitor está ativo, novo
os leitores podem começar imediatamente. Quando um escritor termina, um novo escritor tem
ity, se alguém estiver esperando. Em outras palavras, uma vez que começamos a ler, continuamos
lendo até que não haja mais leitores. Da mesma forma, uma vez que começamos a escrever,
todos os gravadores pendentes podem ser executados.
Página 15
57. Um possível script de shell pode ser
E se [ ! –F números]; então echo 0> números; fi

contagem = 0
while (teste $ count! = 200)
Faz
contagem = ′ expr $ contagem + 1 ′
n = ′ cauda –1 números ′
expr $ n + 1 >> números
feito
Execute o script duas vezes simultaneamente, iniciando-o uma vez em segundo plano
(usando &) e novamente em primeiro plano. Em seguida, examine os números dos arquivos . Será
provavelmente começa parecendo uma lista ordenada de números, mas em algum momento
perderá sua ordem, devido à condição de corrida criada pela execução de dois policiais
s do script. A corrida pode ser evitada fazendo com que cada cópia do teste de script
para e definir um bloqueio no arquivo antes de entrar na área crítica e desbloqueá-lo
ao deixar a área crítica. Isso pode ser feito assim:
se ln números, números.lock
então
n = ′ cauda –1 números ′
expr $ n + 1 >> números
números rm.lock
fi
Esta versão irá apenas pular uma vez quando o arquivo estiver inacessível. Solução variante
ções podem colocar o processo em hibernação, aguardar muito ou contar apenas loops em
qual a operação foi bem-sucedida.
Página 16
1. Primeiro, é necessário um hardware especial para fazer as comparações e deve ser rápido,
uma vez que é usado em todas as referências de memória. Em segundo lugar, com chaves de 4 bits, apenas 16
os programas podem estar na memória imediatamente (um dos quais é o sistema operacional).
2. É um acidente. O registro de base é 16.384 porque o programa aconteceu a
ser carregado no endereço 16.384. Ele poderia ter sido carregado em qualquer lugar. O limite
registro é 16.384 porque o programa contém 16.384 bytes. Poderia ter
foi qualquer comprimento. Que o endereço de carregamento coincida exatamente com o programa
comprimento é pura coincidência.
3. Quase toda a memória deve ser copiada, o que exige que cada palavra seja
lido e reescrito em um local diferente. Ler 4 bytes leva 4 nseg, então
ler 1 byte leva 1 nseg e escrever mais 2 nseg, para um total de 2
nsec por byte compactado. Esta é uma taxa de 500.000.000 bytes / s. Para copiar 4
GB (2 232 bytes, que é cerca de 4,295 × 10 9 bytes), o computador precisa
2 32 /500, 000, 000 sec, o que é de cerca de 859 mseg. Este número é um pouco pes-
simístico porque se o buraco inicial na parte inferior da memória é k bytes, aqueles k
bytes não precisam ser copiados. No entanto, se houver muitos buracos e muitos
segmentos de dados, os furos serão pequenos, então k será pequeno e o erro no
cálculo também será pequeno.
4. O primeiro ajuste leva 20 MB, 10 MB, 18 MB. O melhor ajuste leva 12 MB, 10 MB e 9
MB. O pior ajuste requer 20 MB, 18 MB e 15 MB. O próximo ajuste leva 20 MB, 18
MB e 9 MB.
5. A memória real usa endereços físicos. Estes são os números que a memória
chips reagem no ônibus. Os endereços virtuais são os endereços lógicos que se referem
para um espaço de endereço de processo. Assim, uma máquina com uma palavra de 32 bits pode gerar
endereços virtuais de até 4 GB, independentemente de a máquina ter mais ou
menos memória do que 4 GB.
6. Para um tamanho de página de 4 KB, os pares (página, deslocamento) são (4, 3616), (8, 0) e (14,
2656). Para um tamanho de página de 8 KB, eles são (2, 3616), (4, 0) e (7, 2656).
7. (a) 8212. (b) 4100. (c) 24684.

8. Eles construíram um MMU e o inseriram entre o 8086 e o barramento. Assim todos
8086 endereços físicos foram para o MMU como endereços virtuais. O MMU
em seguida, mapeou-os em endereços físicos, que foram para o ônibus.
9. É necessário que haja um MMU que possa remapear páginas virtuais para páginas físicas.
Além disso, quando uma página não mapeada no momento é referenciada, é necessário que haja uma armadilha
para o sistema operacional para que ele possa buscar a página.
Página 17
10. Se o smartphone suportar multiprogramação, que o iPhone, Android,

e Windows phones fazem, então vários processos são suportados. Se um proc-
garfos e páginas essenciais são compartilhados entre pais e filhos, cópia na escrita
nitidamente faz sentido. Um smartphone é menor que um servidor, mas logicamente é
não tão diferente.
11. Para esses tamanhos

(a) M tem que ser pelo menos 4096 para garantir um erro TLB para cada acesso a um elemento
mento de X . Uma vez que N afeta apenas quantas vezes X é acessado, qualquer valor de
N vai fazer.
(b) M ainda deve ser de pelo menos 4.096 para garantir uma falha de TLB para cada acesso a um
elemento de X . Mas agora N deve ser maior que 64K para destruir o TLB, que
ou seja, X deve exceder 256 KB.
12. O espaço de endereço virtual total para todos os processos combinados é nv , então este
muito armazenamento é necessário para as páginas. No entanto, uma quantidade r pode estar na RAM, então
a quantidade de armazenamento em disco necessária é apenas nv - r . Este montante é muito mais
do que é necessário na prática porque raramente haverá n processos ac-
atualmente em execução e ainda mais raramente, todos eles precisarão do máximo permitido
memória virtual ed.
13. Uma falha de página a cada k instruções adiciona uma sobrecarga extra de n / k μ seg para o
média, então a instrução média leva 1 + n / k nseg.
14. A tabela de página contém 2 32 /2 13 entradas, que é 524288. Carregando a página

a tabela leva 52 mseg. Se um processo chega a 100 ms, isso consiste em 52 ms para
carregando a tabela de páginas e 48 ms para execução. Assim, 52% do tempo é gasto
carregando tabelas de páginas.
15. Nessas circunstâncias:
(a) Precisamos de uma entrada para cada página, ou 2 24 = 16 × 1024 × 1024 entradas, uma vez que
existem 36 = 48 - 12 bits no campo do número da página.
(b) Os endereços de instrução atingirão 100% no TLB. As páginas de dados terão um
100 taxa de acerto até que o programa passe para a próxima página de dados. Desde um
A página de 4 KB contém 1.024 inteiros longos, haverá uma falha de TLB e
um acesso extra à memória para cada 1.024 referências de dados.
16. A chance de um acerto é 0,99 para o TLB, 0,0099 para a tabela de páginas e 0,0001
para uma falha de página (ou seja, apenas 1 em 10.000 referências causará uma falha de página). O
o tempo efetivo de tradução do endereço em nsec é então:
0. 99 × 1 + 0. 0099 × 100 + 0. 0001 × 6 × 10 6 ≈ 602 ciclos de clock.
Observe que o tempo efetivo de tradução do endereço é bastante alto porque é domi-
nado pelo tempo de substituição de página, mesmo quando as falhas de página ocorrem apenas uma vez em
10.000 referências.
Página 18
17. Considere,
(a) Uma tabela de página multinível reduz o número de páginas reais da página ta-
ble essa necessidade de estar na memória por causa de sua estrutura hierárquica. Na verdade, em
um programa com muitas instruções e localidade de dados, só precisamos do
tabela de página de nível (uma página), uma página de instrução e uma página de dados.
(b) Aloque 12 bits para cada um dos três campos de página. O campo de deslocamento requer
14 bits para endereçar 16 KB. Isso deixa 24 bits para os campos da página. Desde cada
entrada é de 4 bytes, uma página pode conter 2 entradas de tabela de 12 páginas e, portanto, re-
requer 12 bits para indexar uma página. Portanto, alocando 12 bits para cada página
os campos abordarão todos os 2 38 bytes.
18. O endereço virtual foi alterado de (PT1, PT2, deslocamento) para (PT1, PT2, PT3,
Desvio). Mas o endereço virtual ainda usava apenas 32 bits. A configuração de bits
de um endereço virtual alterado de (10, 10, 12) para (2, 9, 9, 12)
19. Vinte bits são usados para os números de página virtual, deixando 12 para o off-
definir. Isso resulta em uma página de 4 KB. Vinte bits para a página virtual implicam 2 20
Páginas.
20. Para uma tabela de páginas de um nível, há 2 32 /2 12 ou páginas 1M necessário. Assim, o

a tabela da página deve ter 1 milhão de entradas. Para paginação de dois níveis, a tabela da página principal
tem 1K entradas, cada uma apontando para uma tabela de segunda página. Apenas dois desses
são usados. Assim, no total, apenas três entradas de tabela de página são necessárias, uma no
tabela de nível superior e uma em cada uma das tabelas de nível inferior.
21. O código e a string de referência são os seguintes
CARGA 6144, R0 1 (I), 12 (D)
PUSH R0 2 (I), 15 (D)
CALL 5120 2 (I), 15 (D)
JEQ 5152 10 (I)
O código (I) indica uma referência de instrução, enquanto (D) indica um dado
referência.
22. O tempo de instrução efetivo é 1 h + 5 (1 - h ), onde h é a taxa de acerto. Se nós

equacionar esta fórmula com 2 e resolver para h , descobrimos que h deve ser pelo menos 0,75.
23. Uma memória associativa compara essencialmente uma chave com o conteúdo de vários
registra simultaneamente. Para cada registro deve haver um conjunto de comparadores
que comparam cada bit no conteúdo do registro com a chave que está sendo pesquisada.
O número de portas (ou transistores) necessários para implementar tal dispositivo é um
função linear do número de registros, portanto, expandir o projeto ganha
sive linearmente.
Página 19
24. Com páginas de 8 KB e um espaço de endereço virtual de 48 bits, o número de

páginas é 2 48 /2 13 , que é 2 35 (cerca de 34 mil milhões).
25. A memória principal tem 2 28 /2 13 = 32.768 páginas. Uma tabela hash de 32K terá um
comprimento médio da corrente de 1. Para chegar a menos de 1, temos que ir para o próximo tamanho, 65.536
entradas. Espalhar 32.768 entradas em 65.536 slots de mesa dará uma média
comprimento da corrente de 0,5, o que garante uma pesquisa rápida.
26. Isso provavelmente não é possível, exceto para o caso incomum e não muito útil
de um programa cujo curso de execução é completamente previsível na compilação
tempo de ção. Se um compilador coleta informações sobre os locais no código de
chamadas para procedimentos, essas informações podem ser usadas no momento do link para reorganizar o
código-objeto para que os procedimentos sejam localizados próximos ao código que os chama.
Isso tornaria mais provável que um procedimento estivesse na mesma página que
o código de chamada. Claro que isso não ajudaria muito para procedimentos chamados
de muitos lugares no programa.
27. Nessas circunstâncias
(a) Cada referência apresentará falha de página, a menos que o número de quadros de página seja 512,
o comprimento de toda a sequência.
(b) Se houver 500 quadros, mapeie as páginas 0-498 para quadros fixos e varie apenas um
quadro.
28. Os frames da página para FIFO são os seguintes:

x0172333300
xx017222233
xxx01777722
xxxx0111177
Os frames da página para LRU são os seguintes:

x0172327103
xx017232710
xxx01773271
xxxx0111327
FIFO produz seis falhas de página; LRU produz sete.

29. A primeira página com um bit 0 será escolhida, neste caso D .
30. Os contadores são
Página 0: 0110110
Página 1: 01001001
Página 2: 00110111
Página 3: 10001011
Página 20
31. A sequência: 0, 1, 2, 1, 2, 0, 3. Em LRU, a página 1 será substituída pela página 3. Em

relógio, a página 1 será substituída, uma vez que todas as páginas serão marcadas e o cursor é
na página 0.
32. A idade da página é 2204 - 1213 = 991. Se τ = 400, está definitivamente fora do
conjunto de trabalho e não foi referenciado recentemente, por isso será despejado. O τ = 1000
situação é diferente. Agora a página cai dentro do conjunto de trabalho (apenas), então
não é removido.
33. Considere,
(a) Para cada bit R que é definido, defina o valor do carimbo de data / hora para 10 e limpe todos os R
bits. Você também pode alterar as entradas de (0,1) RM para (0,0 *). Então, as entradas
para as páginas 1 e 2 mudará para:
Página Carimbo de tempo V R M
0 6 1 0 0*
1 10 1 0 0
2 10 1 0 1
(b) Remova a página 3 ( R = 0 e M = 0) e carregue a página 4:
Página Carimbo de tempo V R M Notas
0 6 1 0 1
1 9 1 1 0
2 9 1 1 1
3 7 0 0 0 Alterado de 7 (1,0,0)
4 10 1 1 0 Alterado de 4 (0,0,0)
34. Considere,
(a) Os atributos são: (FIFO) tempo de carregamento; (LRU) última hora de referência; e
(Ótimo) o tempo de referência mais próximo no futuro.
(b) Existe o algoritmo de rotulagem e o algoritmo de substituição. O rótulo-
O algoritmo de criação rotula cada página com o atributo fornecido na parte a. Lá-
o algoritmo de posicionamento remove a página com o menor rótulo.
35. A latência de busca mais rotacional é de 10 mseg. Para páginas de 2 KB, o tempo de transferência
é cerca de 0,009766 mseg, para um total de cerca de 10,009766 mseg. Carregando 32 de
essas páginas levarão cerca de 320,21 mseg. Para páginas de 4 KB, o tempo de transferência é
dobrou para cerca de 0,01953 mseg, então o tempo total por página é 10,01953 mseg.
O carregamento de 16 dessas páginas leva cerca de 160,3125 mseg. Com discos tão rápidos,
tudo o que importa é reduzir o número de transferências (ou colocar as páginas
com segurança no disco).
Página 21
36. NRU remove a página 2. FIFO remove a página 3. LRU remove a página 1. Segundo
o acaso remove a página 2.
37. Compartilhar páginas traz todos os tipos de complicações e opções:

(a) A atualização da tabela de página deve ser atrasada para o processo B se ele nunca será aceito
cesse a página compartilhada ou se ele a acessa quando a página foi trocada
novamente. Infelizmente, no caso geral, não sabemos qual processo
B fará no futuro.
(b) O custo é que esse tratamento de falha de página preguiçoso pode incorrer em mais falhas de página.
A sobrecarga de cada falha de página desempenha um papel importante para determinar se
esta estratégia é mais eficiente. ( À parte : este custo é semelhante ao enfrentado por
a estratégia copy-on-write para suportar algumas chamadas de sistema fork do UNIX im-
complementações.)
38. Fragmento B desde que o código tem localidade mais espacial do que Fragmento A . o
loop interno causa apenas uma falha de página para cada outra iteração do externo
ciclo. (Haverá apenas 32 falhas de página.) [ À parte (Fragmento A ): Como um quadro
é 128 palavras, uma linha do array X ocupa metade de uma página (ou seja, 64 palavras).
A matriz inteira se encaixa em 64 × 32/128 = 16 quadros. O loop interno do código
percorre as linhas consecutivas de X para uma determinada coluna. Assim, todos os outros
a referência a X [ i ] [ j ] causará uma falha de página. O número total de falhas de página
será 64 × 64/2 = 2, 048].
39. Certamente pode ser feito.
(a) A abordagem tem semelhanças com o uso de memória flash como um dispositivo de paginação em
smartphones, exceto agora, a área de troca virtual é uma RAM localizada em um re-
servidor mote. Toda a infraestrutura de software para a área de troca virtual
teria que ser desenvolvido.
(b) A abordagem pode valer a pena, observando que o tempo de acesso do disco
drives está na faixa de milissegundos, enquanto o tempo de acesso da RAM por meio de uma rede
a conexão de trabalho está na faixa de microssegundos se a sobrecarga do software não estiver
muito alto. Mas a abordagem pode fazer sentido apenas se houver muitos ociosos
RAM no farm de servidores. E também há a questão da confiabilidade.
Uma vez que a RAM é volátil, a área de troca virtual seria perdida se o servidor remoto
ver caiu.
40. O tambor de paginação PDP-1 tinha a vantagem de não ter latência rotacional. Este salvo
meia rotação cada vez que a memória era gravada no tambor.
41. O texto tem oito páginas, os dados têm cinco páginas e a pilha tem quatro páginas. o
o programa não se encaixa porque precisa de 17 páginas de 4096 bytes. Com 512 bytes
página, a situação é diferente. Aqui, o texto tem 64 páginas, os dados são 33 páginas,
e a pilha é de 31 páginas, para um total de 128 páginas de 512 bytes, que cabe. Com
o tamanho de página pequeno está OK, mas não com o grande.
Página 22
42. O programa está obtendo 15.000 falhas de página, cada uma das quais usa 2 ms de extra
Tempo de processamento. Juntos, a sobrecarga de falha de página é de 30 segundos. Isso significa que
dos 60 segundos usados, metade foi gasta na sobrecarga de falha de página e a outra metade na execução
o programa. Se executarmos o programa com o dobro da memória, obtemos metade
tantas falhas de página de memória, e apenas 15 segundos de sobrecarga de falha de página, então o
o tempo total de execução será de 45 segundos.
43. Funciona para o programa se ele não puder ser modificado. Funciona para o
dados se os dados não podem ser modificados. No entanto, é comum que o programa
não pode ser modificado e é extremamente raro que os dados não possam ser modificados. Se o
área de dados no arquivo binário foi substituída por páginas atualizadas, na próxima vez
o programa foi iniciado, ele não teria os dados originais.
44. A instrução pode ultrapassar o limite de uma página, causando duas falhas de página apenas
para buscar a instrução. A palavra buscada também pode ultrapassar o limite de uma página,
gerando mais duas falhas, para um total de quatro. Se as palavras devem ser alinhadas em
memória, a palavra de dados pode causar apenas uma falha, mas uma instrução para carregar um
Palavra de 32 bits no endereço 4094 em uma máquina com uma página de 4 KB é legal em alguns
máquinas (incluindo o x86).
45. A fragmentação interna ocorre quando a última unidade de alocação não está cheia. Externo
a fragmentação ocorre quando o espaço é desperdiçado entre duas unidades de alocação. Em um
sistema de paginação, o espaço desperdiçado na última página é perdido para fragmentos internos
mentação. Em um sistema de segmentação puro, algum espaço é invariavelmente perdido
entre os segmentos. Isso se deve à fragmentação externa.
46. Não. A tecla de pesquisa usa o número do segmento e o número da página virtual
ber, então a página exata pode ser encontrada em uma única correspondência.
47. Aqui estão os resultados:
Endereço Culpa?
(uma) (14, 3) Não (ou 0xD3 ou 1110 0011)
(b) N/D Falha de proteção: escrever para ler / executar segmento
(c) N/D Falha de página
(d) N/D Falha de proteção: Pule para o segmento de leitura / gravação
48. Suporte geral de memória virtual não é necessário quando os requisitos de memória
de todas as aplicações são bem conhecidas e controladas. Alguns exemplos são inteligentes
cartões, processadores para fins especiais (por exemplo, processadores de rede) e incorporados
processadores. Nessas situações, devemos sempre considerar a possibilidade de
usando mais memória real. Se o sistema operacional não tivesse que suportar virtu-
memória, o código seria muito mais simples e menor. Por outro lado,
algumas ideias da memória virtual ainda podem ser exploradas com lucro, embora
com diferentes requisitos de design. Por exemplo, isolamento de programa / thread
pode estar paginando para a memória flash.
Página 23
49. Esta questão aborda um aspecto do suporte à máquina virtual. Recentemente em-
tentações incluem Denali, Xen e VMware. O obstáculo fundamental é como
alcançar desempenho quase nativo, isto é, como se o sistema operacional em execução
tinha memória para si mesmo. O problema é como mudar rapidamente para outra operação
sistema operacional e, portanto, como lidar com a TLB. Normalmente, você deseja
dê um certo número de entradas TLB para cada kernel e certifique-se de que cada kernel
opera dentro de seu contexto de memória virtual adequado. Mas às vezes o difícil
ware (por exemplo, algumas arquiteturas Intel) quer lidar com falhas TLB sem
conhecimento do que você está tentando fazer. Então, você precisa lidar com o TLB
faltar no software ou fornecer suporte de hardware para marcar entradas TLB com um
ID de contexto.
Página 24
1. Você pode subir e descer na árvore quantas vezes quiser usando '' .. ''. Alguns dos
muitos caminhos são
/ etc / passwd
/./etc/passwd
/././etc/passwd
/./././etc/passwd
/etc/../etc/passwd
/etc/../etc/../etc/passwd
/etc/../etc/../etc/../etc/passwd
/etc/../etc/../etc/../etc/../etc/passwd
2. A maneira do Windows é usar a extensão do arquivo. Cada extensão corresponde a um
tipo de arquivo e a algum programa que lida com esse tipo. Outra maneira é
lembre-se de qual programa criou o arquivo e execute esse programa. The Macin-
tosh funciona dessa maneira.
3. Esses sistemas carregaram o programa diretamente na memória e começaram a ser executados em
palavra 0, que era o número mágico. Para evitar tentar executar o cabeçalho como
código, o número mágico era uma instrução BRANCH com um endereço de destino apenas
acima do cabeçalho. Desta forma, foi possível ler o arquivo binário diretamente
no espaço de endereço do novo processo e executá-lo em 0, mesmo sem saber como
grande era o cabeçalho.
4. Para começar, se não houvesse aberto , em cada leitura seria necessário
especifique o nome do arquivo a ser aberto. O sistema então teria que buscar
o i-node para ele, embora possa ser armazenado em cache. Um problema que surge rapidamente é
quando liberar o i-node de volta ao disco. Isso pode expirar, no entanto. Seria
um pouco desajeitado, mas pode funcionar.
5. Não. Se você quiser ler o arquivo novamente, basta acessar o byte 0 aleatoriamente.
6. Sim. A renomeação de chamada não altera a hora de criação ou a hora da última
modificação, mas a criação de um novo arquivo faz com que ele obtenha a hora atual como ambos
a hora de criação e a hora da última modificação. Além disso, se o disco estiver quase
cheio, a cópia pode falhar.
7. A parte mapeada do arquivo deve começar no limite da página e ser uma parte integrante
número de páginas de comprimento. Cada página mapeada usa o próprio arquivo como suporte
armazenar. A memória não mapeada usa um arquivo temporário ou partição como armazenamento de apoio.
8. Use nomes de arquivo como / usr / ast / file . Embora pareça um caminho hierárquico
nome, é realmente apenas um único nome contendo barras incorporadas.
Página 25
9. Uma maneira é adicionar um parâmetro extra para a chamada de sistema de leitura que informa qual anúncio
vestido para ler. Na verdade, cada leitura tem um potencial para fazer uma busca
dentro do arquivo. As desvantagens deste esquema são (1) um parâmetro extra em
cada chamada de leitura e (2) exigir que o usuário acompanhe para onde o arquivo aponta
er é.
10. O componente dotdot move a pesquisa para / usr , então ../ast a coloca em / usr / ast .
Portanto ../ast/x é igual a / usr / ast / x .
11. Uma vez que o armazenamento desperdiçado está entre as unidades de alocação (arquivos), não dentro
eles, isso é fragmentação externa. É precisamente análogo ao externo
fragmentação da memória principal que ocorre com um sistema de troca ou um sistema
tem usando segmentação pura.
12. Se um bloco de dados for corrompido em um sistema de alocação contíguo, apenas este
o bloco é afetado; o restante dos blocos do arquivo podem ser lidos. No caso de
alocação vinculada, o bloco corrompido não pode ser lido; também, dados de localização sobre
todos os blocos a partir deste bloco corrompido são perdidos. Em caso de aloca-
ção, apenas o bloco de dados corrompido é afetado.
13. Demora 9 ms para iniciar a transferência. Para ler 2 13 bytes a uma taxa de transferência de 80
MB / s requer 0,0977 mseg, para um total de 9,0977 mseg. Escrever de volta leva
outro 9,0977 mseg. Portanto, a cópia de um arquivo leva 18,1954 mseg. Para compactar
metade de um disco de 16 GB envolveria a cópia de 8 GB de armazenamento, que é 2 20
arquivos. A 18,1954 ms por arquivo, isso leva 19.079,25 s, que é 5,3 horas.
Claramente, compactar o disco após cada remoção de arquivo não é uma boa ideia.
14. Se bem feito, sim. Durante a compactação, cada arquivo deve ser organizado de forma que todos
de seus blocos são consecutivos, para acesso rápido. O Windows tem um programa que
desfragmenta e reorganiza o disco. Os usuários são encorajados a executá-lo periodicamente
para melhorar o desempenho do sistema. Mas, dado o tempo que leva, correr
uma vez por mês pode ser uma boa frequência.
15. Uma câmera fotográfica digital registra um certo número de fotografias em sequência em um
meio de armazenamento não volátil (por exemplo, memória flash). Quando a câmera é reiniciada,
o meio é esvaziado. Depois disso, as imagens são gravadas uma de cada vez em se-
até que a mídia esteja cheia, momento em que são carregados em um disco
disco. Para esta aplicação, um sistema de arquivos contíguo dentro da câmera (por exemplo, em
meio de armazenamento de fotos) é o ideal.
16. O bloco indireto pode conter 128 endereços de disco. Junto com os 10 diretos
endereços de disco, o arquivo máximo tem 138 blocos. Uma vez que cada bloco tem 1 KB,
o maior arquivo tem 138 KB.
17. Para acesso aleatório, tabela / indexado e contíguo serão ambos apropriados,
embora a alocação vinculada não seja, uma vez que normalmente requer várias leituras de disco para um
dado registro.
Página 26
18. Uma vez que o tamanho do arquivo muda muito, a alocação contígua será ineficiente.
exigindo realocação de espaço em disco conforme o arquivo cresce em tamanho e compactação de
blocos livres à medida que o arquivo diminui de tamanho. Alocação vinculada e tabela / indexada
será eficiente; entre os dois, tabela / alocação indexada será mais eficaz
suficiente para cenários de acesso aleatório.
19. Deve haver uma maneira de sinalizar que os ponteiros do bloco de endereço contêm dados, em vez
do que ponteiros. Se sobrar um pouco em algum lugar entre os atributos, ele pode
ser usado. Isso deixa todos os nove ponteiros para dados. Se os ponteiros tiverem k bytes cada,
o arquivo armazenado pode ter até 9 k bytes de comprimento. Se nenhum pedaço sobrar entre os
tributos, o primeiro endereço de disco pode conter um endereço inválido para marcar o seguinte
ing bytes como dados em vez de ponteiros. Nesse caso, o arquivo máximo é de 8 k
bytes.
20. Elinor está certa. Ter duas cópias do i-node na tabela ao mesmo tempo é
um desastre, a menos que ambos sejam somente leitura. O pior caso é quando ambos estão sendo
atualizado simultaneamente. Quando os i-nodes são gravados de volta no disco,
o que for escrito por último apagará as alterações feitas pelo outro,
e os blocos do disco serão perdidos.
21. Os links físicos não requerem nenhum espaço extra em disco, apenas um contador no i-node para
acompanhe quantos são. Links simbólicos precisam de espaço para armazenar o nome
do arquivo apontado. Links simbólicos podem apontar para arquivos em outras máquinas,
mesmo na Internet. Links físicos são restritos a apontar para arquivos dentro de seus
própria partição.
22. Um único i-node é apontado por todas as entradas de diretório de links físicos para um determinado
Arquivo. No caso de soft-links, um novo i-node é criado para o soft-link e este
inode essencialmente aponta para o arquivo original sendo vinculado.
23. O número de blocos no disco = 4 TB / 4 KB = 2 30. Assim, cada bloco ad-

vestido pode ser de 32 bits (4 bytes), a potência mais próxima de 2. Assim, cada bloco pode
armazenar 4 KB / 4 = 1.024 endereços.
24. O bitmap requer B bits. A lista livre requer bits DF . A lista livre requer
menos bits se DF < B . Alternativamente, a lista livre é mais curta se F / B <1 / D ,
onde F / B é a fração de blocos livres. Para endereços de disco de 16 bits, a lista livre
é menor se 6% ou menos do disco estiver livre.
25. O início do bitmap é semelhante a:
(a) Depois de escrever o arquivo B : 1111 1111 1111 0000

(b) Após excluir o arquivo A : 1000 0001 1111 0000
(c) Depois de escrever o arquivo C : 1111 1111 1111 1100
(d) Após a exclusão do arquivo B : 1111 1110 0000 1100
Página 27
26. Não é um problema sério de forma alguma. O reparo é direto; só leva tempo.
O algoritmo de recuperação é fazer uma lista de todos os blocos em todos os arquivos e
pegue o complemento como a nova lista livre. No UNIX, isso pode ser feito por scan-
ning todos os i-nodes. No sistema de arquivos FAT, o problema não pode ocorrer porque
não há lista gratuita. Mas mesmo que houvesse, tudo o que teria que ser feito para
recuperá-lo é digitalizar o FAT à procura de entradas gratuitas.
27. A tese de Ollie pode não ter o backup tão confiável quanto ele gostaria. Uma cópia de segurança
programa pode passar por cima de um arquivo que está aberto para gravação, como o estado de
os dados em tal arquivo podem ser indeterminados.
28. Eles devem controlar a hora do último despejo em um arquivo no disco. Em cada
despejo, uma entrada é anexada a este arquivo. No momento do despejo, o arquivo é lido e o
hora da última entrada anotada. Qualquer arquivo alterado desde então é despejado.
29. Em (a) e (b), 21 não seria marcado. Em (c), não haveria mudança. Em
(d), 21 não seriam marcados.
30. Muitos arquivos UNIX são curtos. Se todo o arquivo couber no mesmo bloco que o i-
nó, apenas um acesso ao disco seria necessário para ler o arquivo, em vez de dois, como
é atualmente o caso. Mesmo para arquivos mais longos haveria um ganho, uma vez que um
menos acessos ao disco seriam necessários.
31. Não deveria acontecer, mas devido a um bug em algum lugar pode acontecer. Isso significa
que algum bloqueio ocorre em dois arquivos e também duas vezes na lista livre. O primeiro passo
reparar o erro é remover ambas as cópias da lista gratuita. Próximo um grátis
bloco tem que ser adquirido e o conteúdo do bloco doente deve ser copiado lá. Final-
ly, a ocorrência do bloqueio em um dos arquivos deve ser alterada para se referir a
a cópia recém-adquirida do bloco. Neste ponto, o sistema está mais uma vez
consistente.
32. O tempo necessário é h + 40 × (1 - h ). O enredo é apenas uma linha reta.

33. Neste caso, é melhor usar um cache write-through, pois ele grava dados no
disco rígido enquanto atualiza o cache. Isso irá garantir que o arquivo atualizado
está sempre no disco rígido externo, mesmo se o usuário remover acidentalmente o
disco rígido antes que a sincronização do disco seja concluída.
34. A técnica de leitura antecipada de bloco lê blocos sequencialmente, antes de seu uso,
para melhorar o desempenho. Neste aplicativo, os registros provavelmente
não pode ser acessado sequencialmente, uma vez que o usuário pode inserir qualquer ID de aluno em um determinado
instante. Portanto, a técnica de leitura antecipada não será muito útil neste cenário.
35. Os blocos atribuídos a f1 são: 22, 19, 15, 17, 21.
Os blocos atribuídos a f2 são: 16, 23, 14, 18, 20.
Página 28
36. A 15.000 rpm, o disco leva 4 ms para girar uma vez. O acesso médio
o tempo (em ms) para ler k bytes é então 6 + 2 + ( k / 1, 048, 576) × 4. Para blocos
de 1 KB, 2 KB e 4 KB, os tempos de acesso são cerca de 6,0039 mseg, 6,0078
mseg e 6,0156 mseg, respectivamente (quase nenhuma diferença). Isso dá taxas
de cerca de 170,556 KB / s, 340,890 KB / s e 680,896 KB / s, respectivamente.
37. Se todos os arquivos tivessem 1 KB, cada bloco de 4 KB conteria um arquivo e 3 KB

de espaço desperdiçado. Tentar colocar dois arquivos em um bloco não é permitido porque o
a unidade usada para controlar os dados é o bloco, não o semibloco. Isto leva a
75% de espaço desperdiçado. Na prática, todo sistema de arquivos tem arquivos grandes, bem como
muitos pequenos, e esses arquivos usam o disco com muito mais eficiência. Para ex-
amplo, um arquivo de 32.769 bytes usaria 9 blocos de disco para armazenamento, dado um efeito de espaço
ficiência de 32.769 / 36.864, que é cerca de 89%.
38. O bloco indireto pode conter 1024 endereços. Adicionado aos 10 endereços diretos,
existem 1034 endereços ao todo. Uma vez que cada um aponta para um bloco de disco de 4 KB, o
o maior arquivo tem 4.235.264 bytes
39. Ele restringe a soma de todos os comprimentos de arquivo a não ser maior que o disco.
Esta não é uma restrição muito séria. Se os arquivos fossem coletivamente maiores que
o disco, não haveria lugar para armazenar todos eles no disco.
40. O i-node contém 10 ponteiros. O único bloco indireto contém 1.024 ponteiros.
O bloco indireto duplo é bom para 1024 2 ponteiros. O bloco indireto triplo
é bom para 1024 3 ponteiros. Somando isso, obtemos um tamanho máximo de arquivo de
1.074.791.434 blocos, o que corresponde a cerca de 16,06 GB.
41. As seguintes leituras de disco são necessárias:
diretório para /
i-node para / usr
diretório para / usr
i-node para / usr / ast
diretório para / usr / ast
i-node para / usr / ast / cursos
diretório para / usr / ast / cursos
i-node para / usr / ast / cursos / os
diretório para / usr / ast / cursos / os
i-node para /usr/ast/courses/os/handout.t
No total, são necessárias 10 leituras de disco.

42. Alguns profissionais são os seguintes. Primeiro, nenhum espaço em disco é desperdiçado em i-nodes não utilizados.
Em segundo lugar, não é possível ficar sem i-nodes. Terceiro, menos movimento do disco é
necessário, pois o i-node e os dados iniciais podem ser lidos em uma operação. Algum
os contras são os seguintes. Primeiro, as entradas do diretório agora precisarão de um endereço de disco de 32 bits
em vez de um número de i-nó de 16 bits. Em segundo lugar, um disco inteiro será usado até mesmo para
Página 29
arquivos que não contêm dados (arquivos vazios, arquivos de dispositivo). Terceiro, a integração do sistema de arquivos
as verificações de segurança serão mais lentas devido à necessidade de ler um bloco inteiro para cada
i-node e porque i-nodes estarão espalhados por todo o disco. Quarto, arquivos
cujo tamanho foi cuidadosamente projetado para caber no tamanho do bloco não caberá mais
o tamanho do bloco devido ao i-node, atrapalhando o desempenho.
Página 30
1. Na figura, vemos os controladores e dispositivos como unidades separadas. A razão é para

permitem que um controlador lide com vários dispositivos e, assim, elimine a necessidade de
ter um controlador por dispositivo. Se os controladores se tornarem quase livres, então
ser mais simples apenas construir o controlador no próprio dispositivo. Este projeto irá
também permite várias transferências em paralelo e, portanto, oferece melhor desempenho.
2. Fácil. O scanner produz 400 KB / s no máximo. A rede sem fio funciona
a 6,75 MB / s, então não há problema algum.
3. Não é uma boa ideia. O barramento de memória é certamente mais rápido do que o barramento de E / S,
sábio, por que se preocupar com isso? Considere o que acontece com uma memória normal re-
busca. O barramento de memória termina primeiro, mas o barramento de E / S ainda está ocupado. Se a CPU
espera até que o barramento de E / S termine, ele reduziu o desempenho da memória para o de
o barramento de E / S. Se ele apenas tentar o barramento de memória para a segunda referência, ele falhará
se este for uma referência de dispositivo de E / S. Se houvesse alguma maneira de
abortar instantaneamente a referência de barramento de I / O anterior para tentar o segundo, o
a melhoria pode funcionar, mas nunca existe essa opção. Ao todo, é um
péssima ideia.
4. Uma vantagem de interrupções precisas é a simplicidade do código no sistema operacional
pois o estado da máquina está bem definido. Por outro lado, em imprecisas,
terrupts, os escritores de SO têm que descobrir quais instruções foram parcialmente ex-
ecutado e até que ponto. No entanto, interrupções precisas aumentam a complexidade
do design do chip e da área do chip, o que pode resultar em uma CPU mais lenta.
5. Cada transação de barramento tem uma solicitação e uma resposta, cada uma levando 50 nseg, ou 100
nsecé por
um bomtransação de barramento.
para 4 bytes, Issotem
o barramento dá que
10 milhões de 40
lidar com transações defato
MB / s. O ônibus / s. Se
de que cada
estes
transações podem ser pulverizadas em cinco dispositivos de E / S em rodízio é
irrelevante. Uma transação de barramento leva 100 nseg, independentemente de ser consecutiva
as solicitações são para o mesmo dispositivo ou dispositivos diferentes, portanto, o número de canais
o controlador DMA não importa. O ônibus não sabe ou não se importa.
6. (a) Modo palavra por vez: 1000 × [( t 1 + t 2 ) + ( t 1 + t 2 ) + ( t 1 + t 2 )]

Onde o primeiro termo é para adquirir o ônibus e enviar o comando para o
controlador de disco, o segundo termo é para transferir a palavra, e o terceiro termo
é para o reconhecimento. Ao todo, um total de 3.000 × ( t 1 + t 2 ) nseg.
(b) Modo burst: ( t 1 + t 2 ) + t 1 + 1000 vezes t 2 + ( t 1 + t 2 )

onde o primeiro termo é para adquirir o ônibus e enviar o comando para o
controlador de disco, o segundo termo é para o controlador de disco adquirir o barramento, o
o terceiro termo é para a transferência em rajada, e o quarto termo é para adquirir o ônibus
e fazendo o reconhecimento. Ao todo, um total de 3 t 1 + 1002 t 2 .
Página 31
7. A cópia de memória para memória pode ser realizada emitindo primeiro um comando de leitura
que irá transferir a palavra da memória para o controlador DMA e, em seguida, emitir um
escreva para a memória para transferir a palavra do controlador DMA para um diferente
endereço na memória. Este método tem a vantagem de que a CPU pode fazer outras
trabalho útil em paralelo. A desvantagem é que esta cópia de memória para memória
é provável que seja lento, uma vez que o controlador DMA é muito mais lento do que a CPU e o
a transferência de dados ocorre no barramento do sistema, ao contrário do dedicado
Barramento de memória da CPU.
8. Uma interrupção requer o envio de 34 palavras para a pilha. Retornando do interior
terrupt requer a busca de 34 palavras da pilha. Esta sobrecarga sozinha é de 340
nsec. Assim, o número máximo de interrupções por segundo não é mais do que
cerca de 2,94 milhões, assumindo nenhum trabalho para cada interrupção.
9. A taxa de execução de uma CPU moderna é determinada pelo número de instruções
ções que terminam por segundo e tem pouco a ver com a duração de uma instrução
leva. Se uma CPU pode terminar 1 bilhão de instruções / s, é uma máquina de 1000 MIPS,
mesmo que uma instrução leve 30 nseg. Assim, geralmente há pouca tentativa de
faça as instruções terminarem rapidamente. Segurando a interrupção até a última instrução
As finalizações em execução no momento podem aumentar a latência das interrupções consideravelmente.
Além disso, alguma administração é necessária para fazer isso direito.
10. Poderia ter sido feito no início. Uma razão para fazer isso no final é que o
o código do procedimento de serviço de interrupção é muito curto. Pela primeira saída de outro
seu caractere e, em seguida, reconhecendo a interrupção, se outra interrupção acontecer
imediatamente, a impressora estará funcionando durante a interrupção, fazendo com que imprima
ligeiramente mais rápido. Uma desvantagem desta abordagem é um tempo morto ligeiramente mais longo
quando outras interrupções podem ser desabilitadas.
11. Sim. O PC empilhado aponta para a primeira instrução não buscada. Todas as instruções
antes que tenha sido executado e a instrução apontada e seu
cessores não foram executados. Esta é a condição para interrupções precisas.
Interrupções precisas não são difíceis de conseguir na máquina com um único pipeline.
O problema surge quando as instruções são executadas fora de ordem, o que não é
o caso aqui.
12. A impressora imprime 50 × 80 × 6 = 24.000 caracteres / min, o que equivale a 400 caracteres
ters / seg. Cada caractere usa 50 μs de tempo de CPU para a interrupção, portanto,
a cada segundo, o overhead de interrupção é de 20 ms. Usando orientado a interrupções
E / S, os 980 ms de tempo restantes estão disponíveis para outro trabalho. Em outro
palavras, a sobrecarga de interrupção custa apenas 2% da CPU, o que dificilmente
afetar o programa em execução.
Página 32
13. O UNIX faz isso da seguinte maneira. Existe uma tabela indexada por número de dispositivo, com cada
a entrada da tabela sendo uma estrutura C contendo ponteiros para as funções de abertura,
fechar, ler e escrever e algumas outras coisas do dispositivo. Para instalar
um novo dispositivo, uma nova entrada deve ser feita nesta tabela e os ponteiros devem ser preenchidos
, geralmente para o driver de dispositivo recém-carregado.
14. (a) Driver de dispositivo.

(b) Driver de dispositivo.
(c) Software independente de dispositivo.
(d) Software de nível de usuário.
15. Um pacote deve ser copiado quatro vezes durante este processo, que leva 4,1 mseg.
Existem também duas interrupções, que são responsáveis por 2 mseg. Finalmente, a transmissão
o tempo de sessão é de 0,83 ms, para um total de 6,93 ms por 1024 bytes. O máximo
a taxa de dados é, portanto, 147.763 bytes / s, ou cerca de 12% do nominal 10
capacidade de rede megabit / s. (Se incluirmos a sobrecarga do protocolo, os números
ficar ainda pior.)
16. Se a impressora fosse atribuída assim que a saída aparecesse, um processo poderia amarrar
a impressora imprimindo alguns caracteres e depois adormecendo por uma semana.
17. O disco gira a 120 RPS, então 1 rotação leva 1000/120 mseg. Com 200 seg-
toros por rotação, o tempo do setor é 1/200 desse número ou 5/120 = 1/24 mseg.
Durante a busca de 1 ms, 24 setores passam sob a cabeça. Assim, o cilindro
a inclinação deve ser 24.
18. A 7200 RPM, existem 120 rotações por segundo, então a rotação leva cerca de
8,33 mseg. Dividindo isso por 500, obtemos um tempo de setor de cerca de 16,67 μ seg.
19. Existem 120 rotações por segundo. Durante um deles, 500 × 512 bytes passam
sob a cabeça. Assim, o disco pode ler 256.000 bytes por rotação ou 30.720.000
bytes / s.
20. RAID nível 2 não pode apenas se recuperar de unidades travadas, mas também de unidades
erros transitórios detectados. Se uma unidade entregar um único bit ruim, RAID nível 2 irá
corrija isso, mas o RAID nível 3 não.
21. A probabilidade de 0 falhas, P 0 , é (1 - p ) k . A probabilidade de 1 falha, P 1 ,

é kp (1 - p ) k −1 . A probabilidade de falha do RAID é então 1 - P 0 - P 1 . este
é 1 - (1 - p ) k - kp (1 - p ) k −1 .
22. Desempenho de leitura: RAID níveis 0, 2, 3, 4 e 5 permitem leituras paralelas para o servidor
vice um pedido de leitura. No entanto, RAID nível 1 permite ainda duas solicitações de leitura
para prosseguir simultaneamente. Desempenho de gravação: Todos os níveis de RAID fornecem simi-
desempenho de escrita lar. Sobrecarga de espaço: não há sobrecarga de espaço no nível 0
e 100% de overhead no nível 1. Com data word de 32 bits e seis drives de paridade, o
a sobrecarga de espaço é de cerca de 18,75% no nível 2. Para uma palavra de dados de 32 bits, o espaço
a sobrecarga no nível 3 é de cerca de 3,13%. Finalmente, assumindo 33 unidades nos níveis 4 e
Página 33
5, a sobrecarga de espaço é de 3,13% neles. Confiabilidade: Não há confiabilidade

suporte no nível 0. Todos os outros níveis de RAID podem sobreviver a uma falha de disco. Além disso
ção, nos níveis 3, 4 e 5, um único erro de bit aleatório em uma palavra pode ser detectado,
enquanto no nível 2, um único erro de bit aleatório em uma palavra pode ser detectado e cor-
corrigido.
23. Um zebibyte tem 2 70 bytes; um pebibyte é 2 50 . 2 20 pebibytes cabem em um zebibyte.
24. Um campo magnético é gerado entre dois pólos. Não só é difícil

tornam a fonte de um campo magnético pequena, mas também o campo se espalha rapidamente,
o que leva a problemas mecânicos tentando manter a superfície de um magnético
meio próximo a uma fonte magnética ou sensor. Um laser semicondutor gera
luz em um local muito pequeno, e a luz pode ser opticamente manipulada para iluminar
nate um ponto muito pequeno a uma distância relativamente grande da fonte.
25. A principal vantagem dos discos óticos é que eles têm uma gravação muito maior
densidades do que os discos magnéticos. A principal vantagem dos discos magnéticos é que
eles são uma ordem de magnitude mais rápidos do que os discos ópticos.
26. Possivelmente. Se a maioria dos arquivos são armazenados em setores logicamente consecutivos, pode ser
vale a pena intercalar os setores para dar aos programas tempo para processar os dados
acabado de receber, de modo que, quando a próxima solicitação for emitida, o disco estará no
lugar certo. Se isso vale a pena ou não depende fortemente do tipo de
os programas são executados e como seu comportamento é uniforme.
27. Talvez sim e talvez não. A intercalação dupla é efetivamente uma inclinação do cilindro de
dois setores. Se a cabeça pode fazer uma busca faixa a faixa em menos de dois segundos
vezes, do que nenhuma inclinação adicional do cilindro é necessária. Se não puder, adicione
a inclinação do cilindro opcional é necessária para evitar a perda de um setor após uma busca.
28. Considere,
(a) A capacidade de uma zona é de trilhas × cilindros × setores / cilindro × bytes / seita.
Capacidade da zona 1: 16 × 100 × 160 × 512 = 131072000 bytes
Soma = 131072000 + 163840000 + 196608000 + 229376000 = 720896000
(b) Uma taxa de rotação de 7200 significa que há 120 rotações / s. Em 1 ms
tempo de busca track-to-track, 0,120 dos setores são cobertos. Na zona 1, o
a cabeça do disco passará por mais de 0,120 × 160 setores em 1 ms, portanto, trilha ideal
a inclinação para a zona 1 é de 19,2 setores. Na zona 2, a cabeça do disco passará
0,120 × 200 setores em 1 ms, portanto, a inclinação ideal da trilha para a zona 2 é de 24 segundos
tor. Na zona 3, a cabeça do disco passará mais de 0,120 × 240 setores em 1 ms,
portanto, a inclinação ideal da trilha para a zona 3 é de 28,8 setores. Na zona 4, a cabeça do disco
passará mais de 0,120 × 280 setores em 1 mseg, portanto, desvio de faixa ideal para
a zona 3 é de 33,6 setores.
Página 34
(c) A taxa máxima de transferência de dados será quando os cilindros no exterior

zona (zona 4) estão sendo lidas / gravadas. Nessa zona, em um segundo, 280 seg-
tors são lidos 120 vezes. Assim, a taxa de dados é 280 × 120 × 512 = 17.203.200
bytes / s.
29. A capacidade da unidade e as taxas de transferência são duplicadas. O tempo de busca e a média
atraso rotacional são os mesmos. Nenhuma propriedade é pior.
30. Uma consequência bastante óbvia é que nenhum sistema operacional existente funcionará
porque todos eles olham lá para ver onde estão as partições do disco. Alterando a
O formato da tabela de partição fará com que todos os sistemas operacionais falhem. O
a única maneira de alterar a tabela de partição é alterar simultaneamente todas as operações
sistemas operacionais para usar o novo formato.
31. (a) 10 + 12 + 2 + 18 + 38 + 34 + 32 = 146 cilindros = 876 mseg.

(b) 0 + 2 + 12 + 4 + 4 + 36 +2 = 60 cilindros = 360 mseg.
(c) 0 + 2 + 16 + 2 + 30 + 4 + 4 = 58 cilindros = 348 mseg.
32. No pior caso, uma solicitação de leitura / gravação não é atendida por quase dois discos cheios
verifica no algoritmo do elevador, embora seja no máximo uma verificação completa do disco no
algoritmo modificado.
33. Uma desvantagem do modo one-shot é que o tempo consumido pela interrupção manual
ler não foi contabilizado porque o processo de diminuição do contador foi pausado
durante este tempo. Uma desvantagem do modo de onda quadrada é que a freqüência de alta freqüência
frequências podem resultar em múltiplas interrupções sendo enfileiradas quando novas interrupções
são gerados antes de os anteriores terem sido atendidos.
34. Não necessariamente. Um programa UNIX que lê 10.000 blocos emite os pedidos
um de cada vez, bloqueando após cada um ser emitido até depois de ser concluído. Desse modo
o driver de disco vê apenas uma solicitação por vez; não tem oportunidade de fazer qualquer-
coisa, mas processá-los na ordem de chegada. Harry deveria ter iniciado
muitos processos ao mesmo tempo para ver se o algoritmo do elevador funcionou.
35. Há uma corrida, mas não importa. Uma vez que a gravação estável em si já
concluída, o fato de que a RAM não volátil não foi atualizada significa apenas
que o programa de recuperação saberá qual bloco está sendo escrito. Será
leia ambas as cópias. Encontrá-los idênticos, não mudará nenhum, que é o
ação correta. O efeito da falha pouco antes da RAM não volátil foi
atualizado apenas significa que o programa de recuperação terá que fazer duas leituras de disco
mais do que deveria.
36. Sim, o disco permanece consistente, mesmo se a CPU travar durante um processo de recuperação
cedimento. Considere a Figura 5-31. Não há recuperação envolvida em (a) ou (e). E aí-
pose que a CPU trava durante a recuperação em (b). Se a CPU travar antes do
bloco da unidade 2 foi completamente copiado para a unidade 1, a situação
permanece o mesmo que antes. O procedimento de recuperação subsequente detectará um
Página 35
Erro ECC na unidade 1 e copie novamente o bloco da unidade 2 para a unidade 1. Se CPU
trava após o bloco da unidade 2 ter sido copiado para a unidade 1, a situação é
mesmo que no caso (e). Suponha que a CPU trave durante a recuperação em (c).
Se a CPU travar antes que o bloco da unidade 1 tenha sido completamente copiado para
unidade 2, a situação é a mesma do caso (d). A recuperação subsequente pro-
cedura irá detectar um erro ECC na unidade 2 e copiar o bloco da unidade 1 para
unidade 2. Se a CPU travar após o bloco da unidade 1 ter sido copiado para a unidade 2,
a situação é a mesma do caso (e). Finalmente, suponha que a CPU travou durante
recuperação em (d). Se a CPU travar antes que o bloco da unidade 1 tenha sido
completamente copiado para a unidade 2, a situação permanece a mesma de antes. O subse-
o procedimento de recuperação frequente detectará um erro ECC na unidade 2 e copiará novamente
o bloco da unidade 1 para a unidade 2. Se a CPU travar após o bloqueio da unidade 1
foi copiado para a unidade 2, a situação é a mesma do caso (e).
37. Os problemas surgem nos cenários mostrados na Figura 5-27 (b) e 5-27 (d), porque
eles podem se parecer com o cenário 5-27 (c), se o ECC do bloco corrompido for correto
rect. Neste caso, não é possível detectar qual disco contém o válido (antigo
ou novo), e a recuperação não é possível.
38. Dois o ms 60 vezes por segundo é 120 mseg / s, ou 12% da CPU

39. Com esses parâmetros,
(a) Usando um cristal de 500 MHz, o contador pode ser diminuído a cada 2 ns. Então,
para um tique a cada milissegundo, o registro deve ser 1000000/2 = 500.000.
(b) Para obter um tique do relógio a cada 100 μ seg., o valor do registrador de retenção deve ser 50.000.
40. No tempo 5000:

Hora atual = 5000; Próximo sinal = 8; Cabeçalho → 8 → 4 → 3 → 14 → 8.
No tempo 5005:
Hora atual = 5005; Próximo sinal = 3; Cabeçalho → 3 → 4 → 3 → 14 → 8.
No tempo 5013:
Hora atual = 5013; Próximo sinal = 2; Cabeçalho 2 → 14 → 8.
No tempo 5023:
Hora atual = 5023; Próximo sinal = 6; Cabeçalho → 6 → 4 → 5.
41. O número de segundos em um ano médio é 365,25 × 24 × 3600. Este número é

31.557.600. O contador volta ao normal após 2 32 segundos a partir de 1 de janeiro de 1970.
O valor de 2 32 / 31.557.600 é de 136,1 anos, então o empacotamento acontecerá em
2106,1, que é o início de fevereiro de 2106. Claro, até lá, todos os computadores
ter pelo menos 64 bits, então não vai acontecer de jeito nenhum.
42. Rolar a janela requer a cópia de 79 linhas de 80 caracteres ou 6320 caracteres
atores. Copiar 1 caractere (16 bytes) leva 800 nseg, então toda a janela
leva 5,056 mseg. Escrever 80 caracteres na tela leva 400 nseg, então
Página 36
a rolagem e a exibição de uma nova linha levam 5,456 mseg. Isso dá cerca de 183,2
linhas / s.
43. Suponha que o usuário inadvertidamente peça ao editor para imprimir milhares de linhas.
Em seguida, ele pressiona DEL para pará-lo. Se o driver não descartou a saída, a saída pode
continue por vários segundos após o DEL, o que faria o usuário clicar
DEL repetidamente e fica frustrado quando nada aconteceu.
44. Ele deve mover o cursor para a linha 5, posição 7 e, em seguida, excluir 6 caracteres. o
a sequência é ESC [5; 7 H ESC [6 P
45. A taxa máxima que o mouse pode se mover é 200 mm / seg, que é 2.000 mick-
eys / sec. Se cada relatório tiver 3 bytes, a taxa de saída será de 6.000 bytes / s.
46. Com um sistema de cores de 24 bits, apenas 2 24 cores podem ser representadas. Isso não é tudo
deles. Por exemplo, suponha que um fotógrafo tire fotos de 300 latas
de tinta azul pura, cada uma com uma quantidade ligeiramente diferente de pigmento. O primeiro
pode ser representado pelo valor (R, G, B) (0, 0, 1). O próximo pode ser
representado por (0, 0, 2) e assim por diante. Uma vez que a coordenada B tem apenas 8 bits,
não há como representar 300 valores diferentes de azul puro. Alguns dos
as fotografias terão que ser reproduzidas com a cor errada. Outro exemplo é
a cor (120,24, 150,47, 135,89). Não pode ser representado, apenas aproxi-
acoplado por (120, 150, 136).
47
(a) Cada pixel ocupa 3 bytes em RGB, então o espaço de mesa é 16 × 24 × 3 bytes,
que é 1152 bytes.
(b) A 100 ns por byte, cada caractere leva 115,2 μ seg. Isso dá uma saída
taxa de cerca de 8.681 caracteres / s.
48. Reescrever a tela de texto requer a cópia de 2.000 bytes, o que pode ser feito em 4
μ segundos. Reescrever a tela de gráficos requer a cópia de 1024 × 768 × 3 =
2.359.296 bytes ou cerca de 4,72 ms.
49. No Windows, o sistema operacional chama os próprios procedimentos do manipulador. No X Windows, noth-
como isso acontece. X apenas recebe uma mensagem e a processa internamente.
50. O primeiro parâmetro é essencial. Em primeiro lugar, as coordenadas são relativas a alguns
janela, portanto, hdc é necessário para especificar a janela e, portanto, a origem. Segundo,
o retângulo será cortado se cair fora da janela, então a janela será cortada
são necessários jantares. Terceiro, a cor e outras propriedades do retângulo são
retirado do contexto especificado por hdc . É absolutamente essencial.
51. O tamanho da exibição é 400 × 160 × 3 bytes, que é 192.000 bytes. A 10 fps
isto é 1.920.000 bytes / seg ou 15.360.000 bits / seg. Isso consome 15% do
Ethernet rápida.
Página 37
52. A largura de banda em um segmento de rede é compartilhada, portanto, 100 usuários solicitando
dados diferentes simultaneamente em uma rede de 1 Mbps verão cada um um efeito de 10 Kbps
velocidade efetiva. Com uma rede compartilhada, um programa de TV pode ser multicast, então o
os pacotes de vídeo são transmitidos apenas uma vez, não importa quantos usuários haja e
deve funcionar bem. Com 100 usuários navegando na web, cada usuário obterá
1/100 da largura de banda, portanto, o desempenho pode diminuir muito rapidamente.
53. As vantagens dos thin clients incluem baixo custo e nenhuma necessidade de manobras complexas
agement para os clientes. As desvantagens incluem (potencialmente) menor per-
força devido à latência da rede e (potencial) perda de privacidade porque o
os dados / informações do cliente são compartilhados com o servidor.
54. Se n = 10, a CPU ainda pode fazer seu trabalho dentro do prazo, mas a energia usada
cai apreciavelmente. Se a energia consumida em 1 segundo em velocidade total for E , então
rodando em velocidade total por 100 ms e depois inativo por 900 ms, usa E / 10.
Rodar a 1/10 da velocidade por um segundo inteiro usa E / 100, uma economia de 9 E / 100.
A porcentagem de economia cortando a tensão é de 90%.
55. O sistema de janelas usa muito mais memória para sua exibição e usa virtu-
memória al mais do que o modo de texto. Isso torna menos provável que o disco rígido
ficará inativo por um período longo o suficiente para fazer com que seja ativado automaticamente
baixado.
Página 38
1. Nos EUA, considere uma eleição presidencial na qual três ou mais candidatos
estão tentando a nomeação de algum partido. Depois que todas as eleições primárias são
finalizado, quando os delegados chegarem à convenção partidária, pode acontecer que
nenhum candidato tem maioria e nenhum delegado está disposto a mudar seu
voto. Este é um impasse. Cada candidato tem alguns recursos (votos), mas precisa
mais para fazer o trabalho. Em países com vários partidos políticos no
parlamento, pode acontecer que cada partido apoie uma versão diferente do
orçamento anual e que é impossível reunir uma maioria para aprovar o orçamento
obter. Este também é um impasse.
2. O espaço em disco na partição de spool é um recurso finito. Cada bloco que

vem de facto, reclama um recurso e cada novo que chega quer mais
origens. Se o espaço de spool for, digamos, 10 MB e a primeira metade de dez 2 MB
os trabalhos chegarem, o disco ficará cheio e não será possível armazenar mais blocos, então temos um
impasse. O impasse pode ser evitado permitindo que um trabalho comece a ser impresso antes de
antes que seja totalmente enrolado e reservando o espaço assim liberado para o resto do
trabalho. Desta forma, um trabalho será realmente impresso até a conclusão, depois o próximo
pode fazer a mesma coisa. Se os trabalhos não puderem começar a ser impressos até que estejam totalmente no spool,
impasse é possível.
3. A impressora não é preemptiva; o sistema não pode começar a imprimir outro trabalho
até que o anterior seja concluído. O disco de spool é preemptivo; você pode
exclua um arquivo incompleto que esteja ficando muito grande e peça ao usuário para enviá-lo
mais tarde, supondo que o protocolo permita isso.
4. Sim. Não faz qualquer diferença.
5. Suponha que existam três processos, A , B e C , e dois tipos de recursos, R

e S . Além disso assumir que existem um exemplo de R e duas exemplo de S .
Considere o seguinte cenário de execução: A solicita R e o obtém; Pedidos B
S e obtém; C solicita S e o obtém (há duas instâncias de S ); B solicita R
e está bloqueado; A solicita S e é bloqueado. Nesta fase, todas as quatro condições
espera. No entanto, não há impasse. Quando C termina, uma instância de S é re-
alugado que está atribuída a um . Agora A pode completar sua execução e liberar R
que pode ser alocado para B , que pode então concluir sua execução. Estes quatro
as condições são suficientes se houver um recurso de cada tipo.
6. '' Não bloqueie a caixa '' é uma estratégia de pré-alocação, negando o bloqueio e espera
pré-condição de impasse, uma vez que assumimos que os carros podem entrar no espaço da rua após
diminuindo a interseção, liberando assim a interseção. Outra estratégia pode
permitir que os carros parem temporariamente nas garagens e libere espaço suficiente para limpar
o impasse. Algumas cidades têm uma política de controle de tráfego para moldar o tráfego; como cidade
as ruas ficam mais congestionadas, os supervisores de trânsito ajustam as configurações para vermelho
luzes a fim de controlar o tráfego que entra em áreas muito congestionadas. Trafego mais leve
Página 39
fic garante menos competição por recursos e, portanto, diminui a probabilidade de

travamento ocorrendo.
7. A anomalia acima não é um impasse de comunicação, uma vez que esses carros são independentes
pendentes um do outro e passariam pelo cruzamento com um mínimo
atrasar se não houver competição. Não é um impasse de recursos, uma vez que nenhum carro é
segurando um recurso que é solicitado por outro carro. Nem seria o mecânico
ismos de pré-alocação de recursos ou de preempção de recursos auxiliam no controle
esta anomalia. Esta anomalia é de sincronização de competição, no entanto, em
quais carros estão esperando por recursos em uma corrente circular e estrangulamento do tráfego
pode ser uma estratégia eficaz de controle. Para distinguir de recursos mortos
bloqueio, esta anomalia pode ser denominada um '' impasse de agendamento. '' Um impasse semelhante
bloqueio poderia ocorrer seguindo uma lei que exigia que dois trens se fundissem em um shar-
ed a ferrovia para esperar que a outra prossiga. Observe que um policial assinou
finalizar um dos carros ou trens concorrentes para prosseguir (e não os outros) pode
quebrar este estado morto sem reversão ou qualquer outra sobrecarga.
8. É possível que um processo contenha algumas ou todas as unidades de um recurso
digite e solicita outro tipo de recurso, enquanto outro processo mantém o sec-
segundo recurso ao solicitar as unidades disponíveis do primeiro tipo de recurso. Se
nenhum outro processo pode liberar unidades do primeiro tipo de recurso e o recurso
não pode ser antecipado ou usado simultaneamente, o sistema está em um impasse. Para ex-
amplo, dois processos são células de memória alocadas em um sistema de memória real
tem. (Presumimos que a troca de páginas ou processos não é suportada, enquanto
solicitações dinâmicas de memória são suportadas.) O primeiro processo bloqueia outro
recurso - talvez uma célula de dados. O segundo processo solicita os dados bloqueados
e está bloqueado. O primeiro processo precisa de mais memória para executar o
código para liberar os dados. Assumindo que nenhum outro processo no sistema pode
completa e libera células de memória, existe um deadlock no sistema.
9. Sim, existem gráficos ilegais. Afirmamos que um recurso só pode ser detido por um pecador
processo gle. Um arco de um quadrado de recurso para um círculo de processo indica que
o processo possui o recurso. Assim, um quadrado com arcos indo dele para dois
ou mais processos significa que todos esses processos contêm o recurso, o que viola
lates as regras. Consequentemente, qualquer gráfico em que vários arcos deixam um quadrado
e terminar em círculos diferentes viola as regras, a menos que haja várias cópias
dos recursos. Arcos de quadrados a quadrados ou de círculos a círculos também
violar as regras.
10. Nenhuma das mudanças leva a um impasse. Não há espera circular em nenhum dos casos.
11. Considere três processos, A , B e C e dois recursos R e S . Suponha que A seja
esperando por I que é mantido por B , B está esperando por S mantido por A , e C está esperando
para R realizada por um . Todos os três processos, A , B e C estão em impasse. No entanto,
apenas A e B pertencem à cadeia circular.
Página 40
12. Este é claramente um impasse de comunicação e pode ser controlado por ter um
tempo limite e retransmitir sua mensagem de habilitação (aquela que aumenta o ganho
tamanho inferior) após algum período de tempo (uma heurística). É possível, no entanto, que
B recebeu a mensagem original e duplicada. Nenhum dano irá ocorrer
agora se a atualização no tamanho da janela é fornecida como um valor absoluto e não como um
diferencial. Números de sequência em tais mensagens também são eficazes para detectar
duplicatas.
13. Uma parte de todos esses recursos pode ser reservada para uso apenas por processos
propriedade do administrador, então ele ou ela sempre pode executar um shell e pro
gramas necessários para avaliar um impasse e tomar decisões sobre quais processos
esses para matar para tornar o sistema utilizável novamente.
14. Primeiro, o conjunto de processos não marcados, P = ( P1 P2 P3 P4 )
R1 não é menor ou igual a A
R2 é menor que A ; Mark P2 ; A = (0 2 0 3 1); P = ( P1 P3 P4 )
R3 é igual a A ; Mark P3 ; A = (0 2 0 3 2); P = ( P1 P4 )
Assim, os processos P1 e P4 permanecem não marcados. Eles estão em um impasse.
15. Recuperação por preempção: Após a conclusão dos processos P2 e P3 , processe

P1 pode ser forçado a antecipar 1 unidade de RS3 . Isso fará com que A = (0 2 1 3 2),
e permitir que o processo P4 seja concluído. Uma vez que P4 é concluído e libera seu re-
fontes P1 podem ser concluídas. Recuperação por meio de rollback: Rollback P1 para o
estado verificado antes de adquirir RS3 . Recuperação por meio de matar proc-
esses: Mate P1 .
16. O processo está pedindo mais recursos do que o sistema possui. Não há
forma concebível ele pode obter esses recursos, de modo que nunca pode terminar, mesmo se não
outros processos precisam de quaisquer recursos.
17. Se o sistema tivesse duas ou mais CPUs, dois ou mais processos poderiam ser executados em par-
alelo, levando a trajetórias diagonais.
18. Sim. Faça tudo em três dimensões. O eixo z mede o número

de instruções executadas pelo terceiro processo.
19. O método só pode ser usado para orientar o agendamento no instante exato em
qual um recurso vai ser reivindicado é conhecido com antecedência. Na prática, este
raramente é o caso.
20. Existem estados que não são seguros nem bloqueados, mas que levam a um deadlock
estados bloqueados. Por exemplo, suponha que temos quatro recursos: fitas, plotters,
scanners e CD-ROMs, como no texto, e três processos competindo por
eles. Podemos ter a seguinte situação:
Página 41
Tem Precisa Disponível

A: 2000 1020 0121
B: 1000 0131
C: 0121 1010
Este estado não é bloqueado porque muitas ações ainda podem ocorrer, por exemplo,
A ainda pode obter duas impressoras. No entanto, se cada processo solicitar seu restante,
peculiaridades, temos um impasse.
21. Um pedido de D não é seguro, mas um de C é seguro.

22. O sistema está livre de deadlock. Suponha que cada processo tenha um recurso.
Existe um recurso gratuito. Qualquer um dos processos pode solicitá-lo e obtê-lo, no qual
caso ele possa terminar e liberar ambos os recursos. Consequentemente, o impasse é im-
possível.
23. Se um processo tiver m recursos, ele pode terminar e não pode estar envolvido em um deadlock.
Portanto, o pior caso é quando cada processo tem m - 1 recursos e
precisa de outro. Se sobrar um recurso, um processo pode terminar
e liberar todos os seus recursos, deixando o resto terminar também. Portanto, a condição
para evitar deadlock é r ≥ p ( m - 1) + 1.
24. Não. D ainda pode terminar. Quando termina, ele retorna recursos suficientes para permitir que E
(ou A ) para terminar e assim por diante.
25. Comparar uma linha na matriz com o vetor de recursos disponíveis leva m op-
erações. Esta etapa deve ser repetida na ordem de n vezes para encontrar um processo
que pode terminar e ser marcado como concluído. Assim, marcar um processo como concluído leva
na ordem de mn passos. Repetir o algoritmo para todos os n processos significa
que o número de etapas é então mn 2 . Assim, a = 1 e b = 2.
26. A matriz de necessidades é a seguinte:
01002
02100
10300
00111
Se x for 0, temos um deadlock imediatamente. Se x for 1, o processo D pode ser executado para comp
plenitude. Quando terminar, o vetor disponível é 1 1 2 2 1. Infelizmente
agora estamos em um impasse. Se x for 2, depois que D for executado, o vetor disponível será 1 1 3 2 1
e C pode ser executado. Depois de terminar e retornar seus recursos, o vetor disponível é
2 2 3 3 1, o que permitirá que B execute e conclua, e então A para executar e com-
completo. Portanto, o menor valor de x que evita um deadlock é 2.
Página 42
27. Considere um processo que precisa copiar um arquivo enorme de uma fita para uma impressora. Ser-
porque a quantidade de memória é limitada e o arquivo inteiro não cabe neste
memória, o processo terá que percorrer as seguintes instruções até
todo o arquivo foi impresso:
Adquirir unidade de fita

Copie a próxima parte do arquivo na memória (tamanho limitado da memória)
Liberar unidade de fita
Adquirir impressora
Imprimir arquivo da memória
Liberar impressora
Isso aumentará o tempo de execução do processo. Além disso, desde o
impressora é liberada após cada etapa de impressão, não há garantia de que todas as partes
do arquivo será impresso em páginas contínuas.
28. Suponha que o processo A solicite os registros na ordem a , b , c . Se processo B

também pede um primeiro, um deles vai pegar e o outro vai bloquear. este
situação está sempre livre de impasse, pois o vencedor agora pode executar até a conclusão
sem interferência. Das outras quatro combinações, algumas podem levar à morte
lock e alguns estão livres de deadlock. Os seis casos são os seguintes:
impasse abc livre
impasse acb livre
possível impasse bac
bca possível impasse
possível impasse do táxi
possível impasse cba
Uma vez que quatro dos seis podem levar a um impasse, há 1/3 de chance de evitar um
impasse e uma chance de 2/3 de conseguir um.
29. Sim. Suponha que todas as caixas de correio estejam vazias. Agora, A envia para B e espera
para uma resposta, B envia para C e espera por uma resposta, e C envia para A e espera por um
responder. Todas as condições para um impasse nas comunicações agora estão satisfeitas.
30. Para evitar a espera circular, numere os recursos (as contas) com sua conta
números. Depois de ler uma linha de entrada, um processo bloqueia o ac-
conta primeiro, então, quando ele obtém o bloqueio (o que pode implicar em espera), ele bloqueia o
outro. Uma vez que nenhum processo espera por uma conta inferior ao que já
pronto, nunca há uma espera circular e, portanto, nunca um impasse.
31. Altere a semântica de solicitar um novo recurso da seguinte maneira. Se um processo

pede um novo recurso e está disponível, obtém o recurso e guarda o que
já o fez. Se o novo recurso não estiver disponível, todos os recursos existentes estão
liberado. Com este cenário, o impasse é impossível e não há perigo
que o novo recurso é adquirido, mas os existentes perdidos. Claro, o processo
Página 43
só funciona se a liberação de um recurso for possível (você pode liberar um scanner antes de
entre páginas ou um gravador de CD entre CDs).
32. Eu daria nota F (reprovação). O que o processo faz? Uma vez que é claro
precisa do recurso, ele apenas pergunta novamente e bloqueia novamente. Isso não é melhor do que
ficando bloqueado. Na verdade, pode ser pior, pois o sistema pode acompanhar
há quanto tempo os processos concorrentes estão esperando e atribuir um re- recém-liberado
fonte para o processo que está esperando há mais tempo. Por periodicamente expirar
e tentando novamente, um processo perde sua antiguidade.
33. Tanto a memória virtual quanto os sistemas de compartilhamento de tempo foram desenvolvidos principalmente para
auxiliar os usuários do sistema. A virtualização de hardware protege os usuários dos detalhes de
fornecer necessidades, alocação de recursos e sobreposições, além de prevenir
impasse. O custo da mudança de contexto e tratamento de interrupção, no entanto, é
considerável. São necessários registros, caches e circuitos especializados. Proba-
provavelmente este custo não teria sido incorrido para fins de impasse antes
convenção sozinho.
34. Um deadlock ocorre quando um conjunto de processos são bloqueados à espera de um evento
que apenas algum outro processo no conjunto pode causar. Por outro lado, os processos
em um livelock não são bloqueados. Em vez disso, eles continuam a executar a verificação de um
condição para se tornar verdade que nunca se tornará verdade. Assim, além do
recursos que estão mantendo, processos em livelock continuam a consumir preciosos
Tempo de CPU. Finalmente, a inanição de um processo ocorre devido à presença de
outros processos, bem como um fluxo de novos processos de entrada que acabam
com maior prioridade do que o processo que está morrendo de fome. Ao contrário de impasse ou
livelock, inanição pode terminar por conta própria, por exemplo, quando processos existentes
com término de prioridade mais alta e sem novos processos com prioridade mais alta
chegar.
35. Este estado morto é uma anomalia da sincronização da competição e pode ser contra
controlada pela pré-alocação de recursos. Os processos, no entanto, não são bloqueados de
Recursos. Além disso, os recursos já são solicitados em uma ordem linear. Esse
anomalia não é um impasse de recursos; é um livelock. Pré-alocação de recursos
irá prevenir esta anomalia. Como uma heurística, os processos podem expirar e liberar
seus recursos se eles não forem concluídos dentro de algum intervalo de tempo, vá para
durma por um período aleatório e tente novamente
36. Aqui estão as respostas, embora um pouco complicadas.
(a) Esta é uma anomalia de sincronização de competição. Também é um livelock. Nós

pode chamá-lo de livelock de agendamento. Não é um livelock ou impasse de recursos,
uma vez que as estações não estão mantendo recursos que são solicitados por outros e, portanto, um
cadeia circular de estações segurando recursos enquanto solicita outros não
existir. Não é um deadlock de comunicação, uma vez que as estações estão executando inde-
pendentemente e completaria a transmissão foram programados sequencialmente.
Página 44
(b) Ethernet e Aloha com slot exigem que as estações que detectam uma colisão de
sua transmissão deve esperar um número aleatório de intervalos de tempo antes de retransmitir
mitting. O intervalo dentro do qual o intervalo de tempo é escolhido é dobrado após
cada colisão sucessiva, ajustando-se dinamicamente às cargas de tráfego pesadas. Depois
dezesseis retransmissões sucessivas um quadro é eliminado.
(c) Porque o acesso ao canal é probabilístico, e porque recém-chegado

estações podem competir e ser alocadas no canal antes das estações que têm
retransmitida algumas vezes, a inanição é ativada.
37. A anomalia não é um impasse de recursos. Embora os processos estejam compartilhando um

mutex, ou seja, um mecanismo de competição, pré-alocação de recursos e deadlock
todos os métodos de evitação são ineficazes para esse estado morto. Ordenação linear re-
fontes também é ineficaz. Na verdade, pode-se argumentar que as ordens lineares podem ser
o problema; executar um mutex deve ser a última etapa antes de entrar e o
primeiro depois de sair de uma seção crítica. Existe um estado morto circular em que
ambos os processos aguardam um evento que só pode ser causado pelo outro processo.
Este é um impasse de comunicação. Para progredir, um tempo limite funcionará para
rompa esse impasse se ele se antecipar ao mutex do consumidor. Escrevendo código cuidadoso
ou usar monitores para exclusão mútua são as melhores soluções.
38. Se ambos os programas solicitarem o Woofer primeiro, os computadores morrerão de fome com o final
menos sequência: solicitar Woofer, cancelar solicitação, solicitar Woofer, cancelar solicitação,
e assim por diante. Se um deles pede a casinha e o outro pede o cachorro,
temos um impasse, que é detectado por ambas as partes e depois quebrado, mas é
apenas repetido no próximo ciclo. De qualquer maneira, se ambos os computadores foram pro
programado para ir atrás do cachorro ou da casinha de cachorro primeiro, seja de fome ou de morte
bloqueio segue. Não há realmente muita diferença entre os dois aqui. No
maioria dos problemas de impasse, a fome não parece grave porque a introdução
atrasos aleatórios geralmente o tornam muito improvável. Essa abordagem não
trabalho aqui.
Página 45
1. Existem inúmeras razões, entre elas a consolidação de servidores para economizar recursos
custo de investimento de ware, espaço em rack e energia elétrica e gerenciamento de
de milhares de servidores mais fácil.
2. Se a configuração de hardware foi atualizada, a virtualização pode esconder isso e

permitir que o software antigo continue funcionando.
3. Existem várias razões. Um dos principais é ter muitas plataformas, como Win-
dows 7, Windows 8, Linux, FreeBSD, OS X, etc. disponíveis em um único desktop
máquina para testar o software em desenvolvimento. Além disso, reiniciando um ma virtual
chine após um travamento induzido por um bug de software é muito mais rápido.
4. Depois de atualizar para um novo computador e sistema operacional, a pessoa pode

deseja executar algum software que ele tinha no antigo. A virtualização torna isso
possível executar o sistema antigo e o novo no mesmo computador, portanto,
servindo o software antigo.
5. Muito poucos programadores tiveram acesso a um mainframe IBM. Começando no

1980, a série Intel x86 dominou a computação e não era virtualizável.
Embora a tradução binária pudesse resolver esse problema, essa ideia não foi pensada
até o final dos anos 1990.
6. Qualquer instrução que altere as tabelas de página ou mapa de memória é certamente sensível,
bem como qualquer coisa que envolva E / S. Qualquer instrução capaz de ler o verdadeiro
o estado da máquina também é sensível.
7. Existem muitos, incluindo movimentos, instruções aritméticas, salto e chamada em
estruturas, turnos, etc.
8. A virtualização completa significa emular o hardware exatamente para cada operação
sistema em execução na máquina virtual se comporta exatamente como se comportaria
metal. A paravirtualização consiste em mudar o sistema operacional para
não faça nada que seja difícil de virtualizar. Virtualização completa na ausência de
o suporte de hardware é complicado em qualquer arquitetura complexa, como o
x86. É mais fácil em máquinas RISC. Se o hardware de virtualização estiver presente, completo
a virtualização não é tão difícil. Então, o que é mais difícil provavelmente depende de
se o suporte de hardware está disponível. Se for, então paravirtualizar uma operação
sistema de gerenciamento é provavelmente mais trabalho. Se não houver suporte de hardware, pode ser
mais fácil mudar o sistema operacional para ser mais amigável. Se houver muitos
sistemas operacionais que precisam ser paravirtualizados, isso poderia dar mais trabalho.
9. Sim, claro. Linux foi paravirtualizado precisamente porque a fonte
o código está disponível. O Windows foi paravirtualizado pela Microsoft (que
o código-fonte), mas não lançou nenhuma versão paravirtualizada.
Página 46
10. As máquinas virtuais não têm nada a ver com partições de disco. O hipervisor pode
pegue uma partição de disco e divida-a em subpartições e dê a cada
máquina um deles. Em princípio, pode haver centenas. Pode ser
particione o disco em n partes ou faça isso sob demanda. Em hospedagem virtual
máquinas, é comum usar arquivos no host para armazenar imagens de disco do
hóspede.
11. Um aplicativo ou processo é virtualizado durante o tempo de execução, usando um virtu-
camada de alização entre o aplicativo e o sistema operacional. Esta camada executa o ap-
instruções de plicação, modificando-as conforme necessário antes da execução. O ap-
plicatura é transparente para a presença da camada subjacente. Windows Emu-
lator (WINE) é um exemplo, onde executáveis binários do Microsoft Windows podem
ser executado em outro sistema operacional como o Linux. Isso é feito usando
mapeamento instantâneo de chamadas de API do Windows para chamadas POSIX.
12. Os hipervisores tipo 1 geralmente requerem a alteração do procedimento de inicialização do com
computador para carregar o hipervisor primeiro, em seguida, criar máquinas virtuais e, em seguida, instalar
sistemas operacionais neles. Em centros de dados operados por administradores de sistemas especializados
tores, isso não é um problema, mas para a maioria dos usuários comuns, fazer isso é muito
complicado. Os hipervisores tipo 2 foram inventados para tornar a instalação de um hipervisor
não é mais difícil do que instalar um programa aplicativo, algo que os usuários
freqüentemente fazem. Além disso, usando um sistema operacional host para atender aos periféricos locais
als, não era necessário que o hipervisor tivesse drivers para todos eles, uma vez que
ele poderia usar aqueles dentro do sistema operacional host.
13. Sim. Quando um sistema operacional convidado faz E / S, por exemplo, o hardware de virtualização
pega e passa o controle para o hipervisor tipo 2, que então descobre
o que fazer. Normalmente, isso envolverá fazer uma solicitação ao sistema operacional host para realizar
formar o I / O, mas não ter que se preocupar com o trapping da instrução de I / O defi-
simplifica nitidamente os assuntos para o hipervisor.
14. Foi inventado nos primeiros dias, antes que o hardware de virtualização existisse. Era
necessário para evitar sistemas operacionais convidados, que estavam sendo executados no usuário
modo, de executar instruções confidenciais que não eram privilegiadas. Indo
para a frente, isso é menos necessário, pois o hardware moderno bloqueia quando um modo de usuário
programa executa uma instrução sensível. No entanto, em algumas circunstâncias, bi-
a tradução nary é mais rápida do que o trapping. No entanto, como o hardware im-
prova, a necessidade de tradução binária diminuirá.
15. Normalmente, o anel 0 (com o conjunto de privilégios mais alto) é usado para executar em ker-
modo nel; e toque 3 para o modo de usuário. Alguns hipervisores usaram o anel 0 para executar
o hipervisor no modo kernel; o sistema operacional convidado foi executado no anel 1. Quando o convidado
O sistema operacional invoca instruções privilegiadas, ele pode interceptar o hipervisor que executa
estas instruções após verificar os direitos de acesso, permissões, etc.
maneiras também são possíveis.
Página 47
16. Foi demonstrado que a abordagem de CPU habilitada para VT resulta em muitas armadilhas
devido ao uso da abordagem trap-and-emulate. Uma vez que as armadilhas são caras para
lidar, há casos em que as abordagens baseadas na tradução superam o
abordagem baseada em hardware.
17. Quando o sistema operacional convidado emite uma instrução '' Clear Interrupt '' (como CLI ), fazer
no hardware pode consumir muito tempo em algumas CPUs, como aquelas com
tubulações profundas. Por outro lado, em um sistema virtualizado, o hipervisor precisa
não desabilitar interrupções no hardware e simplesmente usar uma variável para indicar
cate que o '' Sinalizador de interrupção '' do sistema operacional convidado especificado está definido como zero, tornando-o
mais rápido para executar a instrução CLI.
18. Ele poderia traduzir todo o programa com antecedência. A razão para não fazer isso é
que muitos programas têm grandes pedaços de código que nunca são executados. Por
traduzindo blocos básicos sob demanda, nenhum código não utilizado é traduzido. Um po-
desvantagem potencial da tradução sob demanda é que ela pode ser um pouco menos
eficiente para continuar iniciando e interrompendo o tradutor, mas este efeito é provavelmente
pequena. Além disso, a análise estática e a tradução do código x86 são complicadas
devido a ramificações indiretas (ramificações cujos destinos são calculados em tempo de execução).
Isso é piorado pelas instruções de tamanho variável no x86. Assim você pode
não tenha certeza de quais instruções traduzir. Finalmente, há a questão da auto-
modificar o código.
19. Um hipervisor puro apenas emula o hardware real e nada mais. Um puro
microkernel é um pequeno sistema operacional que oferece serviços básicos para o pro-
gramas usando. As máquinas virtuais em execução em um hipervisor puro executam tradi-
sistemas operacionais tradicionais, como Windows e Linux. Em cima de um microkernel
são geralmente processos que implementam serviços do sistema operacional, mas em um
forma descentralizada.
20. Se vários sistemas operacionais convidados alocarem o que eles acham que é a página física k para um dos
seus processos, há um problema. É necessária alguma maneira para realizar um segundo
mapeamento entre as páginas porque os convidados não controlam realmente o
páginas, apesar do que eles podem pensar. É por isso que as tabelas de páginas aninhadas são necessárias.
21. A máquina não precisa apenas de memória para o sistema operacional normal (convidado)
tem e todos os seus aplicativos, mas também precisa de memória para a função de hipervisor
ções e estruturas de dados necessárias para executar instruções sensíveis em nome de
o sistema operacional convidado. Os hipervisores tipo 2 têm o custo adicional de operação do host
sistema. Além disso, cada máquina virtual terá seu próprio sistema operacional, então
haverá N cópias do sistema operacional armazenadas na memória. Uma maneira de reduzir
o uso de memória seria identificar "código compartilhado" e manter apenas uma cópia do
este código na memória. Por exemplo, uma empresa de hospedagem na Web pode executar vários
VMs, cada uma executando uma versão idêntica do Linux e uma cópia idêntica do
Código do servidor da web Apache. Neste caso, o segmento de código pode ser compartilhado entre
VMs, embora as regiões de dados devam ser privadas.
Página 48
22. Cada sistema operacional convidado manterá uma tabela de páginas que mapeia seus números de páginas virtuais para
números de quadros físicos (em sua parcela da memória virtualizada). Em ordem de
evitar que diferentes sistemas operacionais convidados façam referência incorreta ao
mesmo número de página física, o hipervisor cria uma tabela de página de sombra que
mapeia o número da página virtual da máquina virtual para o número do quadro físico
fornecido pelo hipervisor.
23. As tabelas de página podem ser modificadas apenas pelo sistema operacional convidado, não pelo aplicativo
programas de cação no hóspede. Quando o sistema operacional convidado terminar de modificar o
tabelas, ele deve voltar ao modo de usuário emitindo uma instrução sensível como
RETORNE DA ARMADILHA. Esta instrução irá interceptar e dar ao hipervisor
ao controle. Ele poderia então examinar as tabelas de página no sistema operacional convidado para ver se eles
foi modificado. Embora isso pudesse funcionar, todas as tabelas de página teriam que ser
verificado em cada sistema feito por um aplicativo convidado, ou seja, toda vez que o
o sistema operacional convidado voltou ao modo de usuário. Pode haver milhares dessas transições
por segundo, portanto, não é provável que seja tão eficiente quanto usar páginas somente leitura para o
tabela de páginas.
24. Quando um hipervisor fica sem páginas, ele não tem como descobrir quais
páginas que os sistemas operacionais convidados realmente valorizam. A solução é trapacear e
incluir motoristas de balão nos convidados. O hipervisor então sinaliza para o balão
drivers para expandir o uso de memória, forçando os sistemas operacionais convidados a
decidir quais páginas despejar. Isso é definitivamente trapaça porque o hipervisor
não deve se comunicar com partes específicas dos sistemas operacionais convidados. Isto é
não deveria saber o que está acontecendo nas máquinas virtuais. Mas isso
técnica resolve um problema de forma simples, então todos fingem que existe
nada duvidoso acontecendo.
25. Os drivers de balão não funcionam se o hipervisor não souber nada sobre
os sistemas operacionais convidados em execução em suas máquinas virtuais. Também não
trabalhar se não houver maneira de incluir um driver de balão neles, por exemplo, se eles
não suportam drivers carregáveis e o código-fonte não está disponível, então eles
não pode ser recompilado para incluir o driver de balão.
26. Considere um caso em que várias cópias de máquinas virtuais do mesmo sistema operacional convidado
residem em um sistema. Neste caso, não é necessário manter várias cópias
da parte somente leitura do sistema operacional (como segmentos de código) na memória. Somente
uma cópia precisa ser mantida, reduzindo assim os requisitos de memória e
permitindo mais máquinas virtuais em um sistema. Esta técnica é chamada de desduplicação
cátion. A VMware chama isso de '' compartilhamento de página transparente ''.
27. Sim. O hardware DMA anterior usava endereços de memória absolutos. Se um convidado opera
sistema operacional iniciou um DMA operando para o que pensava ser o endereço físico k ,
isso provavelmente não iria para o buffer que deveria ir e pode
sobrescrever algo importante. Os primeiros hipervisores tiveram que reescrever o código que
usou DMA para usar endereços que não causariam problemas.
Página 49
28. Usar serviços em nuvem significa que você não precisa configurar e manter um computador
infra-estrutura. Você também pode terceirizar a realização de backups. Pele-
além disso, se suas necessidades de computação mudarem rapidamente, você pode adicionar ou remover ma-
chines facilmente. No lado negativo, o provedor de nuvem pode facilmente roubar sua con
dados fidenciais, e a expansibilidade prometida pode ser ilusória se você precisar
capacidade extra no momento em que o Walmart ou algum outro grande cliente decidir
para pegar 10.000 máquinas. Além disso, a largura de banda entre você e a nuvem
pode ser um problema. É provável que seja muito menor do que a largura de banda local, portanto, se muito
de dados precisa se mover entre você e a nuvem, isso pode ser um problema. Além disso,
se você estiver trabalhando em tempo real, a largura de banda entre você e a nuvem
pode variar muito de momento a momento, causando problemas.
29. Obviamente, existem muitos, mas um provedor que oferece máquinas x86 virtuais vazias
estaria oferecendo IAAS. Um provedor que oferece máquinas Windows 8 ou Linux
estaria oferecendo PAAS. Um provedor que oferece um programa de processamento de texto,
como o Microsoft Word, rodando na nuvem ofereceria software como um
serviço.
30. Suponha que muitas máquinas virtuais foram inicializadas em um único servidor. Inicialmente, todos
deles faziam quase a mesma quantidade de trabalho e exigiam os mesmos recursos
e a situação estava bem. Então, de repente, um deles começou a usar mas-
recursos sive (CPU, memória, etc.) perturbando todas as outras máquinas virtuais.
Este pode ser um bom momento para migrá-lo para um servidor dedicado próprio.
31. Dispositivos físicos de I / O ainda apresentam problemas porque eles não migram com
a máquina virtual, mas seus registros podem manter o estado que é crítico para o
funcionamento adequado do sistema. Pense em operações de leitura ou gravação em dispositivos
(por exemplo, o disco) que foram emitidos, mas ainda não foram concluídos. E / S de rede
é particularmente difícil porque outras máquinas continuarão a enviar pacotes para
o hipervisor, sem saber que a máquina virtual foi movida. Mesmo se os pacotes
pode ser redirecionado para o novo hipervisor, a máquina virtual não responderá
sive durante o período de migração, que pode ser longo porque todo o sistema virtual
máquina, incluindo o sistema operacional convidado e todos os processos em execução em
ele deve ser movido para a nova máquina. Como resultado, os pacotes podem experimentar grandes
atrasos ou até mesmo perda de pacotes se os buffers do dispositivo / hipervisor estourarem.
32. Para migrar um processo específico, as informações do estado do processo devem ser armazenadas
ed e, em seguida, transferido, incluindo arquivos abertos, alarmes, manipuladores de sinais, etc. Er-
rors podem se infiltrar durante a tarefa de captura de estado, levando a potencialmente incorretos,
informações de estado incompletas ou inconsistentes. No caso de migração de VM, o
toda a memória e as imagens de disco são movidas para o novo sistema, o que é mais fácil.
33. A migração padrão (morta) consiste em parar a máquina virtual e salvar
sua imagem de memória como um arquivo. O arquivo é então transportado para o destino, em
paralisado em uma máquina virtual e reiniciado. Isso faz com que o aplicativo
pare um pouco durante o transporte. Em muitas circunstâncias, tendo o ap-
Página 50
a parada da plicatura é indesejável. Com a migração ao vivo, as páginas do ma- virtual

quinas são movidas enquanto está em execução. Depois que todos chegam ao destino, um
é feita uma verificação para ver se algum deles foi alterado desde a migração. Se então,
eles são copiados novamente. Este processo é repetido até que todas as páginas no destino
nação estão em dia. Trabalhar desta forma (migração ao vivo) significa aplicativos
pode ser movido sem tempo de inatividade.
34. Os três requisitos principais eram: Compatibilidade (capacidade de executar um existente
sistema operacional convidado sem quaisquer modificações como uma máquina virtual); Desempenho (mini-
sobrecarga incorreta durante a execução da VM; caso contrário, os usuários não escolheriam executar seus
aplicativos dentro de uma VM) e isolamento (protegendo os recursos de hardware
de acesso malicioso ou não autorizado).
35. Não havia como o VMware ter drivers para os milhares de
diferentes dispositivos de E / S existentes. Por ter VMware Workstation ser um tipo 2
hipervisor, ele poderia resolver o problema indiretamente usando os drivers já
instalado no sistema operacional host.
36. VMware ESXi foi reduzido para que possa ser colocado no firmware do
servidores. Quando o servidor é ligado, o BIOS pode então se copiar para a RAM
e comece a criar máquinas virtuais. Isso simplifica muito a inicialização e
processo de inicialização.
37. Vários exemplos podem ser encontrados em: virtualboximages.com . Estes incluem vários
ous distribuições de sistemas operacionais de código aberto pré-instalados. Para ex-
amplo, em vez de obter um ISO para um novo tipo de Linux, passe pela instalação
processo e, em seguida, colocar a VM em execução, é mais fácil baixar o pré-instalado
VDI. Existem aparelhos semelhantes que são executados no VMWare. Outros exemplos podem
ser encontrado em: http://www.turnkeylinux.org
Página 51
1. Tanto USENET quanto SETI @ home podem ser descritos como ampla área distribuída
sistemas. No entanto, USENET é realmente mais primitivo do que o esquema de
Fig. 8-1 (c), uma vez que não requer qualquer infraestrutura de rede diferente de
conexões ponto a ponto entre pares de máquinas. Além disso, uma vez que não
processamento de trabalho além do necessário para garantir a disseminação adequada de notícias
artigos, pode ser debatido se é realmente um sistema distribuído do tipo
estamos preocupados neste capítulo. SETI @ home é um exemplo mais típico
de um sistema distribuído de área ampla; os dados são distribuídos para nós remotos que
em seguida, retorne os resultados dos cálculos ao nó coordenador.
2. Dependendo de como as CPUs estão conectadas à memória, uma delas consegue

primeiro, por exemplo, pega o ônibus primeiro. Ele completa sua operação de memória, então
outro acontece, etc. Não é previsível qual vai primeiro, mas se o
sistema foi projetado para consistência sequencial, não deve importar.
3. Uma máquina de 200 MIPS emitirá 200 milhões de referências de memória / s, consum
gerando 200 milhões de ciclos de ônibus ou metade da capacidade do ônibus. Leva apenas duas CPUs
para consumir o ônibus inteiro. O armazenamento em cache diminui o número de solicitações de memória / s
para 20 milhões, permitindo que 20 CPUs compartilhem o barramento. Para colocar 32 CPUs no ônibus,
cada um dos
milhões poderia solicitar de
200 milhões nãoreferências
mais do que
de 12,5 milhões
memória vãode solicitações
para o ônibus, o/ s. Se apenas 12,5
a taxa de perda de cache deve ser 12,5 / 200 ou 6,25%. Isso significa que a taxa de acerto é
93,75%.
4. As CPUs 000, 010, 100 e 110 são desligadas das memórias 010 e 011.
5. Cada CPU gerencia seus próprios sinais completamente. Se um sinal for gerado a partir de
o teclado e o teclado não estão atribuídos a nenhuma CPU em particular (o usual
caso), de alguma forma o sinal deve ser enviado para a CPU correta para ser manuseada.
6. Para emitir uma chamada de sistema, um processo gera uma armadilha. A armadilha interrompe seu próprio
CPU. De alguma forma, a informação de que uma CPU escrava teve uma armadilha deve ser
transmitido para a CPU mestre. Isso não acontece no primeiro modelo. Se lá
são instruções trap interprocessador, isso pode ser usado para sinalizar o mestre. Se não
tais instruções existem, o escravo pode coletar os parâmetros da chamada do sistema
e colocá-los em uma estrutura de dados na memória que o mestre pesquisa continuamente
quando está ocioso.
7. Aqui está uma solução possível:
insira a região:
TST LOCK | Teste o valor do bloqueio
JNE ENTRE NA REGIÃO | Se for diferente de zero, tente novamente
TSL REGISTER, LOCK | Copie o bloqueio para registrar e definir o bloqueio para 1
CMP REGISTER, # 0 | O bloqueio era zero?
Página 52
JNE ENTRE NA REGIÃO | Se fosse diferente de zero, o bloqueio foi definido, então o loop
RET | Retur n para o chamador; região crítica entrou
8. Conforme observado no texto, temos pouca experiência (e ferramentas) para escrever altamente
aplicativos de desktop paralelos. Embora os aplicativos de desktop às vezes sejam
multithread, os threads são frequentemente usados para simplificar a programação de E / S e
portanto, eles não são threads de computação intensiva. A única área de aplicativo de desktop
que tem alguma chance de paralelização em grande escala é o videogame, onde
muitos aspectos do jogo requerem computação significativa (paralela). A mais
Uma abordagem promissora é paralelizar o sistema operacional e os serviços de biblioteca. Nós
já vimos exemplos disso nos designs atuais de hardware e sistema operacional. Para
exemplo, as placas de rede agora têm processadores paralelos on-board (processo de rede
essores) que são usados para acelerar o processamento de pacotes e oferecer rede de alto nível
serviços de trabalho em velocidades de linha (por exemplo, criptografia, detecção de intrusão, etc). Como um-
outro exemplo, considere os poderosos processadores encontrados em placas de vídeo usadas para
descarregue a renderização de vídeo da CPU principal e ofereça gráficos de nível superior
APIs para aplicativos (por exemplo, Open GL). Pode-se imaginar a substituição desses
cartões para fins comerciais com processadores multicore de chip único. Além disso, como o
número de núcleos aumenta, a mesma abordagem básica pode ser usada para paralelizar
outro sistema operacional e serviços de biblioteca comuns.
9. Provavelmente os bloqueios nas estruturas de dados são suficientes. É difícil imaginar qualquer coisa
um pedaço de código pode fazer isso é crítico e não envolve alguns dados do kernel
estrutura. Toda aquisição e liberação de recursos usa estruturas de dados, por exemplo
ple. Embora não possa ser provado, provavelmente os bloqueios nas estruturas de dados são suficientes.
10. São necessários 16 ciclos de barramento para mover o bloco e ocorre nos dois sentidos para cada TSL .
Assim, a cada 50 ciclos de barramento, 32 deles são desperdiçados na movimentação do bloco de cache.
Conseqüentemente, 64% da largura de banda do barramento é desperdiçada em transferências de cache.
11. Sim, seria, mas o tempo de interpolação pode acabar sendo muito longo e degradante
atuação. Mas seria correto, mesmo sem máximo.
12. É tão bom quanto o TSL . É usado pré-carregando um 1 no registro para ser
usado. Então, esse registro e a palavra de memória são trocados atomicamente. Depois
a instrução, a palavra de memória está bloqueada (ou seja, tem o valor 1). É anterior
valor agora está contido no registro. Se estava bloqueado anteriormente, a palavra foi
não foi alterado e o chamador deve fazer um loop. Se foi desbloqueado anteriormente, é
agora bloqueado.
13. O loop consiste em uma instrução TSL (5 ns), um ciclo de barramento (10 ns) e um
JMP volta para o TSL instrução (5 ns). Assim, em 20 nseg, 1 ciclo de barramento é re-
questionado ocupando 10 nseg. O loop consome 50% do barramento.
Página 53
14. O agendamento de afinidade tem a ver com colocar o thread certo na CPU certa.
Isso pode reduzir as perdas de TLB, uma vez que elas são mantidas dentro de cada CPU.
Por outro lado, não tem efeito nas falhas de página, uma vez que se uma página está na memória
para uma CPU, está na memória de todas as CPUs.
15. (a) 2 (b) 4 (c) 8 (d) 5 (e) 3 (f) 4.

16. Em uma grade, o pior caso são nós em cantos opostos tentando se comunicar.
No entanto, com um toro, os cantos opostos estão separados por apenas dois saltos. O pior
caso é um canto tentando falar com um nó no meio. Para k ímpar , leva
( k - 1) / 2 saltos para ir de um canto para o meio horizontalmente e outro
( k - 1) / 2 saltos para ir para o meio verticalmente, para um total de k - 1. Para k pares ,
o meio é um quadrado de quatro pontos no meio, então o pior caso é de um
canto para o ponto mais distante naquele quadrado de quatro pontos. Demora k / 2 saltos para obter
lá horizontalmente e também k / 2 verticalmente, então o diâmetro é k .
17. A rede pode ser dividida em dois por um plano no meio, dando dois
sistemas, cada um com uma geometria de 8 × 8 × 4. Existem 128 links em execução
entre as duas metades, para largura de banda de bissecção de 128 Gbps.
18. Se considerarmos apenas o tempo da rede, obtemos 1 nseg por bit ou atraso de 512 nseg
por pacote. Para copiar 64 bytes 4 bytes por vez, 320 nseg são necessários em cada
lado, ou total de 640 nseg. Adicionando o tempo de conexão de 512 nseg, temos um total de 1132 nseg.
Se duas cópias adicionais forem necessárias, obtemos 1792 nseg.
19. Se considerarmos apenas o tempo de conexão, uma rede de 1 Gbps oferece 125 MB / s.
Mover 64 bytes em 1152 nseg é 55,6 MB / s. Movendo 64 bytes em 1792 nseg
é 35,7 MB / s.
20. O tempo para mover k bytes por E / S programada é de 20 k nseg. A hora do DMA
é 2.000 + 5 k nseg. Equacionando-os e resolvendo para k , obtemos o ponto de equilíbrio
apontar para 133 bytes.
21. Claramente, a coisa errada acontece se uma chamada de sistema for executada remotamente. Tentando
ler um arquivo na máquina remota não funcionará se o arquivo não estiver lá. Além disso,
definir um alarme na máquina remota não enviará um sinal de volta para a chamada
máquina de ling. Uma maneira de lidar com chamadas de sistema remoto é interceptá-los e enviar
de volta ao site de origem para execução.
22. Primeiro, em uma rede de broadcast, um pedido de broadcast pode ser feito. Segundo, um
banco de dados centralizado de quem tem qual página pode ser mantida. Terceiro, cada
página poderia ter uma base inicial, indicada pelos k bits superiores de seu anúncio virtual
vestir; a base doméstica pode acompanhar a localização de cada uma de suas páginas.
Página 54
23. Nesta divisão, o nó 1 tem A , E e G , o nó 2 tem B e F e o nó 3 tem C ,

D , H , e I . O corte entre os nós 1 e 2 agora contém AB e EB para um
peso de 5. O corte entre os nós 2 e 3 agora contém CD , CI , FI e
FH para um peso de 14. O corte entre os nós 1 e 3 agora contém EH e
GH para um peso de 8. A soma é 27.
24. A tabela de arquivos abertos é mantida no kernel, portanto, se um processo tiver arquivos abertos, quando
ele é descongelado e tenta usar um de seus arquivos, o novo kernel não conhece
sobre eles. Um segundo problema é a máscara de sinal, que também é armazenada no
kernel original. Um terceiro problema é que se um alarme estiver pendente, ele disparará
a máquina errada. Em geral, o kernel está cheio de pedaços de informações
informações sobre o processo e também devem ser migrados com êxito.
25. Os nós Ethernet devem ser capazes de detectar colisões entre pacotes, de modo que a propa-
o atraso de conexão entre os dois nós mais amplamente separados deve ser menor que
a duração do pacote mais curto a ser enviado. Caso contrário, o remetente pode totalmente
transmitir um pacote e não detectar uma colisão, embora o pacote sofra um
colisão perto da outra extremidade do cabo.
26. O middleware é executado em sistemas operacionais diferentes, então o código é claramente diferente
diferente porque as chamadas do sistema embarcado são diferentes. O que eles têm em
comum é produzir uma interface comum para a camada de aplicativo acima deles.
Se a camada de aplicativo faz chamadas apenas para a camada de middleware e nenhum sistema
dez chamadas, então todas as versões dele podem ter o mesmo código-fonte. Se eles
também fazem verdadeiras chamadas de sistema, elas serão diferentes.
27. Os serviços mais adequados são
(a) Conexão não confiável.
(b) Fluxo de bytes confiável.
28. É mantido hierarquicamente. Existe um servidor mundial para .edu que conhece
sobre todas as universidades e um servidor .com que conhece todos os nomes e
ing em .com . Assim, para procurar cs.uni.edu , uma máquina primeiro procuraria uni em
o servidor .edu , vá até lá para perguntar sobre o cs e assim por diante.
29. Um computador pode ter muitos processos aguardando conexões de entrada.

Eles podem ser o servidor da Web, servidor de correio, servidor de notícias e outros. Algum
forma é necessária para tornar possível direcionar uma conexão de entrada para alguns
processo particular. Isso é feito fazendo com que cada processo escute uma porta específica.
Foi acordado que os servidores Web ouvirão a porta 80, portanto,
as conexões direcionadas ao servidor Web são enviadas para a porta 80. O próprio número
foi uma escolha arbitrária, mas algum número teve que ser escolhido.
30. Dispositivos de I / O físicos ainda apresentam problemas porque eles não migram com
a máquina virtual, mas seus registros podem manter o estado que é crítico para o
funcionamento adequado do sistema. Pense em operações de leitura ou gravação em dispositivos
Página 55
(por exemplo, o disco) que foram emitidos, mas ainda não foram concluídos. E / S de rede
é particularmente difícil porque outras máquinas continuarão a enviar pacotes para
o hipervisor, sem saber que a máquina virtual foi movida. Mesmo se os pacotes
pode ser redirecionado para o novo hipervisor, a máquina virtual não responderá
sive durante o período de migração, que pode ser longo porque todo o sistema virtual
máquina, incluindo o sistema operacional convidado e todos os processos em execução em
ele deve ser movido para a nova máquina. Como resultado, os pacotes podem experimentar grandes
atrasos ou até mesmo perda de pacotes se os buffers do dispositivo / hipervisor estourarem.
31. Uma maneira seria o servidor da Web empacotar a página inteira, incluindo todos
as imagens, em um grande arquivo zip e envie tudo na primeira vez para que apenas
é necessária uma conexão. Uma segunda maneira seria usar um sem conexão
protocolo como UDP. Isso eliminaria a sobrecarga da conexão, mas
exigem que os servidores e navegadores façam seu próprio controle de erros.
32. Ter o valor de uma leitura depende se um processo está no
mesma máquina que o último escritor não é transparente. Isso argumenta para mak-
mudanças visíveis apenas para o processo que as faz. No outro
lado, ter um único gerenciador de cache por máquina é mais fácil e mais barato de implementar
plement. Tal gerente se torna muito mais complicado se tiver que
manter várias cópias de cada arquivo modificado, com o valor retornado dependendo
sobre quem está fazendo a leitura.
33. A memória compartilhada funciona com páginas inteiras. Isso pode levar a um falso compartilhamento, em
qual acesso a variáveis não relacionadas que por acaso estão na mesma página causa
debatendo-se. Colocar cada variável em uma página separada é um desperdício. Baseado em objeto
o acesso elimina esses problemas e permite um compartilhamento mais refinado.
34. Hashing em qualquer um dos campos da tupla quando ele é inserido no espaço da tupla
não ajuda porque o in pode ter parâmetros principalmente formais. Um opti-
mização que sempre funciona é notar que todos os campos de fora e de dentro são
digitado. Assim, a assinatura de tipo de todas as tuplas no espaço da tupla é conhecida, e o
tipo de tupla necessária em um in também é conhecido. Isso sugere a criação de uma tupla sub-
espaço para cada assinatura de tipo. Por exemplo, todas as tuplas (int, int, int) vão para
um espaço e todas as tuplas (string, int, float) vão para um espaço diferente. Quando
um in é executado, apenas o subespaço correspondente deve ser pesquisado.
Página 56
1. Os serviços de notícias populares exigem integridade e disponibilidade, mas não confidencialidade.

Os sistemas de armazenamento de backup exigem confidencialidade e integridade, mas não necessariamente
disponibilidade 24 horas por dia, 7 dias por semana. Finalmente, os serviços bancários exigem confidencialidade, integridade,
e disponibilidade.
2. (a) e (c) têm que ser uma parte do TCB e (b), (d) e (e) podem ser implementados
mentado fora do TCB.
3. Um canal secreto é um canal de comunicação não autorizado que pode ser

criado em um sistema, observando e manipulando o desempenho mensurável
características do sistema. O principal requisito para a existência de um canal secreto
é ter alguns recursos de sistema compartilhados, como CPU, disco ou rede que
pode ser usado para enviar sinais secretos.
4. É apenas inserido na matriz duas vezes. No exemplo dado no texto, print-

er1 está em dois domínios simultaneamente. Não há problema aqui.
5. Matriz de proteção total: 5000 × 100 = 500.000 unidades de espaço.

ACL:
50 × 100 (1% de objetos acessíveis em todos os domínios; 100 entradas / ACL)
+ 500 × 2 (10% de objetos acessíveis em dois domínios; duas entradas / ACL)
+ 4450 × 1 (89% de objetos acessíveis em um domínio; uma entrada / ACL)
= 10.450 unidades de espaço
O espaço necessário para armazenar uma lista de capacidade será o mesmo do ACL.
6. (a) Lista de capacidades
(b) Lista de capacidades
(c) ACL
(d) ACL
7. Para tornar um arquivo legível por todos, exceto uma pessoa, as listas de controle de acesso são
a única possibilidade. Para compartilhar arquivos privados, listas de controle de acesso ou recursos
pode ser usado. Para tornar os arquivos públicos, as listas de controle de acesso são mais fáceis, mas podem
também é possível colocar um recurso para o arquivo ou arquivos em um local bem conhecido em
um sistema de capacidade.
8. Aqui está a matriz de proteção:
Página 57
Objeto
Domínio Notas PPP prog1 project.t splash.gif
como W Leitura Leitura Leitura Leitura
Escrever Escrever
Exec
gmw Leitura Leitura
Escrever Escrever
Comercial Leitura Leitura
Escrever
desenvolver Leitura Leitura
Exec
9. As ACLs são as seguintes:
Arquivo ACL
Notas PPP gmw: RW; *: R
prog1 asw: RWX; devel: RX; *: R
project.t asw: RW; usuários: RW
splash.gif asw: RW; devel: R
Suponha que * significa tudo.

10. Se asw quiser permitir que gmw, mas nenhum outro membro de usuários, vejam splash.gif,
ele poderia modificar a ACL para asw: RW; devel: R; GMW: R .
11. Apenas modelo Bell-LaPadula: (a), (b), (h)

Apenas modelo Biba: (e), (i)
Ambos: (c), (d), (f), (g)
12. O servidor verificará se a capacidade é válida e, em seguida, gerará um mais fraco

capacidade. Isso é legal. Afinal, o amigo pode simplesmente dar a capacidade
já o fez. Dar a ele o poder de dar algo ainda mais fraco não é
uma ameaça à segurança. Se você tem a capacidade de doar, digamos, poder de leitura / gravação,
distribuir energia somente leitura não é um problema.
13. Não. Isso seria escrever, o que viola a * propriedade.

14. Um processo de gravação em outro processo é semelhante a um processo de gravação em um arquivo.
Conseqüentemente, a propriedade * teria que ser mantida. Um processo pode escrever
mas não escreva. Processo B pode enviar para C , D , e E , mas não a uma .
15. Na foto original, os eixos R, G e B permitem, cada um, valores integrais discretos
de 0 a 255, inclusive. Isso significa que existem 2 24 pontos válidos na cor
espaço que um pixel pode ocupar. Quando 1 bit é retirado para o canal oculto,
apenas os valores pares são permitidos (assumindo que o bit secreto seja substituído por um 0
Página 58
em todos os lugares). Assim, a maior parte do espaço é coberto, mas a resolução de cor é
apenas metade tão bom. No total, apenas 1/8 das cores podem ser representadas. O
cores não permitidas são mapeadas para a cor adjacente cujos valores são todos
mesmo os números, por exemplo, as cores (201, 43, 97), (201, 42, 97), (200, 43,
96) e (200, 42, 97) agora são mapeados para o ponto (200, 42, 96) e não podem
mais ser distinguido.
16. chegou a hora em que a morsa disse para falar de muitas coisas
de navios e sapatos e lacre de repolhos e reis
de por que o mar está fervendo e se os porcos têm asas
mas espere um pouco as ostras choraram antes de conversarmos
pois alguns de nós estão sem fôlego e todos nós somos gordos
sem pressa disse o carpinteiro eles agradeceram muito por isso
De Through the Looking Glass (Tweedledum e Tweedledee).
17. A restrição é que duas células não contêm as mesmas duas letras, caso contrário, de-
a criptografia seria ambígua. Assim, cada um dos 676 elementos da matriz contém
um diferente dos 676 digramas. O número de combinações diferentes é
portanto, 676! Este é um número muito grande.
18. O número de permutações é n !, Então este é o tamanho do espaço da chave. Um anúncio
vantagem é que o ataque estatístico baseado nas propriedades das línguas naturais
não funciona porque um E realmente representa um E e assim por diante.
19. O remetente escolhe uma chave aleatória e a envia para o terceiro confiável criptografado
com a chave secreta que eles compartilham. O terceiro confiável, então, descriptografa o
chave aleatória e recodifica-a com a chave secreta que compartilha com o receptor. Esse
a mensagem é então enviada ao receptor.
20. Uma função como y = x k é fácil de calcular, mas tirar a raiz k de y está longe
mais difícil.
21. A e B escolhem as chaves aleatórias Ka e Kb e as enviam para C criptografadas com C 's
chave pública. C escolhe uma chave aleatória K e a envia para A criptografada usando Ka e
para B criptografado usando Kb .
22. Uma maneira de assinar um documento seria o cartão inteligente ler o documento
fazer um hash dele e, em seguida, criptografar o hash com a chave privada do usuário,
armazenados no cartão. O hash criptografado seria enviado para o cibercafé
computador, mas a chave secreta nunca sairia do cartão inteligente, então o esquema
é seguro.
23. A imagem contém 1.920.000 pixels. Cada pixel possui 3 bits que podem ser usados,
dada uma capacidade bruta de 720.000 bytes. Se isso for efetivamente dobrado devido a
comprimir o texto antes de armazená-lo, a imagem pode conter texto ASCII ocupando
ing cerca de 1.440.000 bytes antes da compressão. Não há expansão devido a
Página 59
a esteganografia. A imagem com os dados ocultos é do mesmo tamanho que o original
imagem
bit inal.
de cada A eficiência
amostra de cor édede8 25%. Isso pode
bits contém serútil,
carga facilmente visto de
e os apertos pelo fato de que 1
compressão
2 bits de texto ASCII por bit de carga útil. Assim, por pixel de 24 bits, efetivamente 6 bits de
O texto ASCII está sendo codificado.
24. Os dissidentes podem assinar as mensagens usando uma chave privada e, em seguida, tentar
divulgar amplamente sua chave pública. Isso pode ser possível tendo alguém
contrabandear para fora do país e, em seguida, publicá-lo na Internet de um país gratuito
Experimente.
25. (a) Ambos os arquivos têm 2,25 MB.

(b) Hamlet , Júlio César , Rei Lear , Macbeth e Mercador de Veneza .
(c) Existem seis arquivos de texto armazenados secretamente, totalizando cerca de 722 KB.
26. Depende do tamanho da senha. O alfabeto a partir do qual as senhas

é construído com 62 símbolos. O espaço total de pesquisa é 62 5 + 62 6 + 62 7 + 62 8 ,
que é cerca de 2 × 10 14 . Se a senha tiver k caracteres, o
o espaço de busca é reduzido para apenas 62 k . A proporção destes é, assim, 2 × 10 14 /62 k .
Para k de 5 a 8, esses valores são 242.235, 3907, 63 e 1. Em outras palavras,
aprender que a senha tem apenas cinco caracteres reduz o espaço de pesquisa em um
fator de 242.235 porque todas as senhas longas não precisam ser tentadas. Esse
é uma grande vitória. No entanto, aprender que são oito caracteres não ajuda muito
porque significa que todas as senhas curtas (fáceis) podem ser ignoradas.
27. Tente acalmar o assistente. O algoritmo de criptografia de senha é público. Passar-

as palavras são criptografadas pelo programa de login assim que são digitadas, e o
a senha criptografada é comparada com a entrada no arquivo de senha.
28. Não, não importa. O aluno pode descobrir facilmente qual é o número aleatório para
seu superusuário é. Essas informações estão no arquivo de senha sem criptografia. Se for
0003, por exemplo, ele apenas tenta criptografar possíveis senhas como
Susan0003 , Boston0003 , IBMPC0003 e assim por diante. Se outro usuário tiver senha
palavra Boston0004 , ele não vai descobrir, no entanto.
29. Suponha que haja m usuários nos sistemas. O cracker pode então coletar o m
valores de sal, assumidos todos diferentes aqui. O cracker terá que tentar criptografar
cada senha adivinhada m vezes, uma vez com cada um dos m sais usados pelo sistema
tem. Assim, o tempo do cracker para quebrar todas as senhas aumenta m- vezes.
30. Existem muitos critérios. Aqui estão alguns deles:

Deve ser fácil e indolor de medir (não amostras de sangue).
Deve haver muitos valores disponíveis (não a cor dos olhos).
A característica não deve mudar com o tempo (não a cor do cabelo).
Deve ser difícil forjar a característica (não o peso).
Página 60
31. A combinação de diferentes mecanismos de autenticação proporcionará maior segurança

autenticação. No entanto, existem duas desvantagens. Primeiro, o custo envolvido em
implementar este sistema é alto. O sistema incorre no custo de três diferentes
mecanismos de autenticação. Em segundo lugar, este mecanismo de autenticação coloca
sobrecarga para o usuário. O usuário deve lembrar seu login / senha, carregar seu
cartão de plástico e lembre-se de seu PIN, e tem que passar pelo processo de digitação
correspondência de impressão. A questão principal é que tudo isso aumentará o tempo que leva para
autenticar um usuário, resultando em aumento da insatisfação do usuário.
32. Se todas as máquinas são confiáveis, funciona bem. Se alguns não são confiáveis, o
esquema falha, porque uma máquina não confiável poderia enviar uma mensagem
para uma máquina confiável, pedindo-lhe para executar algum comando em nome do
superusuário. A máquina que recebe a mensagem não tem como saber se o
comando realmente se originou com o superusuário ou com um aluno.
33. Não funcionaria usá-los para a frente. Se um intruso capturasse um, ele iria
saiba qual usar na próxima vez. Usá-los ao contrário evita esse perigo.
34. Não, não é viável. O problema é que os limites do array não são verificados.
Os arrays não se alinham com os limites da página, portanto, o MMU não ajuda em nada.
Além disso, fazer uma chamada de kernel para alterar o MMU em cada chamada de procedimento
seria proibitivamente caro.
35. O invasor explora a condição de corrida executando uma operação como sym-
após a verificação dos direitos de acesso e antes da abertura do arquivo. Se
o acesso ao sistema de arquivos é uma transação, a verificação dos direitos de acesso e a abertura do arquivo
fará parte de uma única transação e a propriedade de serialização garantirá
esse link simbólico não pode ser criado no meio. A principal desvantagem disso
abordagem é que o desempenho do sistema de arquivos sofrerá uma vez que o transac-
ções incorrem em sobrecarga extra.
36. O compilador pode inserir código em todas as referências de array para fazer a verificação de limites.
Esse recurso evitaria ataques de estouro de buffer. Não é feito porque
tornaria todos os programas significativamente mais lentos. Além disso, em C não é ilegal
para declarar uma matriz de tamanho 1 como um parâmetro de procedimento e, em seguida, referenciar elementos
20, mas claramente a matriz real cujo endereço foi passado seria melhor
tem pelo menos 20 elementos. Além disso, C funciona como memset e memcpy
são usados o tempo todo para copiar estruturas inteiras de uma vez, mesmo que contenham
taxa de matrizes. Em outras palavras, eles são estouros de buffer por design.
37. Se os recursos são usados para tornar possível ter uma pequena proteção,
rede, não; caso contrário, sim. Se um editor, por exemplo, é iniciado apenas com o
recursos para o arquivo a ser editado e seu arquivo de trabalho, então não importa o que
truques estão espreitando dentro do editor, tudo o que ele pode fazer é ler esses dois arquivos. No
por outro lado, se o editor puder acessar todos os objetos do usuário, os cavalos de Tróia
podem fazer seu trabalho sujo, capacidades ou não.
Página 61
38. Do ponto de vista da segurança, seria o ideal. Blocos usados às vezes são
exposta, vazando informações valiosas. Do ponto de vista do desempenho,
zerar blocos desperdiça tempo de CPU, degradando o desempenho.
39. Para qualquer sistema operacional, todos os programas devem iniciar a execução em um
endereço ou ter um endereço inicial armazenado em uma posição conhecida no programa
cabeçalho do arquivo. (a) O vírus primeiro copia as instruções no endereço de início normal
ou o endereço no cabeçalho para um lugar seguro, e então insere um salto para si mesmo
no código ou em seu próprio endereço inicial no cabeçalho. (b) Quando terminar com seu
próprio trabalho, o vírus executa as instruções que pegou emprestado, seguido por um salto
para a próxima instrução que teria sido executada, ou transfere o controle para
o endereço encontrado no cabeçalho original.
40. Um registro mestre de inicialização requer apenas um setor, e se o resto da primeira faixa
é gratuito, ele fornece espaço onde um vírus pode esconder o setor de inicialização original também
como uma parte substancial de seu próprio código. Controladores de disco modernos leem e armazenam em buffer
faixas inteiras de uma vez, então não haverá atraso perceptível ou sons de adi-
buscas tradicionais à medida que os dados extras são lidos.
41. Os programas C têm extensão .c . Em vez de usar a chamada do sistema de acesso para testar
para permissão de execução, examine o nome do arquivo para ver se termina em .c . Este código
vai fazer isso:
char * nome do arquivo;

int len;
nome do arquivo = dp-> nome d;
len = strlen (nome do arquivo);
if (strcmp (& nome do arquivo [len - 2], ".c") == 0) infect (s);
42. Eles provavelmente não podem dizer, mas eles podem adivinhar que XORing uma palavra dentro
o vírus com o resto produzirá um código de máquina válido. Seus computadores podem
apenas tente cada palavra de vírus por vez e veja se alguma delas produz uma máquina válida
código. Para desacelerar esse processo, Virgil pode usar um algoritmo de criptografia melhor,
como usar chaves diferentes para as palavras pares e ímpares e, em seguida, girar o
primeira palavra deixada por algum número de bits determinado por uma função hash no
, girando a segunda palavra aquele número de bits mais um, e assim por diante.
43. O compressor é necessário para compactar outros programas executáveis como parte do
o processo de infectá-los.
44. A maioria dos vírus não quer infectar um arquivo duas vezes. Pode até não funcionar. Lá-
portanto, é importante ser capaz de detectar o vírus em um arquivo para ver se ele já está
infetado. Todas as técnicas usadas para tornar difícil para o software antivírus
detectar vírus também torna difícil para o próprio vírus identificar quais arquivos foram
infetado.
Página 62
45. Em primeiro lugar, executar o programa Ifdisk a partir do disco rígido é um erro. Pode ser
infectado e pode infectar o setor de inicialização. Tem que ser executado a partir do CD original
ROM ou um disquete protegido contra gravação. Em segundo lugar, os arquivos restaurados podem estar em
afetado. Colocá-los de volta sem limpá-los pode apenas reinstalar o vírus.
46. Sim, mas o mecanismo é um pouco diferente do Windows. No UNIX, um com-

O vírus panion pode ser instalado em um diretório no caminho de pesquisa antes daquele
em que vive o programa real. O exemplo mais comum é inserir um pro
gram ls em um diretório de usuário, o que efetivamente substitui / bin / ls porque é
encontrado primeiro.
47. Obviamente, executar qualquer programa de uma fonte desconhecida é perigoso.

Arquivos autoextraíveis podem ser especialmente perigosos, porque podem liberar
vários arquivos em vários diretórios, e o próprio programa de extração poderia
ser um cavalo de Tróia. Se houver uma opção disponível, é muito melhor obter arquivos no
forma de um arquivo comum, que você pode extrair com ferramentas nas quais você confia.
48. Como um rootkit é projetado para ocultar sua existência, ele infecta o sistema operacional,
bibliotecas e aplicativos. Portanto, qualquer software de detecção que dependa de qualquer sistema
a funcionalidade não pode ser confiável. Essencialmente, um rootkit subverte o software que
destina-se a encontrá-lo. Como resultado, os detectores de rootkit precisam contar com recursos externos
componentes como a digitalização de um TCB externo.
49. Uma vez que um rootkit pode subverter o software de recuperação, por exemplo, redefinindo o
pontos de restauração do sistema, essa abordagem para recuperação do sistema não funciona.
50. Não é possível escrever tal programa, porque se tal programa for pos-
sível, um cracker pode usar esse programa para contornar a verificação de vírus no vírus-
programa carregado, ela escreve.
51. O endereço IP de origem de todos os pacotes de entrada pode ser inspecionado. O segundo
conjunto de regras descartará todos os pacotes IP de entrada com endereços IP de origem ser-
saudade de spammers conhecidos.
52. Não importa. Se o preenchimento de zero for usado, S2 deve conter o prefixo verdadeiro como
um inteiro sem sinal nos k bits de ordem inferior . Se a extensão de sinal for usada, então S2
também deve ter o sinal estendido. Contanto que S2 contenha os resultados corretos de shift-
com um endereço verdadeiro, não importa o que está nos bits superiores não usados de S2 .
53. Os navegadores existentes vêm pré-carregados com as chaves públicas de vários terceiros confiáveis
partes como a Verisign Corporation. Seu negócio consiste em verificar
chaves públicas de outras empresas e a obtenção de certificados para elas. Estes cer-
Os certificados são assinados, por exemplo, pela chave privada da Verisign. Desde Verisign's
a chave pública está embutida no navegador, os certificados assinados com sua chave privada podem
ser verificado.
Página 63
54. Primeiro, Java não fornece variáveis de ponteiro. Isso limita a capacidade de um processo de
sobrescrever um local de memória arbitrário. Em segundo lugar, o Java não permite o usuário-con
alocação de armazenamento controlado ( malloc / livre ). Isso simplifica o gerenciamento de memória.
Terceiro, Java é uma linguagem de tipo seguro, garantindo que uma variável seja usada exatamente
forma como deve ser, com base em seu tipo.
55. Aqui estão as regras.
URL Signatário Objeto Açao

www.appletsRus.com AppletsRus / usr / me / appletdir / * Leitura
www.appletsRus.com AppletsRUs / usr / tmp / * Ler escrever
www.appletsRus.com AppletsRUs www.appletsRus; porta: 5004 Conecte-se, leia
56. Um miniaplicativo é qualquer pequeno programa que executa uma tarefa específica, como preencher
um formulário. A principal diferença entre um miniaplicativo e um aplicativo é que um
miniaplicativo é executado dentro do escopo de um programa maior dedicado, renderizando um
página da web. Applets são exemplos típicos de aplicativos auxiliares que não
monopolizam a atenção do usuário e devem ser facilmente acessíveis. Desde a
miniaplicativos são normalmente baixados de terceiros, eles contêm essencialmente
código estrangeiro projetado para ser executado na máquina do usuário. Eles podem conter vírus,
worms ou outro código prejudicial.
Página 64
1. Como a linguagem assembly é específica para cada máquina, uma porta do UNIX para um novo
máquina exigiu reescrever todo o código na linguagem de montagem da nova máquina
calibre. Por outro lado, uma vez que o UNIX foi escrito em C, apenas uma pequena parte do
o sistema operacional (por exemplo, drivers de dispositivo para dispositivos de E / S) teve que ser reescrito.
2. A interface de chamada do sistema está fortemente acoplada ao kernel do sistema operacional. Padronizando o
interface de chamada do sistema teria colocado restrições severas (menos flexibilidade) no
design do kernel do sistema operacional. Isso também tornaria o UNIX menos portátil.
3. Isso permite que o Linux use recursos especiais (como extensões de linguagem) do
compilador gcc que vai desde fornecer atalhos e simplificações até pro
fornecendo ao compilador dicas para otimização. A principal desvantagem é que
existem outros compiladores C populares e ricos em recursos, como LLVM, que não podem ser
usado para compilar o Linux. Se em algum momento futuro LLVM ou algum outro compilador
torna-se melhor que o gcc em todos os sentidos, o Linux não será capaz de usá-lo. Esse
pode se tornar um problema sério.
4. Os arquivos que serão listados são: bonefish, quacker, seahorse e weasel .
5. Imprime o número de linhas do arquivo xyz que contém a string '' nd ''.
6. O pipeline é o seguinte:
cabeça –8 z | cauda -1
A primeira parte seleciona as primeiras oito linhas de z e as passa para a cauda , que
apenas escreve o último na tela.
7. Eles são separados, de modo que a saída padrão pode ser redirecionada sem afetar o padrão
erro padrão. Em um pipeline, a saída padrão pode ir para outro processo, mas
erro dard ainda escreve no terminal.
8. Cada programa é executado em seu próprio processo, portanto, seis novos processos são iniciados.
9. Sim. A memória da criança é uma cópia exata da memória dos pais, incluindo a pilha.
Assim, se as variáveis de ambiente estiverem na pilha do pai, elas estarão
a pilha da criança também.
10. Como os segmentos de texto são compartilhados, apenas 36 KB devem ser copiados. A máquina pode
copie 80 bytes por microssegundo, portanto 36 KB leva 0,46 ms. Adicionar outro 1 mseg
para entrar e sair do kernel, e a coisa toda leva cerca de 1,46
mseg.
11. O Linux depende de cópia na gravação. Dá à criança indicações para o endereço dos pais
espaço, mas marca as páginas do pai protegidas contra gravação. Quando a criança tenta
para escrever no espaço de endereço do pai, ocorre uma falha e uma cópia do par-
A página de ent é criada e alocada no espaço de endereço da criança.
Página 65
12. Os valores negativos permitem que o processo tenha prioridade sobre todos os processos normais.
Os usuários não podem ser confiáveis com tal poder. É apenas para o superusuário e então
usado apenas em situações críticas.
13. O texto diz que o valor agradável está na faixa de −20 a +19, então o valor estático padrão
a prioridade deve ser 120, o que de fato é. Por ser legal e selecionar um positivo
bom valor, um processo pode solicitar para ser colocado em prioridade mais baixa.
14. Sim. Ele não pode mais ser executado, então quanto mais cedo sua memória volta para o livre
lista, melhor.
15. Os sinais são como interrupções de hardware. Um exemplo é o sinal de alarme, que
sinaliza o processo em um número específico de segundos no futuro. Outro é o
sinal de exceção de ponto flutuante, que indica divisão por zero ou algum outro
erro. Muitos outros sinais também existem.
16. Usuários mal-intencionados podem causar estragos no sistema se puderem enviar sinais
a processos arbitrários não relacionados. Nada impediria um usuário de escrever um pro
grama que consiste em um loop que enviou um sinal para o processo com PID i para todos os i
de 1 ao PID máximo. Muitos desses processos seriam despreparados
para o sinal e seria morto por ele. Se você quiser matar seu próprio proc-
esses, está tudo bem, mas matar os processos do seu vizinho não é ac-
aceitável.
17. Seria impossível usar Linux ou Windows, mas o hardware Pentium

torna isso possível. O que é necessário é usar os recursos de segmentação de
o hardware, que não é compatível com Linux ou Windows. O oper-
sistema operacional pode ser colocado em um ou mais segmentos globais, com pro-
cedure chamadas para fazer chamadas de sistema em vez de armadilhas. OS / 2 funciona dessa maneira.
18. Geralmente, os daemons são executados em segundo plano fazendo coisas como imprimir e enviar
ing e-mail. Uma vez que as pessoas geralmente não estão sentadas na beira de suas cadeiras, esperem-
para que eles terminem, eles recebem baixa prioridade, absorvendo o tempo excessivo da CPU
não é necessário para processos interativos.
19. Um PID deve ser exclusivo. Mais cedo ou mais tarde, o contador vai fechar
de volta a 0. Em seguida, aumentará para, por exemplo, 15. Se acontecer de
o processo 15 foi iniciado há meses, mas ainda está em execução, 15 não pode ser atribuído
para um novo processo. Assim, depois que um PID proposto é escolhido usando o contador, um
deve ser feita a pesquisa da tabela de processos para verificar se o PID já está em uso.
20. Quando o processo for encerrado, o pai receberá o status de saída de seu filho. o
O PID é necessário para ser capaz de identificar o pai para que o status de saída possa ser trans-
encaminhado para o processo correto.
Página 66
21. Uma página agora pode ser compartilhada por todos os três processos neste caso. Em geral, o
O mecanismo de cópia na gravação pode resultar em vários processos compartilhando uma página. Para
lidar com esta situação, o sistema operacional tem que manter uma contagem de referência para cada
página. Se p1 escrever em uma página compartilhada de três maneiras, ele obtém uma cópia privada enquanto o
outros dois processos continuam compartilhando sua cópia.
22. Se todos os bits de sinalizadores de compartilhamento estiverem definidos, a chamada clone inicia um convencional
fio. Se todos os bits forem apagados, 1 a chamada é essencialmente um fork .
23. Cada decisão de agendamento requer a procura de um bitmap para a matriz ativa e
procurando o primeiro bit definido na matriz, o que pode ser feito em tempo constante,
desenfileirando uma única tarefa da fila selecionada, novamente uma operação de tempo constante
ção, ou se o valor do bitmap é zero, trocando os valores do ativo e
listas expiradas, novamente uma operação de tempo constante.
24. Interrupções de clock, especialmente em alta frequência, podem consumir uma boa quantidade de CPU
Tempo. Sua função principal (além de controlar a hora do dia, que
pode ser feito de outras maneiras) é determinar quando antecipar um processo de longa execução
ess. No entanto, em condições normais, um processo torna centenas de sistemas
chamadas por segundo, para que o kernel possa verificar em cada chamada se o processo em execução
foi executado por muito tempo. Para lidar com o caso de um processo totalmente vinculado à CPU, execute
muito tempo, um cronômetro pode ser configurado para disparar em, digamos, 1 segundo, apenas no caso de
não faz chamadas de sistema. Se houver apenas um processo, a preempção não é necessária,
então a ausência de tique-taque está bem.
25. O programa carregado do bloco 0 tem no máximo 512 bytes de comprimento, portanto pode
não ser muito complicado. Carregar o sistema operacional requer compreensão
o layout do sistema de arquivos para localizar e carregar o sistema operacional. Diferente
os sistemas operacionais têm sistemas de arquivos muito diferentes; é pedir muito para
espere um programa de 512 bytes para resolver tudo isso. Em vez disso, o carregador de bloco 0 apenas
busca outro carregador de um local fixo na partição do disco. Este programa
pode ser muito mais longo e específico do sistema para que possa localizar e carregar o sistema operacional.
26. Com o texto compartilhado, 100 KB são necessários para o texto. Cada um dos três processos
precisa de 80 KB para seu segmento de dados e 10 KB para sua pilha, portanto, a memória total
necessário é de 370 KB. Sem texto compartilhado, cada programa precisa de 190 KB, então três
deles precisam de um total de 570 KB.
27. Os processos que compartilham um arquivo, incluindo a posição atual do ponteiro do arquivo, podem apenas
compartilhar um descritor de arquivo aberto, sem ter que atualizar nada em um do outro
tabelas descritoras de arquivos privadas. Ao mesmo tempo, outro processo pode acessar o
mesmo arquivo por meio de um descritor de arquivo aberto separado, obter um ponteiro de arquivo diferente,
e percorrer o arquivo por sua própria vontade.
Página 67
28. O segmento de texto não pode ser alterado, por isso nunca precisa ser retirado da página. Se seus quadros
são necessários, eles podem simplesmente ser abandonados. As páginas sempre podem ser recuperadas
do sistema de arquivos. O segmento de dados não deve ser paginado de volta para o ex-
arquivo ecutável, porque é provável que ele tenha mudado desde que foi introduzido.
Paginar de volta arruinaria o arquivo executável. O segmento da pilha não é uniforme
presente no arquivo executável.
29. Dois processos podem mapear o mesmo arquivo em seus espaços de endereço ao mesmo
Tempo. Isso dá a eles uma maneira de compartilhar a memória física. Metade do compartilhado
a memória pode ser usado como um tampão a partir de uma para B e metade como um tampão de B para A .
Para se comunicar, um processo escreve uma mensagem em sua parte do memorando compartilhado
ry, então um sinal para o outro para indicar que há uma mensagem esperando por ele.
A resposta pode usar o outro buffer.
30. O endereço de memória 65.536 é o byte 0 do arquivo, então o endereço de memória 72.000 é o byte 6464.
31. Originalmente, quatro páginas do arquivo foram mapeadas: 0, 1, 2 e 3. A chamada

for bem-sucedido e depois de feito, apenas as páginas 2 e 3 ainda estão mapeadas, ou seja, bytes
16.384 a 32.767.
32. É possível. Por exemplo, quando a pilha cresce além da página inferior, um
falha de página ocorre e o sistema operacional normalmente atribui o próximo mais baixo
página para ele. No entanto, se a pilha bateu no segmento de dados, o próximo
a página não pode ser alocada para a pilha, então o processo deve ser encerrado antes de
porque ficou sem espaço de endereço virtual. Além disso, mesmo se houver outra página
disponível na memória virtual, a área de paginação do disco pode estar cheia, tornando
impossível alocar armazenamento de apoio para a nova página, o que também teria
minar o processo.
33. É possível se os dois blocos não forem amigos. Considere a situação de
Fig. 10-17 (e). Chegam dois novos pedidos de oito páginas cada. Neste ponto
as últimas 32 páginas de memória pertencem a quatro usuários diferentes, cada um com
oito páginas. Agora os usuários 1 e 2 liberam suas páginas, mas os usuários 0 e 3 seguram
deles. Isso resulta em uma situação com oito páginas usadas, oito páginas gratuitas, oito
páginas gratuitas e oito páginas usadas. Temos dois blocos adjacentes de tamanho igual
que não podem ser mesclados porque não são amigos.
34. A paginação para uma partição permite o uso de um dispositivo bruto, sem a sobrecarga de
usando estruturas de dados do sistema de arquivos. Para acessar o bloco n , o sistema operacional pode
calcule a posição do disco apenas adicionando-o ao bloco inicial da partição.
Não há necessidade de passar por todos os blocos indiretos que, de outra forma, seriam
precisava.
35. Abrir um arquivo por um caminho relativo ao diretório de trabalho é geralmente mais complicado
conveniente para o programador ou usuário, uma vez que um nome de caminho mais curto é necessário. Isto é
também geralmente muito mais simples e requer menos acessos ao disco.
Página 68
36. Os resultados são os seguintes:

(a) O bloqueio é concedido.
(b) O bloqueio é concedido.
(c) C está bloqueado, uma vez que os bytes 20 a 30 não estão disponíveis.
(d) A está bloqueado, uma vez que os bytes 20 a 25 não estão disponíveis.
(e) B está bloqueado, pois o byte 8 não está disponível para bloqueio exclusivo.
Neste ponto, agora temos um impasse. Nenhum dos processos jamais será capaz
para correr novamente.
37. Surge a questão de qual processo obtém o bloqueio quando se torna disponível. o
a solução mais simples é deixá-lo indefinido. Isso é o que POSIX faz porque
é o mais fácil de implementar. Outra é exigir que os bloqueios sejam concedidos no
ordem em que foram solicitados. Esta abordagem é mais trabalhosa para o implemento
mentação, mas evita a fome. Ainda outra possibilidade é permitir que os processos
fornecer uma prioridade ao solicitar um bloqueio e usar essas prioridades para fazer um
escolha.
38. Um processo irá solicitar um bloqueio compartilhado se quiser ler alguns bytes, ao passo que
irá solicitar um bloqueio exclusivo se quiser atualizar alguns bytes. Um processo de re-
buscar um bloqueio exclusivo pode ser bloqueado indefinidamente se houver uma sequência de
processos solicitando bloqueios compartilhados. Em outras palavras, se os leitores sempre vão antes
escritores, escritores podem passar fome.
39. O proprietário pode ler, escrever e executá-lo, e todos os outros (incluindo o

grupo do proprietário) pode apenas lê-lo e executá-lo, mas não pode escrevê-lo.
40. Sim. Qualquer dispositivo de bloco capaz de ler e escrever um bloco arbitrário pode ser
usado para manter um sistema de arquivos. Mesmo se não houvesse maneira de buscar um específico
bloco, é sempre possível rebobinar a fita e, em seguida, contar para a frente até o retorno
bloco questionado. Tal sistema de arquivos não seria um sistema de arquivos de alto desempenho
tem, mas funcionaria. O autor realmente fez isso em um PDP-11 usando
DECtapes e funciona.
41. Não. O arquivo ainda tem apenas um proprietário. Se, por exemplo, apenas o proprietário pode
escrever no arquivo, a outra parte não pode. Vincular um arquivo ao seu diretório faz
não lhe dar de repente nenhum direito que você não tinha antes. Isso apenas cria um novo
caminho para acessar o arquivo.
42. Quando o diretório de trabalho é alterado, usando chdir , o i-node para o novo
O diretório de trabalho é obtido e mantido na memória, na tabela de i-node. O i-
nó para o diretório raiz também está lá. Na estrutura do usuário, os ponteiros para ambos
destes são mantidos. Quando um nome de caminho precisa ser analisado, o primeiro caractere
é inspecionado. Se for um '' / '', o ponteiro para o nó-i raiz é usado como ponto de partida
lugar, caso contrário, o ponteiro para o i-node do diretório de trabalho é usado.
Página 69
43. O acesso ao i-node do diretório raiz não requer um acesso ao disco, então temos
a seguir:
1. Lendo o diretório / para procurar '' usr ''.

2. Leitura no i-node para / usr .
3. Lendo o diretório / usr para procurar '' ast ''.
4. Leitura no i-node para / usr / ast .
5. Lendo o diretório / usr / ast para procurar '' trabalho ''.
6. Leitura no i-node para / usr / ast / work .
7. Lendo o diretório / usr / ast / work para procurar '' f ''.
8. Leitura no i-node para / usr / ast / work / f .
Portanto, no total, oito acessos de disco são necessários para buscar o i-node.
44. O i-node contém 12 endereços. O único bloco indireto contém 256. O duplo
bloqueio indireto provável leva a 65.536, e o indireto triplo leva a 16.777.216,
para um total de 16.843.018 blocos. Isso limita o tamanho máximo do arquivo a 12 + 256
+ 65.536 + 16.777.218 blocos, o que é cerca de 16 gigabytes.
45. Quando um arquivo é fechado, o contador de seu nó-i na memória é diminuído. Se isso
é maior que zero, o nó-i não pode ser removido da tabela porque o
arquivo ainda está aberto em algum processo. Somente quando o contador atinge zero, o i-
nó ser removido. Sem a contagem de referência, o sistema não saberia
quando remover o i-node da tabela. Fazendo uma cópia separada do i-
nó cada vez que o arquivo era aberto não funcionava porque as alterações feitas no
uma cópia não seria visível nas outras.
46. Ao manter filas de execução por CPU, as decisões de agendamento podem ser feitas localmente,
sem executar mecanismos de sincronização caros para sempre acessar,
e atualização, uma fila de execução compartilhada. Além disso, é mais provável que toda memória relevante
as páginas ainda estarão no cache1 se agendarmos um thread na mesma CPU
onde já foi executado.
47. Uma desvantagem é a segurança, pois um módulo carregável pode conter bugs e
façanhas. Outra desvantagem é que o espaço de endereço virtual do kernel pode ser-
vêm fragmentados à medida que mais e mais módulos são carregados.
48. Forçando o conteúdo do arquivo modificado para o disco a cada 30 segundos,

o dano causado por um acidente é limitado a 30 seg. Se o pdflush não for executado, um processo
pode gravar um arquivo e, em seguida, sair com o conteúdo completo do arquivo ainda no cache.
Na verdade, o usuário pode então fazer logout e ir para casa com o arquivo ainda no cache.
Uma hora depois, o sistema pode travar e perder o arquivo, ainda apenas no cache
e não no disco. No dia seguinte não teríamos um usuário feliz.
49. Tudo o que precisa fazer é definir a contagem de links para 1, uma vez que apenas uma referência de entrada de diretório
entes o i-node.
Página 70
50. Geralmente é getpid , getuid , getgid ou algo parecido. Tudo o que eles fazem é buscar
um inteiro de um lugar conhecido e retorne-o. Qualquer outra chamada faz mais.
51. O arquivo é simplesmente removido. Esta é a maneira normal (na verdade, a única maneira) de
remover um arquivo.
52. Um disquete de 1,44 MB pode conter 1440 blocos de dados brutos. O bloco de inicialização,
superbloco, bloco descritor de grupo, bitmap de bloco e bitmap de nó-i de um
Cada sistema de arquivo ext2 usa um bloco. Se 8192 i-nodes de 128 bytes forem criados,
esses i-nodes ocuparão outros 1.024 blocos, deixando apenas 411 blocos
não utilizado. É necessário pelo menos um bloco para o diretório raiz, deixando espaço para
410 blocos de dados de arquivo. Na verdade, o programa Linux mkfs é inteligente o suficiente para não
para fazer mais i-nodes do que pode ser usado, então a ineficiência não é esta
mau. Por padrão, serão criados 184 i-nodes ocupando 23 blocos. Contudo,
por causa da sobrecarga do sistema de arquivos ext2, o Linux normalmente usa o
Sistema de arquivos MINIX 1 em disquetes e outros dispositivos pequenos.
53. Muitas vezes é essencial ter alguém que possa fazer coisas que normalmente são para-
convidado. Por exemplo, um usuário inicia um trabalho que gera uma quantidade infinita de
saída. O usuário então se desconecta e sai de férias de três semanas em Londres.
Mais cedo ou mais tarde, o disco ficará cheio e o superusuário terá que manualmente
matar o processo e remover o arquivo de saída. Outros exemplos existem.
54. Provavelmente alguém estava com o arquivo aberto quando o professor alterou as permissões
sões. O professor deveria ter deletado o arquivo e depois colocado outra cópia
no diretório público. Além disso, ele deve usar um método melhor para distribuir
arquivos, como uma página da Web, mas isso está além do escopo deste exercício.
55. Se, digamos, direitos de superusuário forem dados a outro usuário com a chamada de sistema fsuid ,
esse usuário pode acessar arquivos de superusuário, mas não será capaz de enviar sinais, matar
processos ou realizar outras operações que requerem privilégios de superusuário.
56. (a) A maioria dos arquivos são listados com zero bytes de tamanho e contêm uma grande quantidade
de informação. Isso ocorre porque esses arquivos não existem no disco. O sistema
recupera as informações do processo real conforme necessário.
(b) A maioria das configurações de hora e data refletem a hora e a data atuais. Isto é
devido ao fato de que a informação é apenas recuperada e, em muitos casos, é
constantemente atualizado.
(c) A maioria dos arquivos são somente leitura. Isso ocorre porque as informações que eles fornecem
está relacionado ao processo e não pode ser alterado pelos usuários.
57. A atividade precisará salvar a posição de rolagem atual do usuário e o nível de zoom
para poder voltar a mostrar a mesma parte da página web que antes. Isto
também precisará salvar todos os dados que o usuário inseriu nos campos do formulário para que eles
não se perder. Não é necessário salvar nada do download para exibir o
página da web (HTML, imagens, JavaScript, etc); isso sempre pode ser recuperado e
Página 71
analisado quando a atividade é restaurada e, geralmente, os dados ainda estarão no

cache em disco local do navegador.
58. Você precisa manter o dispositivo funcionando enquanto lê e armazena o

dados baixados, então o código de rede deve manter um wake lock durante este
Tempo. (Crédito extra: o aplicativo também precisará ter solicitado o inter-
permissão de rede , conforme implícito na Fig. 10-63.)
59. Todos os seus tópicos precisam ser iniciados após a bifurcação. O novo processo irá apenas
ter o fio de bifurcação rodando nele; se você já iniciou outros tópicos,
eles não estariam no novo processo e deixariam o processo em uma
estado definido.
60. Você sabe que o chamador, de alguma forma, recebeu explicitamente uma referência a
seu objeto original. No entanto, você não sabe se o chamador é o mesmo procedimento
essência para a qual você enviou originalmente o objeto - esse processo pode ter se dado
o objeto para outro processo.
61. À medida que mais RAM é necessária, o assassino sem memória começará a matar o processo em
peça do menos necessário para o mais. A partir da ordem de operações, temos
dados, podemos determinar que temos processos em execução com esses
níveis de falta de memória:
1. navegador: FOREGROUND
2. e-mail: SERVIÇO
3. lançador: HOME
4. câmera: CACHED
O assassino de falta de memória vai, portanto, começar na parte inferior e subir, primeiro
matando o processo da câmera, o inicializador e, finalmente, o e-mail.
Página 72
1. Uma vantagem é que tudo está em um só lugar, o que torna mais fácil encontrar. UMA
desvantagem é que um bloco de disco defeituoso no índice de nível superior em uma hiv e pode
causar um desastre em todo o sistema.
2. O HAL é simples e direto. Incluindo o mouse, o disco e todos
os outros drivers de dispositivo nele o tornariam pesado e destruiriam sua função
como uma camada fina que esconde certas diferenças básicas de hardware do computador
self, mas não os dispositivos de E / S.
3. Um banco de dados genealógico pode achar conveniente registrar o nascimento e a morte

datas dos ancestrais de uma pessoa usando o formato de hora do sistema padrão. Na verdade, qualquer
banco de dados histórico pode usar isso.
4. Se as alças contiverem um número de sequência, então quando uma alça for fechada e
continuou a ser usado, isso poderia ser facilmente detectado comparando a sequência
em cada identificador para um número de sequência na tabela de identificador. Sala para o se-
O número de sequência teria de ser encontrado tanto no identificador quanto na entrada da tabela.
Cada vez que uma entrada da tabela de manipulação é reutilizada, o número de sequência é incrementado,
e o número de sequência está embutido no identificador. Se o número de sequência
é N bits, então um identificador particular teria que ser fechado e reaberto 2 N
vezes para evitar a detecção. Então, mesmo para um pequeno N, muitas condições de corrida de controle
podem ser detectados em programas.
5. (a) O gerenciador de processos usa o gerenciador de objetos para criar threads.

(b) O gerenciador de memória usa o gerenciador de segurança para ver se um arquivo pode ser mapeado
ped.
(c) O gerenciador plug-and-play usa o gerenciador de configuração para registrar um
Novo dispositivo.
6. Um sinal é tratado por um novo encadeamento em algum contexto de processo, por exemplo,
quando a tecla Quit é pressionada ou mesmo quando um thread falha. Realmente não faz
qualquer sentido para capturar um sinal no contexto de um thread. Realmente tem que ser por processo.
Portanto, o tratamento de sinais é, na verdade, uma atividade por processo.
7. Faria mais sentido em servidores. As máquinas clientes têm menos concorrentes

processos. Bibliotecas compartilhadas só fazem sentido se houver vários processos
compartilhando-os. Caso contrário, é mais eficiente vincular estaticamente as bibliotecas e
aceitar duplicação. A vantagem da ligação estática é que apenas aqueles procedem
duras que são realmente necessárias são carregadas. Com DLLs, pode haver procedimentos
na memória que ninguém está usando.
8. A questão é se um thread do kernel poderia usar a mesma pilha que seu
thread do usuário correspondente, o que faria sentido, já que a maioria das chamadas de sistema começam
com uma pilha vazia e retornar ao modo de usuário com a pilha novamente vazia. 1
a razão dessas pilhas estarem separadas é por causa da sobrecarga que seria re-
Página 73
necessário versus o custo de manutenção de pilhas separadas. A sobrecarga é porque o

kernel teria que proteger a parte da pilha do usuário em que iria rodar
e certifique-se de que era grande o suficiente ou então pegue outro tópico para solicitar que seja
feito maior. Isso talvez pudesse ser evitado tendo o kernel sempre usando um
conjunto fixo de páginas no topo da pilha do modo de usuário, mas isso é como ter
uma pilha separada. Outra razão para a separação é que o kernel gosta de
saiba de onde vêm os dados para que possa decidir quanta validação é necessária.
Se um buffer é alocado em uma pilha de kernel separada, o buffer terá um kernel
endereço e verificação normalmente não são necessários. Se a pilha do kernel usa parte de
a pilha do usuário, então o kernel terá mais dificuldade em dizer se uma pilha
buffer é do thread do kernel ou do thread do usuário. Além do kernel
freqüentemente depende do fato de que as pilhas do kernel não podem ser paginadas. Então as páginas
da pilha do usuário que o kernel iria usar teria que ser bloqueado
memória. Por outro lado, não é muito caro alocar um
pilha - muito menos caro do que resolver todos esses problemas. O que faz o
threads caros não são as pilhas que usam, são todos os metadados necessários para
gerenciá-los.
9. A taxa de acerto nas entradas da tabela de páginas armazenadas em cache no TLB tem um grande impacto sobre
performance do sistema. A operação para percorrer as tabelas de páginas e encontrar um
a entrada é muito cara. Uma vez que a TLB tem apenas um número limitado de entradas,
usar páginas grandes de 2 MB aumenta muito quantos endereços virtuais podem ser
mapeado pelo TLB por vez. Páginas grandes desperdiçarão grandes quantidades de mem-
ory por causa do espaço não utilizado no final da página final dentro de uma região de
o arquivo. Portanto, eles são eficazes apenas quando usados em regiões muito grandes. Mas
mesmo assim, eles aumentam a pressão da memória na memória porque uma página grande é
provavelmente terá grandes quantidades de dados que não estão sendo acessados, e
teria sido paginado para o disco se usar páginas de 4 KB.
10. Há um limite de 32 operações porque existem apenas 32 bits de direitos no ob-

ject identificador.
11. Não é possível porque semáforos e mutexes são objetos executivos e

seções críticas, não. Eles são gerenciados principalmente no espaço do usuário (mas têm
um semáforo de apoio quando o bloqueio é necessário). O gerenciador de objetos não
sabem sobre eles e não possuem alças, como foi afirmado no texto.
Uma vez que WaitForMultipleObjects é uma chamada de sistema, o sistema não pode realizar um
OR booleano de várias coisas, uma das quais nada sabe. A chamada
deve ser uma chamada de sistema porque semáforos e mutexes são objetos de kernel. No
resumindo, não é possível ter qualquer chamada de sistema que mistura objetos de kernel e
objetos de usuário como este. Tem que ser um ou outro.
12. A variável pode ser um ponteiro para uma estrutura de dados alocada dinamicamente,
onde a inicialização e alocação da estrutura eram de responsabilidade de
o primeiro segmento que queria usá-lo. Se dois threads tentarem inicializar o
Página 74
variável quase ao mesmo tempo, duas estruturas diferentes podem ser alocadas
e um dos threads pode usar a instância errada. InitOnceExecuteOnce usa
uma variável extra, digamos, para registrar o estado de cada inicialização separada. Válido
os estados são: não inicializado, inicializando, inicializado . O tópico que vai realmente
fazer os registros de inicialização define atomicamente foo para inicializar . Quando ini-
a inicialização é concluída, ele define atomicamente foo como inicializado e chama WakeByAd-
dressAll . A configuração atômica e o exame de uma variável podem ser realizados
usando um cadeado ou uma instrução de hardware como comparar e trocar . Se um tópico
descobre que foo está definido como inicializado , então pula a inicialização. Se encontrar foo
definido como inicializando , ele chama WaitOnAddress para aguardar a conclusão da inicialização.
13. (a) O último tópico termina.
(b) Um thread executa ExitProcess .
(c) Outro processo com um identificador para este o mata.
(Aplicativos modernos) O sistema operacional decidiu encerrá-lo para recuperar espaço no arquivo de troca
ou porque o aplicativo estava sendo atendido.
14. O sistema operacional encerra aplicativos modernos, principalmente quando o sistema
está com pouca memória ou está sendo reinicializado. Se os aplicativos tentassem ser executados
no primeiro caso, pode não haver recursos suficientes para que eles tenham sucesso
salvar com sucesso seu estado. E, no último caso, eles podem atrasar indefinidamente
o desligamento do Windows, como costuma acontecer no Windows desktop. No entanto
os usuários podem alternar entre aplicativos com frequência, a frequência dessas trocas
está na escala humana de segundos ou minutos. Para um aplicativo bem escrito, o
poucos milissegundos necessários para salvar o estado não têm muito impacto. Addi-
opcionalmente, escrever aplicativos dessa forma cria uma melhor experiência do usuário onde o
aplicativo para travar, já que o último estado salvo está disponível como um ponto de verificação.
15. Como os IDs são reutilizados imediatamente, um programa que identificou um processo que
ele queria operar por ID pode descobrir que o processo morreu, e o ID
foi reutilizado entre o momento em que encontra o ID e o momento em que o usa. UNIX
não reutiliza IDs de processo até que todos os outros (32.000) IDs tenham sido usados. Então
embora o mesmo problema possa teoricamente ocorrer, as chances são muito baixas. Vencer-
A dows evita esse problema mantendo a lista livre em ordem FIFO, de modo que os IDs
normalmente não são reutilizados por muito tempo. Outra solução poderia ter sido
adicione números de sequência, como foi sugerido para identificadores de objeto para resolver um
problema com a reutilização do cabo comum. Em geral, os aplicativos não devem identificar
ify um determinado processo apenas pelo ID, mas também pelo carimbo de data / hora de criação. Para
fazer uma operação em um processo que o ID é usado para obter um identificador. O tempo de criação-
o selo pode ser verificado uma vez que o identificador é obtido.
16. No máximo alguns microssegundos. Ele antecipa o segmento atual imediatamente. Isto é
apenas uma questão de quanto tempo leva para executar o código do despachante para fazer o thread
interruptor.
Página 75
17. Ter sua prioridade reduzida abaixo da prioridade básica pode ser usado como um trocadilho
ishment por usar tempo excessivo de CPU ou outros recursos.
18. O AutoBoost precisaria aumentar a prioridade de um thread A somente quando um alto

O thread B de prioridade er estava esperando por um recurso mantido pelo thread A. Para fazer isso
O AutoBoost precisaria manter o controle de todos os recursos do sistema, e
qual thread continha cada recurso. Quando B bloqueia, AutoBoost encontraria A e
elevar temporariamente a sua prioridade para a de B.
19. Para threads de modo kernel, suas pilhas e a maioria das estruturas de dados de que precisam
para acessar permanecem acessíveis mesmo depois de alterar os espaços de endereço, porque eles
são compartilhados por todos os processos. Se os tópicos do modo de usuário mudassem de endereço
espaços, eles perderiam o acesso às suas pilhas e outros dados. Encontrando uma solução
para o modo de usuário, como alterar pilhas durante uma chamada de processo cruzado,
permitir que os threads criem processos como limites de isolamento e passem a CPU para
entre eles da mesma forma que a CPU passa do modo de usuário para o modo kernel.
Chamadas de procedimento de processo cruzado podem ser feitas sem envolver o agendador
para suspender o chamador e acordar o receptor no processo do servidor (e vice-versa
ao retornar).
20. Uma maneira é aumentar a prioridade de processos importantes. Uma segunda maneira é
dar a processos importantes quanta mais longos.
21. Embora os conjuntos de trabalho não estejam sendo cortados, os processos ainda estão modificando
páginas apoiadas por arquivos. Esses arquivos serão periodicamente enviados para o disco. Também
aplicativos fazem liberações explícitas de páginas para o disco para preservar os resultados e
manter a consistência nos arquivos. Tanto o sistema de arquivos quanto o registro estão ativos, todos os
tempo, e eles tentam garantir que os volumes e colmeias não percam dados se o
sistema fosse quebrar.
22. Para discos rotativos, a variável mais significativa que afeta o desempenho é o
número de operações de busca necessárias para executar E / S. Normalmente não é o número
ber de I / Os que afetam o desempenho, mas quando muitos pedaços diferentes no disco
deve ser acessado. Reduzir o conjunto de trabalho faz com que o Windows lide com o
páginas de memória para um processo, alguns de cada vez. Porque o Windows aloca
espaço nonaarquivo
alocados de página
memória, quandodeaspáginas
as gravações páginasgeralmente
são escritaspodem
em vezserdegravadas
quando são
no mesmo
região do disco, reduzindo o número de buscas necessárias para gravar páginas no disco.
Os processos de primeiro plano pertencentes a aplicativos modernos param de funcionar
logo depois que o usuário desliga ou desliga a tela. Isso significa que
o conjunto de trabalho exigido pelo processo repentinamente cai para zero. Mas não
significa que o processo não precisa dessas páginas. Ele simplesmente não precisa deles
até que o usuário volte para o aplicativo. Naquela época, é provável que
a maioria dessas páginas, de repente, será necessária novamente. Isso é diferente de
a situação normal em que as páginas são cortadas porque o aplicativo estava fazendo
algo mais. No caso de aplicativos modernos, é que o usuário (e, portanto, o
Página 76
sistema) estão fazendo outra coisa. A troca não permite apenas as páginas
de um aplicativo específico para serem movidos de forma eficiente para o disco juntos. Mais
importante, traz de volta de forma eficiente todas as páginas de que o aplicativo precisará
na memória de uma vez em vez de usar paginação sob demanda. Paginação por demanda
traria apenas as páginas conforme necessário. Inicialmente, o aplicativo seria
execute um pouco, falha de página, execute um pouco mais, falha de página novamente, até o conjunto de trabalho
tinha sido construído de volta. Cada falha de página separada pode exigir uma busca, se houver
a atividade de E / S intermediária fez com que o disco se afastasse da área de troca.
23. No x86, o auto-mapa é feito pegando duas das entradas na página di-
reitoria e, em vez de fazer com que eles apontem para uma página de tabela de página, eles apontam para
o diretório da página que os contém. Essas entradas são configuradas na página di-
reitoria para um processo quando ele é inicializado pela primeira vez. Uma vez que as mesmas entradas de PDE são
sempre usado, o endereço virtual do auto-mapa será o mesmo em todos os proc-
ess.
24. Para mapear 4 GB de espaço de endereço requer 1M PTEs. Se PTES tiver apenas 4 bytes
cada um, então a tabela de página inteira tem apenas 4 MB.
25. Sim. Os VADs são a forma como o gerenciador de memória mantém o controle de quais anúncios
vestidos estão em uso e são gratuitos. Um VAD é necessário para uma região reservada
para evitar que uma tentativa subsequente de reservar ou comprometê-lo seja bem-sucedida.
26. (1) é uma decisão política sobre quando e como cortar um conjunto de trabalho. (2) e (3)
é requerido. (4) é uma decisão política sobre a agressividade de escrever sujo
páginas para o disco. (5) e (6) são obrigatórios. (7) não é realmente uma questão de política ou
obrigatório; o sistema nunca tem que zerar páginas, mas se o sistema for diferente
ocioso, zerar páginas é sempre melhor do que apenas executar o loop ocioso.
27. Não é movido de forma alguma. Uma página vai para uma das listas apenas quando não é
presente em qualquer conjunto de trabalho. Se ainda estiver em um conjunto de trabalho, não continua
qualquer uma das listas gratuitas.
28. Não pode entrar na lista modificada, pois contém páginas que ainda estão mapeadas
em e pode ser criticado de volta. Uma página não mapeada não está nessa categoria. Isto
certamente não pode ir diretamente para a lista gratuita porque essas páginas podem ser abandonadas
doado à vontade. Uma página suja não pode ser abandonada à vontade. Conseqüentemente,
primeiro deve ser gravado de volta no disco, então ele pode ir para a lista gratuita.
29. Um evento de notificação significa que todos os threads em espera se tornarão executáveis
quando o evento é sinalizado. Isso pode resultar em muitas mudanças de contexto extras
conforme os threads tentam adquirir o evento apenas para bloquear novamente. Em um único proc-
essor, se o tempo de bloqueio for muito menor do que o quantum, então é provável
que no momento em que os outros threads começarem a ser executados, o bloqueio terá sido liberado
pelo tópico anterior para adquiri-lo. Mas com tempos de espera curtos, a probabilidade
de muitos threads esperando pelo bloqueio é muito menor de qualquer maneira. Com um mul-
processador, mesmo tempos de espera curtos podem resultar em trocas de contexto desnecessárias
Página 77
porque os threads que são desbloqueados podem estar todos programados para executar o im-
mediatamente em processadores diferentes, mas bloqueia imediatamente, como apenas um segmento
terá sucesso em adquirir o bloqueio.
30. Exemplos de programas que hospedam DLLs para terceiros incluem servidores da Web,
navegadores e editores de documentos. As DLLs hospedadas podem ser questionáveis
qualidade e pode desestabilizar o programa de hospedagem. Ao criar uma cópia do
processo hospedado para executar a DLL, o processo original pode ser isolado contra
bugs ou (se estiver usando alguma forma de processo de sandboxing) ataques.
31. Existem dois registros. Os campos são os seguintes. Os valores antes dos dois pontos
são os campos de cabeçalho:
Registro 1 = 0, 8: (3, 50), (1, 22), (3, 24), (2, 53)
Registro 2 = 10, 10: (1, 60)
32. O fato de que o bloco 66 é contíguo a uma passagem existente não ajuda, pois o
os blocos não estão em uma ordem lógica de arquivo. Em outras palavras, usando o bloco 66 como o novo
bloco não é melhor do que usar o bloco 90. As entradas no MFT são:
0, 8: (4, 20), (2, 64), (3, 80), (1, 66)
33. É um acidente. Os 16 blocos aparentemente comprimidos em 8 blocos. Poderia

foram 9 ou 11 com a mesma facilidade.
34. Todos, exceto o SID do usuário, podem ser removidos sem afetar a força do
segurança.
35. Um invasor geralmente tem acesso a um ambiente de computação e o usa para
tente obter o controle de um ambiente de computação diferente e protegido. Existem
muitos exemplos: usando um sistema para se conectar a um serviço em outro sistema
que não possui um firewall adequado; executando Javascript dentro de um navegador
e obter o controle do navegador; executando como um usuário comum e obtendo
controle do kernel.
Começando com uma vulnerabilidade, como um estouro que de alguma forma permite que
invasor para modificar locais arbitrários na memória, o que eles fazem com isso?
Como eles encontram a memória para modificar? Se pilhas, ou tabelas de funções virtuais em
o heap, estão no mesmo endereço em todas as máquinas, eles podem apenas modificar
gire os endereços e os ponteiros de função que eles encontrarem para, em última análise, obter os
grama para pular para onde quiserem. Para onde eles querem que o programa vá? Se isso
não eram para proteção de não execução, eles podiam apenas pular para as instruções mas-
consultar como dados de entrada. Sem isso, eles têm que escolher instruções que são
já executável e pule para eles. Se eles puderem encontrar uma série de informações úteis
sequências de construção, geralmente terminando em um retorno (ou seja, gadgets), e eles podem
acumular dados na pilha que podem ser interpretados como uma série de stackframes,
eles podem executar programas bastante interessantes usando essa técnica.
O ponto relevante é que em dois pontos da descrição acima o invasor
Página 78
precisa ter uma boa ideia de onde os dados e o código estão localizados no espaço de endereço
ela está atacando. ASLR embaralha os espaços de endereço, portanto, não é tão provável que o at-
o defensor pode apenas adivinhar com muita probabilidade de sucesso. Mas vazamento de informações
significa que ele pode não precisar.
Um vazamento de informações é uma vulnerabilidade em que o sistema será inap-
disponibilizar informações que possam ser usadas para adivinhar com sucesso
onde algo útil como uma pilha ou DLL reside no espaço de endereço de um par-
sistema ou processo específico.
A fonte de vazamento de informações pode incluir APIs de serviço remoto,
mentação de idiomas hospedados em outros programas e chamadas de sistema, incluindo
a implementação de controles de I / O em drivers de dispositivo.
36. Não. Quando uma DLL é carregada, ela executa o código dentro do processo. Este código
pode acessar toda a memória do processo e pode usar qualquer uma das alças, e
todas as credenciais no token padrão do processo. A única coisa que representa
ação permite que o processo adquira novos identificadores usando as credenciais de
o cliente que está personificando. Permitindo que QUALQUER código não confiável seja executado
dentro do processo significa que qualquer uma das credenciais acessíveis a esse processo
agora ou no futuro pode ser mal utilizado. Isso é algo a considerar na próxima vez
você usa qualquer navegador configurado para baixar o código de sites não confiáveis.
37. O agendador sempre tentará colocar o encadeamento em seu processador ideal, ou falhará
isso, de volta para um processador no mesmo nó. Assim, mesmo que o tópico seja
atualmente em execução em um processador em um nó diferente, no final da página
falha, ele pode, de fato, ser programado de volta para seu nó preferencial. Se todos os processadores
nesse nó continuar a estar ocupado, ele pode ser executado em um nó diferente e pagar o
penalidade por acesso mais lento à página que acabou de ser interrompida. Mas é mais
provavelmente terminará de volta em seu nó preferido, mais cedo ou mais tarde, e, assim, se beneficiará
desta colocação de página no longo prazo.
38. As operações de metadados no sistema de arquivos, como a troca de arquivos de recuperação, podem
criar momentos inoportunos em que travamentos resultariam em nenhum arquivo de recuperação.
Ter a oportunidade de liberar buffers de dados internos permite que o aplicativo
crie um estado consistente do qual seja mais fácil recuperar. Permitindo o aplicativo
ção para terminar operações complexas simplificaria a quantidade de lógica necessária
durante a recuperação.
Em geral, permitindo que um aplicativo se prepare para o instantâneo do volume
permite reduzir a quantidade de estado transitório que deve ser tratado quando
recuperando mais tarde. A recuperação de falhas é geralmente difícil de testar porque é muito
difícil avaliar todas as combinações possíveis de condições de corrida que são pos-
sible. Teoricamente, é possível projetar software que pode lidar com todos os tipos
de cenários de recuperação e falha, mas é muito difícil. Um exemplo de software
que enfrenta esses desafios é o próprio sistema de arquivos NTFS. Muito design,
análise e testes foram investidos para tornar altamente provável que
O NTFS pode se recuperar de uma falha sem ter que executar chkdsk (o Windows 'e-
Página 79
quivalente do fsck do UNIX ). Em sistemas de arquivos corporativos muito grandes, um chkdsk para
a recuperação após uma falha pode levar horas ou dias.
39. A última página em um arquivo mapeado em memória deve conter zeros após o último
dados. Caso contrário, se um driver de E / S para um disco sobrescrever apenas parte da página com
dados do disco, os dados anteriores no resto da página seriam expostos.
Isso não é um problema para as páginas anteriores do arquivo porque o sistema lerá
uma página completa do arquivo antes de dar acesso ao código do modo de usuário. Quando
as páginas da pilha são alocadas conforme a pilha cresce, elas devem conter todos os zeros, não
quaisquer dados aleatórios que possam ter sido deixados lá pelo inquilino anterior.
40. Quando um servidor individual é corrigido, o administrador do sistema tem um monte de dis-
crítica sobre o agendamento das atualizações para um horário conveniente. Se a raiz operar
sistema de instalação precisa ser reiniciado para instalar atualizações, os sistemas convidados não
precisam reinicializar, mas devem ter toda a memória que estão usando salva no disco
antes que o sistema operacional raiz seja reinicializado e restaurado posteriormente. Isso envolve um
quantidade muito grande de I / O e pode levar minutos embora o sistema operacional raiz
A reinicialização leva apenas alguns segundos. Durante esses minutos, o sistema operacional do convidado
tem ficará indisponível.
Uma solução é evitar fazer o I / O, não modificando ou limpando o
memória usada pelos sistemas convidados quando o sistema operacional raiz é reinicializado.
Em vez de salvar e restaurar toda a memória no disco, o sistema operacional raiz
pode apenas deixá-lo na RAM e gravar no disco apenas as informações necessárias para encontrar
a memória do convidado após a reinicialização.
Página 80
1. As melhorias no hardware do computador foram em grande parte devido a transistores menores

tor. Alguns fatores que podem limitar isso são: (a) as propriedades de onda da luz podem
limitar as técnicas fotolitográficas convencionais para a produção de circuitos integrados
cuits, (b) a mobilidade de átomos individuais em sólidos pode levar à degradação de
as propriedades de camadas muito finas de semicondutores, isoladores e condutores
tores, e (c) a radioatividade de fundo pode interromper as ligações moleculares ou afetar
cobranças armazenadas muito pequenas. Certamente existem outros.
2. Para programas altamente interativos, o modelo de evento pode ser melhor. Destes, apenas
(b) é interativo. Assim, (a) e (c) são algorítmicos e (b) é orientado por eventos.
3. Não. A diferença está mais relacionada ao fato de que os servidores DNS armazenam em cache e são
organizado hierarquicamente. Os caminhos poderiam facilmente ter sido dados no topo
ordem para baixo, mas a convenção de fazer isso ao contrário agora está bem estabelecida.
4. Possivelmente stat é redundante. Pode ser conseguida por uma combinação de aberto ,
fstat e fechar . Seria muito difícil simular qualquer um dos outros.
5. Se os drivers forem colocados abaixo dos threads, os drivers não podem ser threads independentes
no estilo do MINIX 3. Eles precisam ser executados como parte de algum outro tópico, mais
no estilo UNIX.
6. É possível. O que é necessário é um processo em nível de usuário, o servidor semáforo que
gerencia semáforos. Para criar um semáforo, um usuário envia uma mensagem perguntando
para um novo semáforo. Para usá-lo, o processo do usuário passa a identidade do
semáforo para outros processos. Eles podem então enviar mensagens para o semáforo
servidor pedindo uma operação. Se a operação for bloqueada, nenhuma resposta será enviada de volta,
bloqueando assim o chamador.
7. O padrão é 8 ms de código do usuário e 2 ms de código do sistema. Com o opti-

mização, cada ciclo é agora de 8 mseg de código de usuário e 1 mseg de código de sistema.
Assim, o ciclo é reduzido de 10 ms para 9 ms. Multiplicando por 1000 tais
ciclos, um programa de 10 segundos agora leva 9 segundos.
8. Os nomes externos podem ser tão longos quanto necessários e de comprimento variável. interno
os nomes são geralmente de 32 ou 64 bits e sempre com comprimento fixo. Nomes externos
não precisa ser único. Dois nomes podem apontar para o mesmo objeto, por exemplo,
links no sistema de arquivos UNIX. Os nomes internos devem ser exclusivos. Nomes externos
pode ser hierárquico. Os nomes internos são geralmente índices em tabelas e, portanto,
formam um namespace simples.
9. Se a nova mesa tiver 2 × o tamanho da antiga, ela não vai encher rapidamente, reduzindo
o número de vezes que uma tabela atualizada será necessária. Por outro lado, então
pode não ser necessário muito espaço, portanto, pode desperdiçar memória. Este é um clássico
trade-off entre tempo e espaço.
Página 81
10. Seria arriscado fazer isso. Suponha que o PID esteja na última entrada. Em
Nesse caso, sair do loop deixaria p apontando para a última entrada. No entanto, se
o PID não foi encontrado, p pode acabar apontando para a última entrada ou para uma
além dele, dependendo dos detalhes do código compilado, cujas otimizações
foram ativados e assim por diante. O que pode funcionar com um compilador pode falhar com
um diferente. É melhor definir uma bandeira.
11. Isso poderia ser feito, mas não seria uma boa ideia. Um driver IDE ou SCSI é
muitas páginas. Ter o código condicional tão longo torna o código-fonte
difícil de seguir. Seria melhor colocar cada um em um arquivo separado e então
use o Makefile para determinar qual incluir. Ou, pelo menos, con
A compilação tradicional pode ser usada para incluir um arquivo de driver ou outro.
12. Sim. Isso torna o código mais lento. Além disso, mais código significa mais bugs.
13. Não é fácil. Múltiplas invocações ao mesmo tempo podem interferir em uma
de outros. Pode ser possível se os dados estáticos forem protegidos por um mutex, mas isso
significaria que uma chamada para um procedimento simples pode ser bloqueada inesperadamente.
14. Sim. O código é replicado sempre que a macro é chamada. Se é chamado de muitos
vezes, o programa será muito maior. Este é um típico comércio de espaço-tempo
off: um programa maior e mais rápido em vez de um programa menor e mais lento. No entanto, em
um caso extremo, o programa maior pode não caber no TLB, fazendo com que ele
thrash e, portanto, correr mais devagar.
15. Comece por EXCLUSIVE-ORing os 16 bits inferiores e superiores da palavra juntos

para formar um inteiro de 16 bits, s . Para cada bit, existem quatro casos: 00 (resulta em um
0), 01 (resulta em 1), 10 (resulta em 1) e 11 (resulta em 0). Assim, se o
o número de 1s em s é ímpar, a paridade é ímpar; caso contrário, é mesmo. Fazer uma mesa
com 65.536 entradas, cada uma contendo um byte com o bit de paridade nele. O
macro se parece com isto:
# define bits de paridade (w) [(w & 0xFFFF) ˆ ((w >> 16) & 0xFFFF)]
16. Sem circunstâncias. O valor da cor '' comprimida '' seria tão grande quanto o original
nal e, além disso, uma enorme paleta de cores pode ser necessária. Não faz sentido em
tudo.
17. A paleta de cores de 8 bits contém 256 entradas de 3 bytes cada para um total de
768 bytes. A economia por pixel é de 2 bytes. Assim, com mais de 384 pixels,
GIF ganha. Uma paleta de cores de 16 bits contém 65.536 entradas de 3 bytes cada,
para 196.608 bytes. A economia aqui é de 1 byte por pixel. Assim, com mais de
196.608 pixels, a compressão de 16 bits vence. Supondo uma proporção de 4: 3, o intervalo
cada ponto é uma imagem de 512 × 384 pixels. Para VGA (640 × 480), cores de 16 bits
requer menos dados do que a cor verdadeira de 24 bits.
Página 82
18. Para um caminho que está no cache de nome de caminho, não tem efeito porque o i-node é
ignorado de qualquer maneira. Se não for lido, não importa se já está na memória.
Para um caminho que não está no cache de nomes, mas envolve um nó i fixado, então
ning ajuda, pois elimina a leitura do disco.
19. Registrando a data da última modificação, o tamanho e, possivelmente, um sinal calculado

natureza, como uma soma de verificação ou CRC, pode ajudar a determinar se mudou desde
última referência. Uma advertência: um servidor remoto pode fornecer informações falsas
sobre um arquivo, e a regeneração local de uma assinatura calculada pode ser necessária
sary.
20. O arquivo pode receber um número de versão ou uma soma de verificação e esta informação
armazenado junto com a dica. Antes de acessar um arquivo remoto, uma verificação seria
feito para ter certeza de que o número da versão ou soma de verificação ainda está de acordo com o atual
alugar arquivo.
21. Um sistema de arquivos normalmente tentará gravar novos dados no disco disponível mais próximo
bloco após o último usado. Se dois arquivos estão sendo gravados simultaneamente
isso pode resultar na intercalação dos blocos de dados no disco, resultando em ambos os arquivos
sendo fragmentado e, portanto, mais difícil de ler. Este efeito pode ser amelio-
avaliado pelo armazenamento em buffer de dados na memória para maximizar o tamanho das gravações, ou gravando em
arquivos temporários e, em seguida, copiando cada saída para um arquivo permanente quando o pro-
grama termina.
22. Brooks estava falando sobre grandes projetos em que a comunicação entre o
programadores retarda tudo. Esse problema não ocorre com um
projeto por pessoa e para que a produtividade seja maior.
23. Se um programador pode produzir 1000 linhas de código por um custo de $ 100.000, uma linha
de código custa $ 100. O Windows 8 consiste em 50–100 milhões de linhas de código,
que chega a US $ 5–10 bilhões. Isso parece muito. Provavelmente Micro-
soft conseguiu melhorar a produtividade do programador usando ferramentas melhores para
que um programador pode produzir milhares de linhas de código por ano. Além disso,
grandes pedaços do Windows 8 não foram modificados do Windows 7, então o
quantidade de código novo no Windows 8 é apenas uma fração de seu tamanho total. No
por outro lado, a receita anual da Microsoft é de cerca de US $ 70 bilhões, portanto, gastando bil-
milhões de dólares no Windows 8 são possíveis.
24. Suponha que a memória custe $ 10 por GB (verifique os preços atuais). Então uma
máquina de baixo custo com um disco de 100 GB precisa de $ 1000 de RAM para seu disco.
Se o restante do PC for $ 500, o custo total será $ 1500. Isso é muito caro
sive para o mercado low-end.
25. Um sistema embarcado pode executar apenas um ou um pequeno número de programas. Se
todos os programas podem ser mantidos carregados na memória o tempo todo, pode não haver
precisa de um gerenciador de memória ou de um sistema de arquivos. Além disso, os motoristas iriam
ser necessário apenas para alguns dispositivos de I / O, e pode fazer mais sentido escrever
Página 83
os drivers de E / S como rotinas de biblioteca. Rotinas de biblioteca também podem ser melhores.
empilhados em programas individuais, em vez de bibliotecas compartilhadas, eliminando
a necessidade de bibliotecas compartilhadas. Provavelmente, muitos outros recursos poderiam ser eliminados
em casos específicos.
Página 84
82 SOLUÇÕES DE PROBLEMAS PARA O APÊNDICE A
SOLUÇÕES PARA O APÊNDICE A PROBLEMAS
1. XGA é 1024 × 768. Com 24 bits / pixel e uma taxa de quadros de 25 quadros / s, nós
obter 471.859.200 bits / s. Esta taxa é muito alta para UltraWide SCSI, que pode
só vá até 320 Mbps.
2. A televisão NTSC padrão tem cerca de 640 × 480 pixels. A 8 bits / pixel e 30
quadros / s, obtemos uma largura de banda de 73 Mbps. Mal dá certo com um
canal. Dois canais seriam demais.
3. Da tabela, HDTV é 1280 × 720 contra 640 × 480 para TV normal. Tem
três vezes mais pixels e, portanto, precisa de três vezes a largura de banda. A razão
filho, ele não precisa de quatro vezes mais largura de banda é que a proporção de
A HDTV é diferente da TV convencional para corresponder melhor ao filme de 35 mm.
4. Para avançar em câmera lenta, é suficiente que cada quadro seja exibido
duas ou mais vezes seguidas. Nenhum arquivo adicional é necessário. Para voltar atrás
devagar é tão ruim quanto voltar rapidamente, portanto, um arquivo adicional é necessário.
5. O áudio é amostrado a 16 bits por amostra, 44.100 vezes / segundo com dois canais.
Isso dá uma taxa de áudio descompactado de 1.411.200 bits / seg ou 176.400
bytes / s. Em 74 minutos, isso soma 747 MB. Esta é a capacidade total de
o CD. Não está comprimido de forma alguma. O motivo pelo qual os dados são limitados a 650 MB é
que melhor correção de erros é usada para dados, uma vez que um erro é mais sério do que
para música. Se até mesmo um fator de compressão tivesse sido usado em CDs de áudio,
os dados teriam sido inferiores a 374 MB e mais de 74 minutos poderiam
ser armazenado em um CD.
6. Existem 32.768 magnitudes possíveis. Por exemplo, suponha que o sinal
varia de -32,768 volts a +32,767 volts e o valor armazenado para cada sam-
ple é o sinal arredondado para o número mais próximo de milivolts, como um sinal
Inteiro de 16 bits. Um sinal de 16.0005 volts teria que ser registrado como
16.000 ou como 16.001. O erro percentual aqui é de 1/320%. No entanto, sup-
representar o sinal é 0,0005 volts. Isso é registrado em 0 ou 1. No último
caso, o erro é de 50%. Assim, o ruído de quantização afeta mais as amplitudes baixas
do que amplitudes elevadas. Concertos de flauta serão atingidos com mais força do que rock and roll devido
para suas amplitudes mais baixas.
7. Um esquema de compressão / expansão de volume pode ser implementado como segue.
Um bit da saída é reservado para sinalizar que o sinal gravado é expandido.
Os 15 bits restantes são usados para o sinal. Quando os 5 bits de alta ordem de
o sinal de 20 bits não é 00000, o bit de expansão é 0 e os outros 15 bits
conter os 15 bits de alta ordem dos dados amostrados. Quando os 5 bits de alta ordem
do sinal são 00000, o bit de expansão é ativado e a amplitude de 20 bits
o sinal é deslocado 5 bits para a esquerda. No final do ouvinte, o processo reverso leva
Lugar, colocar. Este esquema aumenta o ruído de quantização ligeiramente para sinais altos (devido
para um sinal de 15 bits em vez de um sinal de 16 bits), mas diminui para sinais silenciosos,
Página 85
SOLUÇÕES DE PROBLEMAS PARA O APÊNDICE A 83
quando o efeito da quantização é mais perceptível. Uma grande desvantagem é

que este não é um padrão e não funcionaria com os leitores de CD existentes, mas
poderia funcionar para música online tocada com um plugin especial que usasse este esquema
em ambas as extremidades. Uma versão mais sofisticada poderia usar 2 bits para denotar quatro diferentes
diferentes regimes de expansão para diferentes níveis de sinal.
8. PAL tem mais linhas de varredura e mais resolução espacial do que NTSC. Tem 625
linhas verticais contra 525 para NTSC. Ele também tem mais pixels por linha. Estes re-
procure uma imagem mais nítida e use a largura de banda extra. Por outro lado,
NTSC tem mais quadros por segundo, então é melhor para capturar ações rápidas.
Nenhum é '' melhor '' do que o outro neste sentido. Diferentes trade-offs têm
feito: melhor resolução no tempo versus melhor resolução no espaço. Tudo de
isso é completamente independente dos esquemas de codificação de cores usados.
9. A diferença não causa nenhum problema. O algoritmo DCT é usado para
codificar I-frames em um esquema semelhante a JPEG. Os macroblocos são usados em P-
frames para localizar macroblocos que apareceram em frames anteriores. Os dois
as coisas não têm nada a ver umas com as outras e não entram em conflito.
10. Não, eles não fazem. O algoritmo de compensação de movimento encontrará cada macro-
bloco no quadro anterior em algum deslocamento de sua localização atual. Por en-
codificando o fato de que o macrobloco atual deve ser retirado do anterior
quadro em uma posição (Δ x , Δ y ) da atual, não é necessário trans-
mit o próprio bloco novamente.
11. Os processos que suportam os três fluxos de vídeo já usam 0,808 do
Tempo de CPU, portanto, sobram 192 ms por segundo para o áudio. Proc de áudio
ess A é executado 33,333 vezes / s, o processo de áudio B é executado 25 vezes / s e o áudio
o processo C é executado 20 vezes / s, para um total de 78.333 execuções / s. Estas 78.333 corridas
pode usar 192 mseg, portanto, cada execução pode usar 192 / 78,333 ou 2,45 mseg.
12. O primeiro processo usa 0,400 da CPU. O segundo usa 0,375 do
CPU. Juntos, eles usam 0,775. O limite RMS para dois processos é
2 × (2 0,5 - 1), que é 0,828, portanto, o RMS tem garantia de funcionamento.
13. O PAL gera um quadro a cada 40 ms. Suponha que todos os streams estão ativados em
no mesmo instante (tempo 0). O limite superior de utilização, conforme comprovado por Liu
e Layland, não precisa se aplicar aqui. É possível agendar o primeiro quadro de
stream 0 a 0 ms, stream 1 a 5 ms, e assim por diante, até um máximo de 8
córregos. Então, no tempo de 40 ms, o segundo quadro do fluxo 0 é agendado e
em breve.
14. Desde 0,65 <ln 2, RMS sempre pode programar os filmes, não importa quantos
existem. Portanto, o RMS não limita o número de filmes.
Página 86
15. A sequência que começa em t = 150 é A 6, B 5, C 4, A 7, B 6, A 5 e C 5. Quando

C 5 termina em t = 235, não há trabalho a fazer até t = 240 quando A e B se tornam
pronto, então o sistema fica inativo por 5 mseg. A escolha de executar B 5 antes
C 4 é arbitrário. A outra forma também é permitida.
16. Um leitor de DVD é bom para visualização em casa, mas o alto tempo de busca da otimização atual
sistemas de gravação de cal limita sua utilidade para fornecer um único fluxo de
dados. As unidades de DVD não podem suportar vários streams com diferentes horários de início ou
Funções de controle semelhantes ao videocassete, como pausa, retrocesso e avanço rápido para dif-
usuários diferentes. Com a tecnologia atual, os dados teriam que ser armazenados em um buffer
memória extremamente grande. Os discos rígidos são simplesmente melhores.
17. Se o pior caso de espera for de 6 minutos, um novo fluxo deve começar a cada 6 minutos. Para
Filme de 180 minutos, 30 transmissões são necessárias.
18. A taxa de dados é de 0,5 MB / s. Um minuto de vídeo usa 30 MB. Ir em frente

ou para trás 1 minuto cada requer 60 MB.
19. Temos 2 × Δ T × 2 × 10 6 ≤! 50 × 2 20 × 8. Portanto, Δ T ≤ 105 seg.

20. HDTV não faz diferença. Ainda existem 216.000 frames no
filme. O desperdício de cada quadro é cerca de meio bloco de disco ou 0,5 KB. Para
todo o filme, essa perda é de 108 KB.
21. Há alguma perda para cada quadro. Quanto mais frames você tiver, mais perda
você tem. NTSC tem uma taxa de quadros mais alta, portanto, tem um pouco mais de perda. Mas
dados os números envolvidos, esta perda não é uma fração significativa do total
espaço em disco.
22. O principal efeito da HDTV são quadros maiores. Quadros grandes tendem a fazer o
desvantagem de pequenos blocos menos sérios porque grandes quadros podem ser lidos em
eficientemente. Assim, o argumento de desempenho do disco em favor de grandes blocos
diminui. Além disso, se os quadros não forem divididos em blocos (já que eles não são
aqui), ter I-frames que são uma fração substancial de um bloco é um sério
problema. Muitas vezes pode ocorrer que um bloco esteja parcialmente cheio e um grande quadro I
aparece a seguir, desperdiçando uma grande quantidade de espaço no bloco atual. No
todo, ir para HDTV favorece o modelo de bloco pequeno.
23. Em média, 1 KB pode ser desperdiçado por bloco. Um filme PAL de 2 horas requer
180.000 frames. Assim, o desperdício médio de espaço em disco total para este filme é
180.000 KB.
24. Cada bloco de índice de quadro pode armazenar até 2048/8 = 512 entradas. Desde cada frame
pode ter até 255 × 2 KB = 510 KB, o maior tamanho de arquivo pode ser:
512 × 510 KB = 261, 120 KB.
Página 87
SOLUÇÕES DE PROBLEMAS PARA O APÊNDICE A 85
25. Na Web, a duração é de 226 minutos. Portanto, o número total de frames é

25 × 226 × 60 = 339.000 quadros. Uma vez que cada bloco de índice de quadro pode se referir a
512 quadros, o número de blocos de índice necessários é 339000/512 ou 663.
26. O buffer é grande o suficiente se o número de quadros I for 4 ou menos. A probabilidade

capacidade de obter exatamente k quadros I é C (24, k ) I k B 24− k , onde I é 0,1 e B é
0.9. As probabilidades de obter exatamente 0, 1, 2, 3 e 4 quadros I são 0,0798.
0,213, 0,272, 0,221 e 0,129, respectivamente. A soma deles é 0,915. Esse
significa que há 0,085 ou 8,5% de chance de falha. Isso é muito grande para aceitar.
27. O buffer deve ser grande o suficiente para conter cinco quadros, uma vez que apenas 5% do
as trilhas têm mais de cinco quadros I.
28. Independentemente do formato, o número de fluxos simultâneos é 3 × 60/15 = 12.

29. Uma alternativa é ter um arquivo separado para cada idioma. Esta alternativa
minimiza o uso de RAM, mas desperdiça muito espaço em disco. Se o espaço em disco for
barato e o objetivo é oferecer suporte ao maior número possível de streams de uma vez,
proach é atraente. Outra alternativa é armazenar a trilha de áudio para cada
idioma separadamente e faça uma busca extra por quadro para buscar o áudio. Esse
esquema faz uso eficiente do espaço em disco, mas introduz buscas extras e, portanto,
diminui o desempenho.
30. A constante de normalização, C , é 0,36794, então as probabilidades são 0,368,

0,184, 0,123, 0,092, 0,074, 0,061, 0,053 e 0,046.
31. Um disco de 14 GB contém 14 × 2 30 ou 15.032.385.536 bytes. Se estes forem uniformemente

dividido em 1000 cilindros, cada cilindro contém 15.032.385, o que é apenas
o suficiente para um videoclipe de 30 segundos. Assim, cada clipe ocupa um cilindro. O
a questão é qual fração do peso total é representada pelos 10 primeiros
clipes de 1000. Somando 1, 1/2, ... 1/10, temos 2,92895. Multiplicando isso
por 0,134 obtemos 0,392, então o braço passa quase 40% de seu tempo dentro do
10 cilindros intermediários.
32. Para quatro itens, a lei de Zipf produz probabilidades de 0,48, 0,24, 0,16 e 0,12.
As proporções dessas probabilidades também descrevem a utilização relativa das unidades
para a Fig. 12-0 (a). Para os outros três arranjos de striping, todas as unidades serão
usado igualmente, supondo que todo mundo que paga por um filme o assiste
até o fim. O resultado em um determinado momento pode ser diferente, no entanto.
Se todo mundo na cidade quer começar a assistir a um filme em 8 AM a REGIME
da Fig. 12-0 (b) atingiria inicialmente o primeiro disco mais rígido, depois o próximo disco
15 minutos depois, etc. Os arranjos da Fig. 12-0 (c) ou (d) não seriam
afetado dessa forma.
33. O PAL é executado a 25 quadros / s, de modo que os dois usuários estão fora por 150 quadros. Fundir
em 3 min significa fechar a lacuna em 50 frames / min. Um vai 25
quadros / min mais rápido e 25 quadros / min mais lento. A taxa de quadros normal
Página 88
é de 1500 frames / min, então a velocidade de aumento ou redução é 25/1500 ou 1/60, que é
cerca de 1,67%.
34. Para NTSC, com 30 quadros / s, uma rodada é 33,3 mseg. O disco gira 180
vezes / s, então a latência rotacional média é meia rotação ou 2,8 mseg.
O MPEG-2 é executado a cerca de 500.000 bytes / s ou cerca de 16.667 bytes / quadro. Em 320
MB / s, o tempo de transferência de um quadro é de cerca de 51 μs . Assim, a busca, rota-
a latência regional e os tempos de transferência somam cerca de 5,8 mseg. Cinco fluxos assim
consumir 29 ms de 33,3 ms, que é o máximo.
35. O tempo médio de busca vai de 3,0 mseg a 2,4 ms, então o tempo por operação
ção é reduzida para 5,2 mseg. Isso adiciona mais um fluxo, totalizando seis.
36. As solicitações são ordenadas, com base no cilindro solicitado, conforme: (40, 210), (32, 300),
(34, 310), (36, 500). O horário de término de cada solicitação é, na ordem: 21 mseg, 27
mseg, 33 mseg, 39 mseg. Assim, o sistema perderá o último prazo, se o
o algoritmo acima é usado.
37. Seis fluxos. Fazer listras é inútil. Cada operação de disco ainda leva 5,2 ms para
controle os dados. Se o tempo de transferência é 51 μ seg ou 13 μ seg
não faz muita diferença.
38. Para o primeiro lote de cinco solicitações, o crítico é para o cilindro 676, o quarto em
a lista, mas com um prazo de t = 712 mseg. Portanto, cada solicitação deve ser atendida
em 3 ms ou menos para que o quarto seja executado em t = 712 ms.

MOS 4th Respostas

Enviado por

Direitos autorais:

Formatos disponíveis

MOS 4th Respostas

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

MOS 4th Respostas

Enviado por

Direitos autorais:

Formatos disponíveis

21/08/2021 SISTEMAS OPERACIONAIS MODERNOS

RIO SELIM SUPERIOR, NJ 07458

Copyright Pearson Education, Inc. 2014

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

SOLUÇÕES PARA O CAPÍTULO 1 PROBLEMAS

1. Um sistema operacional deve fornecer aos usuários uma máquina estendida, e

2. Obviamente, existem muitas respostas possíveis. Aqui estão alguns.

4. A evidência empírica mostra que o acesso à memória exibe o princípio da localidade

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

2 SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 1

8. Uma tela de texto monocromática de 25 × 80 caracteres requer um buffer de 2.000 bytes. o

11. Número de cabeças = 255 GB / (65536 * 255 * 512) = 16

13. Pode demorar 20, 25 ou 30 ms para concluir a execução desses programas de

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 1 3

15. Tempo médio de acesso =

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

4 SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 1

23. Ele contém os bytes: 1, 5, 9, 2.

24. Hora de recuperar o arquivo =

29. Várias chamadas UNIX não têm contrapartida na API Win32:

Chmod : o Windows usa listas de controle de acesso.

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 1 5

32. A camada de virtualização apresenta maior uso de memória e processador

33. As conversões são diretas:

(a) Um nanoear é 10 -9 × 365 × 24 × 3600 = 31.536 mseg.

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

6 SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 2

SOLUÇÕES PARA O CAPÍTULO 2 PROBLEMAS

1. A transição do bloqueado para o funcionamento é concebível. Suponha que um processo

8. A probabilidade de que todos os processos estejam esperando por I / O é 0,4 6, que é

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 2 7

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

8 SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 2

20. Os ponteiros são realmente necessários porque o tamanho da variável global é

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 2 9

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

10 SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 2

exclusão e, em seguida, o contador é incrementado. Se for mais do que zero, ninguém

36. Os funcionários se comunicam passando mensagens: pedidos, comida e sacolas em

SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 2 11

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

12 SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 2

49. A sequência de previsões é 40, 30, 35 e agora 25.

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 2 13

57. Um possível script de shell pode ser

E se [ ! –F números]; então echo 0> números; fi

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

14 SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 3

SOLUÇÕES PARA O CAPÍTULO 3 PROBLEMAS

7. (a) 8212. (b) 4100. (c) 24684.

© Copyright 2015 Pearson Education, Inc. Todos os direitos reservados.

SOLUÇÕES DE PROBLEMAS PARA O CAPÍTULO 3 15

10. Se o smartphone suportar multiprogramação, que o iPhone, Android,

11. Para esses tamanhos