Processos Flashcards
include <sys/types.h>
Usando o programa mostrado na Figura 3.30, explique qual será a saída na LINHA A.
#include <stdio.h>
#include <unistd.h>
int value = 5;
int main()
{ pid_t
pid;
pid = fork();
if (pid == 0) { /* processo-filho */
value += 15;
return 0;
}
else if (pid > 0) { /* processo-pai */
wait(NULL);
printf(“PARENT: value = %d”,value); /* LINHA A */
return 0;
}
}</unistd.h></stdio.h>
A chamada de sistema fork() cria um processo filho a partir do processo pai. Ambos os processos compartilham o mesmo código, variáveis globais, heaps e stacks no momento da criação. No entanto, após a criação, eles têm cópias separadas de suas variáveis. O processo pai recebe o PID (identificador de processo) do filho como resultado de fork(), enquanto o filho recebe 0.
Nesse contexto, o valor da variável é 5 no momento da criação. Portanto, qualquer alteração feita no processo filho após a criação não afetará o valor no processo pai e vice-versa. O resultado final será que o processo pai exibe “PAI: valor=5”, indicando que o valor não foi modificado após a criação do processo filho.
include <stdio.h></stdio.h>
Incluindo o processo-pai inicial, quantos processos são criados pelo programa mostrado na Figura 3.31?
#include <unistd.h>
int main()
{
/* cria um processo-filho */
fork();
/* cria outro processo-filho */
fork();
/* e cria um outro */
fork();
return 0;
}</unistd.h>
O código executa a chamada de sistema fork() em cada Processo() consecutivo, duplicando os processos existentes a cada vez. Após a primeira chamada, haverá 2 processos (pai e filho). Na segunda chamada, cada um dos 2 processos existentes duplica, resultando em 4 processos. Na terceira chamada, os 4 processos existentes duplicam novamente, resultando em um total de 8 processos.
Portanto, após as três instruções Processo(), há um processo pai original e sete filhos, totalizando oito processos. Isso é consistente com a fórmula que afirma que o número total de processos após N chamadas de fork() é 2^N, uma vez que temos três chamadas fork(), resultando em 2^3 = 8 filhos.
As versões originais do sistema operacional móvel iOs da Apple não forneciam um meio para
processamento concorrente. Discuta três grandes complicações que o processamento concorrente
adiciona a um sistema operacional.
- Dificuldade em compartilhar recursos globais
- Dificuldade na alocação de recursos
- Problemas com erros de depuração e programação
Descreva o que acontece quando ocorre uma mudança de contexto e o novo contexto já está carregado em um dos
conjuntos de registradores. O que acontece quando o novo contexto está na memória e não em um conjunto de registradores e todos os conjuntos de registradores estão sendo usados?
se novo contexto já estiver em um conjunto de registradores, a CPU ajusta o ponteiro para o “conjunto de registradores usado atualmente” para apontar para esse conjunto, tal operação é rápida.se o novo contexto estiver na memória, ele deve ser carregado em um dos conjuntos de registradores, o que leva mais tempo. Isso envolve a alteração do ponteiro do conjunto de registro atual para apontar para o conjunto contendo o novo contexto
Quando um processo cria um novo processo usando a operação fork ( ), qual dos estados a seguir é compartilhado entre o processo-pai e o processo-filho?
a.Pilha
b.Heap
c.Segmentos de memória compartilhada
Quando a função Processo() é chamada para criar um processo filho,a pilha e o heap são copiados apenas quando necessário, enquanto os segmentos de memória compartilhada permanecem inalterados e compartilhados entre os processos.
Considere a semântica “exatamente uma vez” no que diz respeito ao mecanismo RPC. O algoritmo para implementação dessa semântica é executado corretamente, mesmo quando a mensagem ACK retornada ao cliente é perdida por causa de um problema na rede? Descreva a sequência de mensagens e discuta se a semântica “exatamente uma vez” continua sendo preservada
Para garantir a semântica “exatamente uma vez” em procedimentos remotos, um algoritmo usa um esquema de confirmação (ACK) junto com carimbos de data/hora ou um contador incremental. O cliente envia uma solicitação RPC ao servidor com um carimbo de data/hora e inicia um temporizador. O cliente aguarda duas possibilidades: receber um ACK do servidor indicando a execução do procedimento ou que o temporizador expire. Se o temporizador expirar, o cliente reenvia o RPC com um carimbo de data/hora posterior.
Existem duas razões para o cliente não receber o ACK: (1) o RPC original não foi recebido pelo servidor ou (2) o RPC foi recebido e executado, mas o ACK foi perdido. Na situação (1), o uso de ACKs permite que o servidor execute o RPC. Na situação (2), o servidor identifica o RPC duplicado por meio do carimbo de data/hora e evita a execução repetida. O servidor envia um segundo ACK ao cliente para confirmar a execução bem-sucedida do RPC.
Suponha que um sistema distribuído seja suscetível a falhas no servidor. Que mecanismos seriam necessários para garantir a semântica “exatamente uma vez” na execução de RPCs?
o servidor deve manter um registro em armazenamento estável (como um log de disco) contendo informações sobre as operações RPC recebidas, se foram executadas com êxito e os resultados associados. Quando ocorre uma falha no servidor e uma mensagem RPC é recebida, o servidor pode verificar se o RPC já foi executado anteriormente, garantindo assim a semântica “exatamente uma vez” na execução dos RPCs
