A maior rede de estudos do Brasil

Pergunta 1

Version:1.0 StartHTML:000000312 EndHTML:000038755 StartFragment:000030352 EndFragment:000038680 StartSelection:000030390 EndSelection:000038628 SourceURL:https://anhembi.blackboard.com/webapps/assessment/take/launch.jsp?course_assessment_id=_1106076_1&course_id=_397355_1&content_id=_8115890_1&step=nullFazer teste: ATIVIDADE 3 – SISTEMAS OPERACIONAIS (ON) - ...

Pergunta 1

  1.  

    Data a tabela de processos abaixo faça o escalonamento de acordo com o algoritmo Round Robin.

     

    Chegada

    Duração

    Prioridade

    P1

    0

    5

    2

    P2

    10

    4

    2

    P3

    0

    7

    1

    P4

    7

    5

    1

    P5

    15

    7

    4

    P6

    12

    3

    3

     

    *OBS: Para responder a esta questao, utilize um editor como o MS Word, MS Excel, ou outra alternativa que voce desejar, mas faça o Upload do arquivo em versao PDF.

 


10 resposta(s) - Contém resposta de Especialista

User badge image

RD Resoluções Verified user icon

Há mais de um mês

Nesse exercício, a parte complicada é calcular os tempos de espera. Depois que os tempos de espera são calculados, os tempos de giro podem ser calculados rapidamente.


Sendo assim, criamos o seguinte algoritmo abaixo:

1- Crie um array rem_bt [] para acompanhar o restante

tempo de burst dos processos. Este array é inicialmente um

cópia de bt [] (array de tempos de burst)

2- Crie outro array wt [] para armazenar os tempos de espera

de processos. Inicialize esta matriz como 0.

3- Inicialize o tempo: t = 0

4- Continue percorrendo todos os processos enquanto todos os processos

não são feitas. Faça o seguinte para o processo se for

ainda não feito.

a- Se rem_bt [i]> quantum

(i) t = t + quantum

(ii) bt_rem [i] - = quantum;

c- Else // Último ciclo para este processo

(i) t = t + bt_rem [i];

(ii) wt [i] = t - bt [i]

(ii) bt_rem [i] = 0; // Este processo acabou


Uma vez que tenhamos tempos de espera, podemos calcular o tempo de retorno tat [i] de um processo como a soma dos tempos de espera e de tempo de pico, ou seja, wt [i] + bt [i]:

// Programa C ++ para implementação de agendamento de RR

#include <iostream>

usando namespace std;

// Função para encontrar o tempo de espera para todos

// processa

void findWaitingTime (int processes [], int n,

int bt [], int wt [], int quantum)

{

// Faça uma cópia dos tempos de burst bt [] para armazenar o restante

// tempo de rajada

int rem_bt [n];

para (int i = 0; i <n; i ++)

rem_bt [i] = bt [i];

int t = 0; // Hora atual

// Mantenha os processos atravessando de maneira round robin

// até que todos eles não estejam prontos.

enquanto (1)

{

bool done = true;

// Atravessa todos os processos, um por um repetidamente

para (int i = 0; i <n; i ++)

}

Nesse exercício, a parte complicada é calcular os tempos de espera. Depois que os tempos de espera são calculados, os tempos de giro podem ser calculados rapidamente.


Sendo assim, criamos o seguinte algoritmo abaixo:

1- Crie um array rem_bt [] para acompanhar o restante

tempo de burst dos processos. Este array é inicialmente um

cópia de bt [] (array de tempos de burst)

2- Crie outro array wt [] para armazenar os tempos de espera

de processos. Inicialize esta matriz como 0.

3- Inicialize o tempo: t = 0

4- Continue percorrendo todos os processos enquanto todos os processos

não são feitas. Faça o seguinte para o processo se for

ainda não feito.

a- Se rem_bt [i]> quantum

(i) t = t + quantum

(ii) bt_rem [i] - = quantum;

c- Else // Último ciclo para este processo

(i) t = t + bt_rem [i];

(ii) wt [i] = t - bt [i]

(ii) bt_rem [i] = 0; // Este processo acabou


Uma vez que tenhamos tempos de espera, podemos calcular o tempo de retorno tat [i] de um processo como a soma dos tempos de espera e de tempo de pico, ou seja, wt [i] + bt [i]:

// Programa C ++ para implementação de agendamento de RR

#include <iostream>

usando namespace std;

// Função para encontrar o tempo de espera para todos

// processa

void findWaitingTime (int processes [], int n,

int bt [], int wt [], int quantum)

{

// Faça uma cópia dos tempos de burst bt [] para armazenar o restante

// tempo de rajada

int rem_bt [n];

para (int i = 0; i <n; i ++)

rem_bt [i] = bt [i];

int t = 0; // Hora atual

// Mantenha os processos atravessando de maneira round robin

// até que todos eles não estejam prontos.

enquanto (1)

{

bool done = true;

// Atravessa todos os processos, um por um repetidamente

para (int i = 0; i <n; i ++)

}

User badge image

Andre Smaira

Há mais de um mês

Nesse exercício, a parte complicada é calcular os tempos de espera. Depois que os tempos de espera são calculados, os tempos de giro podem ser calculados rapidamente.


Sendo assim, criamos o seguinte algoritmo abaixo:

1- Crie um array rem_bt [] para acompanhar o restante

tempo de burst dos processos. Este array é inicialmente um

cópia de bt [] (array de tempos de burst)

2- Crie outro array wt [] para armazenar os tempos de espera

de processos. Inicialize esta matriz como 0.

3- Inicialize o tempo: t = 0

4- Continue percorrendo todos os processos enquanto todos os processos

não são feitas. Faça o seguinte para o processo se for

ainda não feito.

a- Se rem_bt [i]> quantum

(i) t = t + quantum

(ii) bt_rem [i] - = quantum;

c- Else // Último ciclo para este processo

(i) t = t + bt_rem [i];

(ii) wt [i] = t - bt [i]

(ii) bt_rem [i] = 0; // Este processo acabou


Uma vez que tenhamos tempos de espera, podemos calcular o tempo de retorno tat [i] de um processo como a soma dos tempos de espera e de tempo de pico, ou seja, wt [i] + bt [i]:

// Programa C ++ para implementação de agendamento de RR

#include <iostream>

usando namespace std;

// Função para encontrar o tempo de espera para todos

// processa

void findWaitingTime (int processes [], int n,

int bt [], int wt [], int quantum)

{

// Faça uma cópia dos tempos de burst bt [] para armazenar o restante

// tempo de rajada

int rem_bt [n];

para (int i = 0; i <n; i ++)

rem_bt [i] = bt [i];

int t = 0; // Hora atual

// Mantenha os processos atravessando de maneira round robin

// até que todos eles não estejam prontos.

enquanto (1)

{

bool done = true;

// Atravessa todos os processos, um por um repetidamente

para (int i = 0; i <n; i ++)

}

User badge image

Frachesi Mariano

Há mais de um mês


Só quero saber como eu escrevo a resposta, tenho que montar alguma coisa?

Essa pergunta já foi respondida por um dos nossos especialistas