ENUNCIADO

MODELO
FICHA PRÁTICA N.º 3 PED
Processos

Curso Engenharia Informática Ano letivo 2019-2020

Unidade curricular Sistemas Operativos

Ano curricular 2.º Semestre 2.º Data 08.Abril.2020

FICHA PRÁTICA N.º 3 – Processos

1. Indique as diferenças entre escalonadores de curto-termo, de médio-termo e de longo-termo.

2. Descreva as ações efetuadas pelo núcleo de um sistema operativo na operação de troca de
contexto entre processos.
3. O processador UltraSPARC da Sun tem múltiplos conjuntos de registos. Descreva o que acontece
quando ocorre uma troca de contexto no caso em que o novo contexto já está presente num
dos conjuntos de registos do processador. Descreva também o que acontece quando o novo
contexto está em memória em vez de estar num dos conjuntos de registos, sabendo que estes
estão todos em utilização.
4. O SO Palm OS e as primeiras versões do iOS da Apple não forneciam qualquer facilidade de
processamento concorrente. Indique as três principais dificuldades que o processamento
concorrente levanta a um sistema operativo.
5. Quando um processo cria um novo processo utilizando a operação fork(), qual dos seguintes
elementos é partilhado entre os processos pai e filho: Stack, Heap ou Segmentos de memória
partilhada?
6. Indique as circunstâncias em que a Linha A será atingida no código do programa seguinte
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int main( )
{
pid_t pid;
pid = fork( ); /* Cria um processo filho*/
if (pid < 0) { /* Ocorreu um erro */
fprintf(stderr, “Erro: processo filho não foi criado!”);
return 1;
}
else if (pid == 0) { /* Processo filho */
execlp(“/bin/ls”, “ls”, NULL); /* LINHA A */
}
else { /* Processo pai */
wait(NULL); /* Processo pai espera que processo filho termine */
printf (“Processo FILHO terminou!”);
}
return 0;
}

Engenharia Informática – 2.º Ano P á g i n a | 1 de 4

Sistemas Operativos 2019-2020
 ENUNCIADO
MODELO
FICHA PRÁTICA N.º 3 PED
Processos

7. Considere o seguinte programa

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>

int valor = 5;

int main( )
{
pid_t pid;

pid = fork( );

if (pid == 0) { /* processo filho */

valor += 15;
return 0;
}

else if (pid > 0) { /* processo pai */

wait(NULL);
printf(“PROCESSO PAI: valor = %d”, valor); /* LINHA A */
return 0;
}
}

Explique o resultado obtido na linha A.

8. Considere o seguinte programa e explique o resultado obtido nas linhas A e B

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>

#define SIZE 5

int vetor[SIZE] = {0, 1, 2, 3, 4};

int main( )
{
int i;
pid_t pid;

pid = fork( );

if (pid == 0) {
for (i = 0; i < SIZE; i++) {
vetor[i] *= -i;
printf(“FILHO: %d\n“, vetor[i]); /* LINHA A */
}
}

else if (pid > 0) {

wait(NULL);
for (i = 0; i < SIZE; i++)
printf(“PAI: %d\n“, vetor[i]); /* LINHA B */
}
return 0;
}

Engenharia Informática – 2.º Ano P á g i n a | 2 de 4

Sistemas Operativos 2019-2020
 ENUNCIADO
MODELO
FICHA PRÁTICA N.º 3 PED
Processos

9. Considere o seguinte programa

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int main( )
{
pid_t pid, pid1;
pid = fork( ); /* Cria processo filho*/
if (pid < 0) { /* Ocorreu erro */
fprintf(stderr, “Erro: processo filho não foi criado!”);
return 1;
}
else if (pid == 0) { /* Processo filho */
pid1 = getpid( );
printf (“Processo FILHO: pid = %d”, pid); /* LINHA A */
printf (“Processo FILHO: pid1 = %d”, pid1); /* LINHA B */
}
else { /* Processo pai */
pid1 = getpid( );
printf (“Processo PAI: pid = %d”, pid); /* LINHA C */
printf (“Processo PAI: pid1 = %d”, pid1); /* LINHA D */
wait(NULL);
}
return 0;
}

Indique os valores que identificam os processos nas linhas A, B, C e D. Considere que os valores
pid atuais do processo pai e do processo filho são, respetivamente, 1500 e 1502.
10. Incluindo o processo pai inicial, quantos processos são criados pelo programa seguinte?
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int main( )
{
fork( ); /* Cria um processo filho*/
fork( ); /* Cria outro processo filho*/
fork( ); /* E ainda cria outro processo filho*/
return 0;
}

11. Incluindo o processo pai inicial, quantos processos são criados pelo programa seguinte?
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int main( )
{
int i;
for (i = 0; i < 4; i++)
fork( ); /* Cria um processo filho*/
return 0;
}

Engenharia Informática – 2.º Ano P á g i n a | 3 de 4

Sistemas Operativos 2019-2020
 ENUNCIADO
MODELO
FICHA PRÁTICA N.º 3 PED
Processos

12. Escrever um programa em C, usando a chamada sistema fork(), que apresente a sucessão de
Fibonacci no processo filho. O número de termos da sucessão é fornecido na linha de comandos.
Os processos pai e filho têm as suas próprias cópias de dados, pelo que será necessário que o
processo filho apresente a sucessão.
O processo pai deverá invocar a chamada sistema wait() para esperar que o processo filho
termine antes de o programa terminar.
Realizar a verificação de erro necessária de modo a garantir que é passado um valor não
negativo na linha de comandos.
Sucessão de Fibonacci: 1, 1, 2, 3, 5, 8, …
Formalmente: fib0 = 1
fib1 = 1
fibn = fibn-1 + fibn-2
13. Repetir o exercício anterior, utilizando agora a chamada sistema CreateProcess() da API Win32.

Neste caso, vai ser necessário especificar outro programa que será invocado por
CreateProcess(). Será esse programa que irá ser executado como um processo filho e que
visualizará a sucessão de Fibonacci.
Realizar a verificação de erro necessária de modo a garantir que é passado um valor não
negativo na linha de comandos.
14. Escrever um programa em C, usando a chamada sistema fork(), que calcule e apresente o
fatorial de um número no processo filho. O número é fornecido na linha de comandos.
Os processos pai e filho têm as suas próprias cópias de dados, pelo que será necessário que o
processo filho apresente o resultado do fatorial.
O processo pai deverá invocar a chamada sistema wait() para esperar que o processo filho
termine antes de o programa terminar.
Realizar a verificação de erro necessária de modo a garantir que é passado um valor não
negativo na linha de comandos.
15. Repetir o exercício anterior, utilizando agora a chamada sistema CreateProcess() da API Win32.

Neste caso, vai ser necessário especificar outro programa que será invocado por
CreateProcess(). Será esse programa que irá ser executado como um processo filho e que
apresentará o resultado do fatorial.
Realizar a verificação de erro necessária de modo a garantir que é passado um valor não
negativo na linha de comandos.
16. Considere o mecanismo RPC (Remote Procedure Calls). Descreva as consequências indesejáveis
que podem ocorrer caso não se implementem os mecanismos “no máximo uma vez” ou
“exatamente uma vez” na semântica de uma chamada.

Engenharia Informática – 2.º Ano P á g i n a | 4 de 4

Sistemas Operativos 2019-2020