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. O algoritmo de escalonamento FCFS é adequado a um sistema de tempo

compartilhado? Porque?

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 o funcionamento dos sistemas operacionais monoprogramados e
multiprogramados.

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)
return(primeiro.fila0());
else
return(primeiro.fila1());
}

12. Considere um sistema operacional multiprogramado no qual existem três filas

scheduling:

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;