Prova: Sistemas Operacionais.

Nome: Gustavo Santos de Mattos Chagas

Data: 28/10/2021

Questão 1: Pois em processos I/O bound caso o processador tiver um tempo de turnaround
muito alto, a responsividade cai e dados do buffer de um teclado podem não ser lidos e
resultar em um processo CPU-bound que precisem desses inputs ficar sem em espera por mais
tempo. Uma ideia para escalonar processos em sistema multicore seria atribuir a cada core
uma função dentro do sistema, ao menos um core para processos por CPU-bound, outro para
I/O-bound e outro para memory-intensive. Além disso, distribuir processos restantes entre os
núcleos de forma a manter a carga equilibrada.

Questão 3:

Sabendo que política preemptiva é a que permite um escalonador de processos interromper a

execução de um processo para começar outro e essa política não está presente na questão. Ao
chegar um conjunto de processos para um SPN (Shortest Process Next), o escalonador escolhe
o de menor tamanho, mas para isso é necessário gastar um tempo para saber qual é o de
menor tempo antes de se iniciar.

Questão 4:

• Um argumento a favor de se ter um quantum pequeno é minimizar o tempo de

turnaround pois assim o processador não deixa os processos esperando por muito
tempo, o ruim é que diminui o throughput pois possui muita troca de contexto e isso
custa tempo.
• A vantagem de se utilizar um quantum grande é maximizar o throughput do sistema
pois com menos trocas de contexto o sistema gasta menos tempo com isso e mais em
de fato executar o processo. A desvantagem é o grande tempo de turnaround que
acaba ocorrendo dos processos.
• Em um algoritmo de múltiplas filas pode vir a ser útil usar quantum de diferentes
tamanhos, supondo uma fila hipotética com processos pequenos e outra com
processos grandes. Pode-se usar um quantum médio para os processos pequenos
assim maximizando o throughput dos mesmos e mantendo um turnaround razoável e
um quantum pequeno para a fila dos processos grandes para diminuir o turnaround
aumentando a responsividade do sistema em troca de diminuir o throughput se assim
for da vontade do programador.

Questão 5:

No código acima, o algoritmo não resolve o problema por alguns motivos. o primeiro deles é
usar a operação DOWN no semáforo “sem”, quando era pra se iniciar com UP e iniciar o
semáforo em 0. O segundo problema é o semáforo “sem1” começar em C e aumentar ainda
mais com a operação de UP, quando deveria ser a função de DOWN.
Questão 6:

A) Sim! No caso onde em P1 o código é executado até a linha “x = x - 1” e depois disso em

P2 está sendo feita a verificação se x é diferente de 10 que resultará em verdadeiro,
após isso P1 volta a ser executado e retorna o valor de X para 10, após isso P2 printa o
resultado.
1. (P1) shared int x;
2. (P1) x = 10;
3. (P1) While(1) {
4. (P1) x = x -1;
5. (P2) shared int x;
6. (P2) x = 10;
7. (P2) while(1){
8. (P2) x = x – 1;
9. (P2) x = x -1;
10. (P2) if (x!=10) -> True
11. (P1) x = x + 1
12. (P2) printf(x);
B) Utilizar um semáforo para impedir que ambos os processos acessem a região crítica
simultaneamente, no caso a região de alteração do valor de X.
“ DOWN(sem);
x = x – 1;
x = x + 1;
UP(sem); ”

Questão 7:

As operações DOWN e UP são as operações de troca de estado de um semáforo, especificando

um pouco mais, a operação de DOWN serve para fazer o processo aguardar a entrada na
região crítica (esperando por um UP), enquanto que a operação UP para liberar o acesso do
processo na região crítica.

A) Pensando no exemplo de um banco onde o usuário tem uma variável que indica o
saldo em conta, sem usar o semáforo, dois processos distintos de pagamento podem
verificar o saldo em conta como suficiente para efetuar o pagamento (Quando na
verdade só há saldo suficiente para um) e então a conta ficará no negativo pois
quando ambos os processos entraram na região crítica o valor era suficiente.
B) Pois o uso de semáforos serve para auxiliar quando há múltiplos processos tentando
acessar a mesma região de memória simultaneamente múltiplas vezes, se os
processos não tem essa necessidade, semáforo pode acabar atrasando ainda mais os
processos do que ajudando.
C) Considerando que deadlock é a espera entre dois processos que nunca sinalizam
através de um UP nos semáforos, não, não é possível pois dependeria da espera de
outro processo. Entretanto, usando um semáforo em um algoritmo de apenas um
processo, se mal programado, é possível deixar o único processo em um estado de
espera infinito pois não terá outro processo para trocar o estado do semáforo. Então
nesse caso sim.