Sistemas_Operacionais_resposta

Prévia do material em texto

Processo | Tempo de Chegada | Surto | Prioridade 
P0 | 0 | 12 | 3 
P1 | 1 | 03 | 0 
P2 | 2 | 05 | 1 
P3 | 3 | 03 | 2 
P4 | 4 | 10 | 7 
P5 | 5 | 16 | 3 
________________________________________________________________ 
FCFS: |0 |12 |15 |20 |23 |33 
 12 3 5 3 10 16 
 P0 P1 P2 P3 P4 P5 
(0+12+15+20+23+33)/6 = 17,17 
SJF não Preemptivo: 
 |0 |3 |6 |11 |21 |33 
 3 3 5 10 12 16 
P1 P3 P2 P4 P0 P5 
(0+3+6+11+21+33)/6 = 12,33 
SJF Preemptivo: 
 |0|1|4 |7 |12 |22 |33 
 1 3 3 5 10 11 16 
 P0 P1 P3 P2 P4 P0 P5 
((22-1)+(1-1)+(4-3)+(7-2)+(12-4)+(33-5))/6 = 10,5 
SJF Prioridade: 
 |0 |3 |8 |11 |23 |39 
 3 5 3 12 16 10 
 P1 P2 P3 P0 P5 P4 
(0+3+8+11+23+39)/6 = 14 
Round-Robin Q=4: 
 |0 |4 |7 |11 |14 |18 |22|26|27|31|35 |39|43|45|49 
 4 3 4 3 4 4 4 1 4 4 4 4 2 4 4 
P0 P1 P2 P3 P4 P5 P0 P2 P4 P5 P0 P4 P5 P5 
((0+22-4+39-26)+(4-1)+(7-2+26-11)+(11-3)+(14-4+31-18+43-35)+(18-5+35-22+45-39))/6 = 
21,83 
1) Considere o seguinte conjunto de processos, com a duração de surto de CPU expressa em 
milissegundos 
a) Desenhe os diagramas de Gantt que ilustre a execução desses processos usando os 
seguintes escalonadores, FCFS, SFJ preemptivo e não preemptivo, por prioridade e RR 
b) Qual dos escalonadores do item a resulta no tempo de espera médio, mínimo e máximo; 
2). Considere uma aplicação que utilize uma matriz na memória principal para a comunicação 
entre vários processos concorrentes. Que tipo de problema pode ocorrer quando dois ou mais 
processos acessam uma mesma posição da matriz? 
Uma situação como essa, em que vários processos acessam e manipulam os 
mesmos dados concorrentemente e o resultado da execução depende da ordem 
específica em que o acesso 
ocorre, é chamada uma condição de corrida. Para nos proteger da condição de corrida 
acima, temos de 
assegurar que apenas um processo de cada vez possa manipular a variável counter. Para 
garantirmos isso, 
é necessário que os processos sejam sincronizados de alguma forma 
 3). Quais são as condições necessárias que devem ser implementadas para resolver o 
problema da seção crítica? Explique cada uma das soluções. 
R: Uma solução para o problema da seção crítica deve satisfazer aos três requisitos a 
seguir: 
Exclusão mútua. Se o processo Pi está executando sua seção crítica, então nenhum 
outro processo pode executar sua seção crítica. 
Progresso. Se nenhum processo está executando sua seção crítica e algum processo 
quer entrar em sua seção crítica, então somente aqueles processos que não estão 
executando suas seções remanescentes podem participar da decisão de qual entrará 
em sua seção crítica a seguir, e essa seleção não pode ser adiada indefinidamente. 
Espera limitada. Há um limite, ou fronteira, para quantas vezes outros processos podem 
entrar em suas seções críticas após um processo ter feito uma solicitação para entrar 
em sua seção crítica e antes de essa solicitação ser atendida. 
4). Descreva as ações tomadas pelo kernel para fazer a troca de contexto entre 
processos? 
R: A alocação da CPU a outro processo requer a execução do salvamento do estado do 
processo corrente e a restauração do estado de um processo diferente. Essa tarefa é 
conhecida como mudança de contexto. Quando ocorre uma mudança de contexto, o 
kernel salva o contexto do processo antigo em seu PCB e carrega o contexto salvo do 
novo processo indicado no schedule para execução. O tempo gasto na mudança de 
contexto é puro overhead porque o sistema não executa trabalho útil durante a permuta 
de processos. A velocidade da permuta varia de uma máquina para outra, dependendo da 
velocidade da memória, do número de registradores a serem copiados e da existência de 
instruções especiais (como uma única instrução de carga ou armazenamento de todos os 
registradores). Uma velocidade típica é de alguns milissegundos. 
5). Um processo é representado no sistema operacional por um bloco de controle do 
processo. Que tipo de informações normalmente está em um processo? 
R: Um processo é mais do que o código do programa, que também é conhecido como 
seção de texto. Ele também inclui a atividade corrente, conforme representada pelo 
valor do contador do programa e o conteúdo dos registradores do processador. 
Geralmente, um processo também inclui a pilha do processo que contém dados 
temporários (como parâmetros de funções, endereços de retorno e variáveis locais), e 
uma seção de dados, que contém variáveis globais. Um processo também pode 
incluir um heap, que é a memória dinamicamente alocada durante o tempo de 
execução do processo. 
* Pilha, atividade atual, Heap, dados, texto; 
6). Quais as quatro condições necessárias para ser possível a ocorrência de 
DeadLock? 
R: 
Uma situação de deadlock pode surgir se as quatro condições a seguir ocorrerem 
simultaneamente em um sistema: 
 
Exclusão mútua. Pelo menos um recurso deve ser mantido em modalidade não 
compartilhável; isto é, apenas um processo de cada vez pode usar o recurso. Se outro 
processo solicitar esse recurso, o processo solicitante deve ser atrasado até que o recurso 
tenha sido liberado. 
Retenção e espera. Um processo deve estar de posse de pelo menos um recurso e perando 
para adquirir recursos adicionais que estejam no momento sendo retidos por outros 
processos. 
Inexistência de preempção. Os recursos não podem ser interceptados; isto é, um recurso 
pode ser liberado apenas voluntariamente pelo processo que o estiver retendo, após esse 
processo ter completado sua tarefa. 
Espera circular. Deve haver um conjunto {P0, P1, …, Pn} de processos em espera tal 
que P0 esteja esperando por um recurso retido por P1, P1 esteja esperando por um recurso 
retido por P2, …, Pn1 esteja esperando por um recurso retido por Pn, e Pn esteja esperando 
por um recurso retido por P0. 
7) Como detectar um DeadLock? 
R: 
Em um deadlock, os processos nunca terminam sua execução, e os recursos do sistema 
ficam ocupados, impedindo que outros jobs comecem a ser executados. Antes de 
discutirmos os diversos métodos que lidam com o problema do deadlock. 
8) O que é um ambiente Multithread e quais as vantagens de sua utilização? 
R: 
Em geral, há duas maneiras de tornar um núcleo processador multithreaded: criação de 
ambiente multithreads de baixa granularidade e de alta granularidade. No ambiente 
multithread de baixa granularidade, um thread é executado em um processador até que 
ocorra um evento de latência longa como uma obstrução da memória. Em razão do atraso 
causado pelo evento de latência longa, o processador deve permutar para outro thread e 
começar sua execução. No entanto, o custo da alternância entre threads é alto, já 
que o pipeline de instruções deve ser esvaziado antes que o outro thread possa começar a 
ser executado no núcleo processador. Uma vez que esse novo thread comece a ser 
executado, ele inicia o preenchimento do pipeline com suas instruções. O ambiente 
multithread de alta granularidade (ou intercalado) alternase entre os threads com um nível 
de granularidade muitomais fina — normalmente no limite de um ciclo de instrução. No 
entanto, o projeto da arquitetura de sistemas de alta granularidade inclui a lógica para a 
alternância entre threads. Como resultado, o custo da alternância entre threads é baixo. 
9) Suponha que um algoritmo de escalonamento favorece os processos que tem usado o 
menor tempo do Processador no passado recente. Por que esse algoritmo favorece programas 
de I/O-bound e não causa starvation permanente nos programas CPU-bound? 
R: 
Ele favorecerá os programas I/ O-Bound por causa da requisição de burst de CPU 
relativamente curta por parte deles ; os programas CPU-Bound não sofrerão starvation 
porque os programas I/ O -B ound abrirão mão da CPU com relativa frequência para 
realizar sua E/S. 
10) Como o uso de threads pode melhorar o desempenho de aplicações paralelas em 
ambientes com múltiplos processadores? 
R: A programação com múltiplos threads fornece um mecanismo para o uso mais 
eficiente desses múltiplos núcleos de computação e o aumento da concorrência. 
Considere uma aplicação com quatro threads. Em um sistema com um único núcleo 
de computação, a concorrência significa simplesmente que a execução dos threads 
será intercalada por meio do tempo, já que o núcleo de processamento é capaz de 
executar apenas um thread de cada vez. Em um sistema com múltiplos núcleos, no 
entanto, a concorrência significa que os threads podem ser executados em paralelo, já 
que o sistema pode atribuir um thread separado a cada núcleo.