Aluna: Mônica Rodrigues dos Santos

GRR20210553

1. (1 ponto) Cite e explique 3 funções de um Sistema Operacional moderno.

● Facilidade de acesso aos recursos do sistema: interface entre o usuário e os
recursos de hardware, tornando esta comunicação transparente (ou
imperceptível) e permitindo ao usuário um trabalho mais eficiente e com
menos possibilidades de erros.
● Compartilhamento de recursos de forma organizada: O compartilhamento de
recursos permite a diminuição de custos, na medida em que mais de um
usuário pode utilizar as mesmas facilidades concorrentemente.
● Segurança na execução de processos: Somente o sistema operacional deve
ter acesso ao hardware do computador, isso garante que somente sejam
executados processos que não causariam falhas sejam executados.
2. (1 ponto) Desenhe e explique o ciclo de vida de um processo.

3. (1 ponto) Explique o funcionamento e as diferenças entre os algoritmos de

escalonamento SPF e SRT.
● SPF (Shortest Process First): É um tipo de escalonamento onde o tempo de serviço
é tomado como prioridade. os processos em espera pelo processador são
organizados numa fila segundo seu tempo de execução, sendo colocados a frente
os menores processos. Quando iniciado o processo não é interrompido até ser
encerrado, uma possibilidade deste método de escalonamento é causar estagnação
de processos mais longos, fazendo com que o tempo de espera se torne mais alto.
● SRT (Shortest Remaining Time): É um escalonador preemptivo, em que a fila de
execução é organizada a cada novo processo iniciado. É avaliado o tempo que os
processos na fila irão precisar para serem executados e colocados em ordem de
acordo com o tempo restante de execução necessário para completar o processo. A
cada rodada de execução a fila deve ser reorganizada de acordo com o tempo
restante de execução dos processos.
A principal diferença entre os algoritmos de escalonamento citados é que um é preemptivo
e o outro não, isso significa que enquanto há rotatividade maior em um processo, no caso
no SRT, permitindo que mais processos tenham oportunidade de serem executados. No
SPF há maior possibilidade de estagnação, pois uma vez que um processo curto é iniciado
irá até o fim, e se surgir novo processo curto nesse meio tempo irá tomar a vez dos
processos mais antigos que estavam aguardando.

4. (1 ponto) Considere um computador com 1 processador de 2 núcleos e os

seguintes eventos.

R1 -> P1 a P4 prontos
R3 -> P5 e P6 prontos
R5 -> P4 bloq
R6 -> P1 bloq, P4 pronto
R7 -> P5 e P6 bloq
R8 -> P1, P5, P6, P7 e P8 prontos

Monte a tabela de escalonamento de processos de acordo com a prioridade:

RR + FIFO + > ID.
Considere que cada rodada é de 10ms e que os processos têm ciclo de vida de:
P1 – 30ms; P2 e P3 – 50ms; P4 – 40ms, P5, P6, P7 e P8 – 20ms

R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14

30 P1 P P E P E B B P P E - - - -
50 P2 P P E P E P P E E P P P E -
50 P3 P E P E P P E P E P P E - -
40 P4 P E P E B P E E - - - - - -
20 P5 - - P P P E B P P P E - - -
20 P6 - - P P P E B P P E - - - -
20 P7 - - - - - - - P P P P E P E
20 P8 - - - - - - - P P P E P E -
P4 P2 P4 P2 P6 P3 P2 P3 P1 P5 P7 P2 P7
P3 P1 P3 P1 P5 P4 P3 P2 P6 P8 P3 P8
P2 P4 P2 P6 P3 P2 P4 P1 P5 P7 P2 P7
P1 P3 P1 P5 P4 P6 P8 P3 P8
P6 P3 P2 P5 P7 P2
P5 P8 P3
P7 P2

Latência mínima: 6 rodadas - P8

Latência máxima: 13 rodadas - P2
Latência média: (10+13+12+8+9+8+7+6)/8 = 10 rodadas
5. (2 pontos) Considere um computador com 1 processador com apenas 1 núcleo e
os seguintes eventos.
R1 -> P3 e P4 prontos
R2 -> P1 pronto
R3 -> P2 pronto
R6 -> P1 bloq
R7 -> P1 e P5 prontos
Monte a tabela de escalonamento de processos de acordo com a prioridade RR + SRT
+ <ID. Calcula as latências mínima, média e máxima, indicando os processos
responsáveis pela mínima e máxima. Considere que cada rodada é de 10ms e que os
processos têm ciclo de vida de:
P1, P2 e P4 – 20ms; P3 – 30ms; P5 – 10ms

R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12

20 P1 - P P P E10 B P P E - - -
20 P2 - - P P P E10 P E - - - -
30 P3 P P E20 P P P E10 P P E - -
20 P4 P E10 P E - - - - - - - -
10 P5 - - - - - - P P P P E -
P4 P3 P4 P1 P2 P3 P2 P1 P3 P5
P3 P4 P1 P2 P3 P2 P1 P3 P5
P1 P2 P3 P3 P5
P3 P5

Latência mínima: 4 rodadas - P4

Latência máxima: 10 rodadas - P3
Latência média: (8+6+10+4+5)/5 = 7 rodadas

6. (1 ponto) Modifique o programa em pseudocódigo abaixo para sincronizar as

threads de forma a intercalarmos a execução das mesmas, começando por T2 (T2 T1
T2 T1 T2 T1 .....).
//sistema
int flag = 2;
for (i = 0; i < 2; i++){
startThread (i);}
//Thread I
while (true)
{
for (i = 0; i < n; i++){
while (flag != 1);
print "T1";
storeInfoIntoDB () // seção critica
flag = 2; }
}

//Thread II
while (true)
{
for (i = 0; i < n; i++){
while (flag != 2);
print "T2";
captureInfoIntoDB (); // seção critica
flag = 1;
}
}

7. (1,5 pontos) Dado o código abaixo, informe se o mesmo provê exclusão mútua,
produz adiamento indefinido, gera sincronização intertravada, gera deadlock.
Explique cada uma de suas respostas.
O algoritmo produz deadlock pois cada thread sinaliza antes de executar o while, cada uma
delas encontrará o flag da outra sinalizado e ficará esperando no while para sempre.
De certa forma garante a exclusão mútua pois não é possível que as duas sejam
executadas.
O adiamento indefinido não pode ser gerado pois possui apenas uma flag que só muda de
valor após a execução.
Possui sincronização intertravada, pois a decisão de entrar na thread é realizada ao iniciar o
flag antes de iniciar as threads.