Você está na página 1de 4

Exercícios P1

1. Escreva o pseudo-código do procedimento de biblioteca que implementa a chamada de

sistema fork.

//Cosiderando que o número da função é passado no registrador eax

#define sys_fork 2 // int fork() Move sys_fork, eax Int 80H

2. Mostre, sob a forma de pseudo-código, os procedimento executado pelo sistema operacional no tratamento de uma interrupção de relógio.

Interrupção de relógio é um tipo de interrupção de hardware. As funções que a rotina de tratamento precisa executar são:

//Void Relógio() {

Salvar contexto(); Atualizar_ontabilização_d_tempo(); Rescalonar();

}

3. Crie um grafo com no mínimo 5 nodos e implemente com a primitiva fork do sistema

operacional Unix.

Na apostila tem exemplos!

4.

compartilhado? Porque?

O

algoritmo

de

escalonamento

FCFS

é

adequado

a

um

sistema

de

tempo

Não, porque o processo CPU Bound pode monopolizar o uso do processador, fazendo que processos I/O bound sejam postergados. Além disso, neste algoritmo o tempo de resposta não é uniforme, o que também não é adequado aos sistemas de tempo compartilhado.

5. Compare as organizações Monolítica e Microkernel.

Monolítica: Pode-se dizer que possui melhor performance que o Microkernel, pois todas as funcionalidades são implementadas em um núcleo. O pedido é recebido por este núcleo que executa o procedimento correspondente ao serviço. É de difícil manutenção, e não modular.

Microkernel: Baseado do modelo cliente/servidor. Servidores implementam os serviços oferecidos aos usuários. Um pedido do usuário é recebido pelo Microkernel que identifica o servidor destinatário e encaminha o pedido. O servidor executa e encaminha o resultado ao Microkernel que o entrega ao cliente. É modular (para adicionar um novo serviço basta implementar um novo servidor), e é de fácil manutenção (comparando-se com o Monolítico)

6. Descreva o funcionamento de um sistema operacional baseado no modelo Microkernel.

É a descrição de MicroKernel colocada acima!

7. Descreva

multiprogramados.

o

funcionamento

dos

sistemas

operacionais

monoprogramados

e

Monoprogramado: Existe um único programa em execução. Nas operações de I/O o processo em execução fica bloqueado até que o I/O se complete. O processador não é utilizado durante este tempo. Ex. MS-DOS. Não possui escalonador nem gerente de memória sofisticado. A memória é dividida em duas partes: uma para o SO e outra para o programa de usuário, em execução.

Multiprogramado: Usa o tempo de espera pelo I/0 de algum processo para executar outro processo. Possui mais de um programa em execução simultânea, possui um escalonador e uma gerencia de memória que permite a existência de mais de um processo na memória.

8. Descreva os passos executados pelo sistema operacional na criação de um processo.

Void CriarProc() Se arquivo é executável AlocarMemória () ; AlocarDescritor () ; ColocarInformaçôesDescritor() ; CarregarPrograma () ; InserirReady list

Senão

erro

9. Apresente os estados que um processo assume durante a sua execução e faça o grafo

de transição, indicando o evento causador da transição.

Tem na apostila!

10. Escreva, sob a forma de pseudo-código, os procedimentos executados pelo sistema

operacional no tratamento de uma interrupção do disco.

Void do_Disco() {

SalvarContexto(); CopiarDadosParaAreaDoProcesso() ; //no caso de read InserirProcReady-list() Rescalonar()

}

11. Considere um sistema que possui duas filas de scheduling, com prioridades 0 e 1,

sendo que somente pode ser escalonado um processo da fila de prioridade 1 não existindo processos na fila de prioridade 0. Sabendo que o algoritmo utilizado nas duas filas é o Round-Robin, escreva o pseudo-código dos procedimentos insere(p), onde p é o índice da tabela de descritores de processos e que possui um campo que contém a prioridade dos processos e r= seleciona(), que retorna o índice da tabela de descritores

que descreve o processo selecionado. Cite duas situações em que cada procedimento é chamado.

Inserir (int p) //índice da tabela do descritor (desc) { If (desc[p].prioridade == 0 )

 

inserirFila0();

else

 

inserirFila1();

}

int select () { if (fila0.prim!= NULL)

else

}

12.

scheduling:

Considere

return(primeiro.fila0());

return(primeiro.fila1());

um

sistema

operacional

multiprogramado

no

qual

existem

três

filas

0: de mais alta prioridade na qual rodam os processos do sistema operacional

1: de prioridade intermediária na qual rodam servidores especializados

2: de mais baixa prioridade, na qual rodam os programas de usuários Sabendo que cada uma das filas possui prioridade absoluta sobre as inferiores (isso é, somente roda um processo de prioridade 2 se não houver nenhum na fila de prioridade 0 nem na fila de prioridade 1), que na fila de prioridade 0 algoritmo utilizado é o FCFS e nas demais é o round-robin:

a) escreva o pseudo-código do procedimento de tratamento da interrupção do

relógio.

Void Relógio() {

SalvarContexto() ; AtualizarContabilizaçãoTempo() ; Rescalonar() ;

}

b) escreva o pseudo-código do procedimento que seleciona um processo

para execução

int select (){ if (fila0.prim!= NULL) return(primeiro.fila0()); else if (fila1.prim!= NULL) return(primeiro.fila1(); else return(primeiro.fila2());

}

13. Escreva os procedimentos saveContext() e restoreContext(), executados pelo sistema operacional para, respectivamente, fazer salvamento e restauração de contexto. Considere que o sistema possui dois registradores de uso geral (R0 e R1), dois registradores utilizados para gerência de memória (Mbase e Msize), respectivamente base e deslocamento, um registrador Stack Pointer (SP), um acumulador (AC) e um apontador de instruções (PC). Defina a estrutura de dados na qual são mantidas as informações sobre os processos (descritor de processos) e observe que o contexto do processo é salvo em seu registro descritor. Leve em conta a existência de uma operação mov op1, op2 onde op1 e op2 podem ser variáveis ou registradores.

SaveContext()

- copiar os registradores para o descritor do processo

RestoreContext()

- O inverso

struct Desc{ Int pid, estado, prioridade, SP, Msize, Mbase, AC, R0, R1, PC;

}

; struct Desc proc_Descritor [1000] ; // portanto, no máximo 1000 processos no sistema.

Considerando que o índice do descritor do processo que estava rodando está armazenado na variável running:

# saveContext () mov SP, proc_Descritor[running].SP; mov Msize, proc_Descritor[running].Msize; mov Mbase, proc_Descritor[running].Mbase,; mov R0, proc_Descritor[running].R0; mov R1, proc_Descritor[running].R1; mov AC, proc_Descritor[running].AC; mov PC, proc_Descritor[running].PC;

Considerando que p é o processo selecionado para ganhar o processador:

#restoreContext( p) mov proc_Descritor[p].SP, SP; mov proc_Descritor[p].Msize, Msize; mov proc_Descritor[p].Mbase, Mbase; mov proc_Descritor[p].R0, R0; mov proc_Descritor[p].R1, R1; mov proc_Descritor[p].AC, AC; mov proc_Descritor[p].PC, PC;