Prática SO UNEB Processos

Prévia do material em texto

Processos
Michel Franc¸a Leal
Universidade do Estado da Bahia (UNEB)
Salvador - Bahia - Brasil
{mfrancaleal@gmail.com}
Resumo
Sabemos que um processo e´ um programa em execuc¸a˜o,
muitos sabem da sua existeˆncia mas poucos sabem na
pr´atica como eles funcionam. Nos sistemas operacionais
os processos funcionam como um u´nico mo´dulo executa´vel
que torna-se concorrente com os demais processos em
execuc¸a˜o. Para os mais leigos, um processo pode ser sim-
plesmente um bloco de notas que ao ser clicado para exe-
cutar, inicia um processo no sistema operacional. Veremos
na pra´tica alguns procedimentos com processos.
1. Introduc¸a˜o
Diferente das threads que na˜o podem ser carregadas pelo
sisstema operacional, os processos sa˜o mo´dulos indepen-
dentes que sa˜o carregados. Um processo pode conter diver-
sas threads que atuam em conjunto para executar um pro-
cesso com muito mais eficieˆncia se fosse processado sem
elas, uma grande saı´da para a execuc¸a˜o de um processo
muito complexo que acarretaria no consumo de recursos,
limitando ou inibindo a execuc¸a˜o de outros processos.
Os sistemas operacionais podem executar diversos proces-
sos simultaneamente, a este prcedimento chamamos multi-
processamento o que pode culminar na disputa por recur-
sos compartilhados, ou seja, concorreˆncia. Caso haja con-
correˆncia, esse problema pode ser resolvido atrave´s do ge-
renciamento de mu´ltiplas linhas de execuc¸a˜o ou processos
no que chamamos multitarefa (sincronizac¸a˜o).
A execuc¸a˜o dos processos ocorre de forma sequeˆncial, ou
seja, um apo´s o outro, executando apenas uma instruc¸a˜o de
um processo. Meso que haja apenas uma unidade central de
processamento (UCP), os processos teˆm o poder de execu-
tar operac¸o˜es de forma concorrente.
2. Questa˜o I
Apo´s executar e analisar o co´digo forck1.c responder:
Porque a mensagem ”Finalizando...” foi impressa duas
vezes?
Vejamos o co´digo:
1 # i n c l u d e <s t d i o . h>
2 # i n c l u d e < s t d l i b . h>
3
4 i n t main ( i n t a rgc , c h a r ∗ a rgv [ ] ) {
5
6
7 p r i n t f ( ” I n i c i a n d o . . . \ n ” ) ;
8
9 f o r k ( ) ;
10
11 p r i n t f ( ” F i n a l i z a n d o . . . \ n ” ) ;
12
13 e x i t ( 0 ) ;
14
15 }
Listing 1. Co´digo fonte forck1.c
Segundo o professor Maziero(1), em sistemas operacionais
baseados em UNIX, os processos sa˜o criados atrave´s de
chamadas de sistemas fork, criando uma co´pia do processo
solicitante. Baseado nisso podemos dizer que o co´digo
mostrado acima existem duas chamadas de processos, um
e´ o processo principal main() uqe podemos chamar de
processo pai e o segundo acontece quando ha´ a chamada de
sistema fork().
O que acontece nesse trecho de co´digo e´ simples, nada
foi feito ale´m de fazer a chamada com fork(), e como
visto, ele herda tudo do pai mas so´ executa o que vem
apo´s ele, nesse caso, ”Finalizando, e como existem dois
processos, como mencionado, ambos executam o comando
”printf(”Finalizando...”);”.
3. Questa˜o II
Apo´s fazer o download do site da disciplina, compilar e
executar os arquivos: fork2.c e fork3.c foi analizado o se-
guinte:
3.1. Ana´lise do Co´digo-fonte do arquuivo
forck2.c
Este co´digo implementa a utilizac¸a˜o de criac¸a˜o de pro-
cessos atrave´s da chamada de sistemas fork() como menci-
onamos antes.
Diferente do co´digo do arquivo forck1, este co´digo ale´m de
criar processos define o que o processo Pai e o processo Fi-
lho fara˜o, ou seja, delimitou a tarefa de cada um e isso acon-
tece quando e´ feito a chamada de condic¸a˜o if (filho pid !=
0). Nessa primeira condic¸a˜o, somente o processo Pai podera´
executar aquele trecho de co´digo, ficando sob responsabili-
dade do processo Filho executar apenas o trecho dentro do
else{}.
3.2. Ana´lise do Co´digo-fonte do arquuivo
forck3.c
O programa comec¸a imprimindo o PID gerado pelo
sistema operacional para o processo pai atrave´s da func¸a˜o
getpid(). Logo em seguida ha´ outra impressa˜o na tela
mostrando o PID do pai. Na sequeˆncia, a varia´vel filho pid
recebe o valor do ID do processo filho retornado pela
func¸a˜o fork().
Na condic¸a˜o if(filho pid == 0) se o valor de filho pid for
igual a zero, significa que o programa esta´ executando o
processo filho. Ele mostra o PID do filho e o PID do pai.
Em seguida o processo filho faz uma pausa, ”dorme”,
invocando a func¸a˜o sleep(), essa pausa dura 5 segundos e
apo´s esse tempo volta a´ ativa.
Se a condic¸a˜o do if for diferente de 0 enta˜o o processo
Pai assume o comando imprimindo seu PID e o do seu
Filho. Apo´s isso, existe a chamada da func¸a˜o wait() que
corresponde a` sincronizac¸a˜o de processos, ou seja, quando
essa func¸a˜o e´ invocada, o processo Pai aguarda o processo
Filho concluir para que ele possa continuar sua execuc¸a˜o,
tanto que apo´s wait(), o processo Pai exibe o PID do seu
filho, que nesse caso e´ 0 porque ele ja´ conluiu suas tarefas
e foi eliminado. A varia´vel status retorna o estado do
processo filho.
4. Questa˜o III
Fazer o download do aquivo fork4.c do site da displina
e fazer as seguintes atividades:
• Antes do pai terminar, abra outro terminal e digite:
ps –aux. O que acontece?
– O comando ps -aux exibe uma lista de processos
que esta˜o sendo executados juntamente com
outras informac¸o˜es a respeito dos mesmos,
como uso da meo´mria principal, uso de pro-
cessamento (ambos em porcentagem), data de
inı´cio da execuc¸a˜o o tempo desta, dentre outras
informac¸o˜es.
Ao executar este comando antes do processo pai
terminar, sa˜o exibidos, ale´m de outros processos
como dito antes, exibe tambe´m os processos Pai
e Filho do programa forck4.c.
• Ana´lise do programa
– O programa se inicia com uma varia´vel chamada
n, do tipo inteiro e uma do tipo pid t chamada fi-
lho pid. Em seguinda um processo filho e´ criado
e, para saber qual processo esta´ em atividade ha´
uma estrutura condicionante o switch, a ideia e´ so´
mostrar quem esta´ sendo executado e se a criac¸a˜o
do fork() teve eˆxito ou na˜o. Apo´s o switch(), o
programa entra em um lac¸o de repetic¸a˜o, usando
for() onde e´ exibido de forma decrescente o valor
da varia´vel n que pode ser 1 caso o processo em
ac¸a˜o seja o processo Filho ou 30 caso o processo
seja o Pai, esses valores foram atribuı´dos dentro
do switch().
5. Questa˜o IV
Nesta´ pra´tica deve-se criar um co´digo em C que deve ter
como saı´da o montante parcial da soma dos identificadores
de cada processo ate´ seu no´.
Segue o co´digo na pro´xima pa´gina:
1 # i n c l u d e <s t d i o . h>
2 # i n c l u d e < s t d l i b . h>
3 # i n c l u d e <s i g n a l . h>
4 # i n c l u d e <s y s / t y p e s . h>
5 # i n c l u d e <s y s / w a i t . h>
6
7 i n t main ( )
8 {
9 i n t soma =0 , s t a t u s =0 , p F i l h o = f o r k ( ) ;
10 i f ( p F i l h o ==0){
11 p r i n t f ( ” Sou o p r i m e i r o f i l h o . PID : %d .
Minha soma : %d\n ” , g e t p i d ( ) , g e t p i d ( ) %10) ;
12 soma= g e t p i d ( ) %10; s l e e p ( 5 ) ;
13 i n t pNeto = f o r k ( ) ;
14 i f ( pNeto ==0){
15 p r i n t f ( ” Sou o p r i m e i r o n e t o . PID : %d .
Minha soma : %d\n ” , g e t p i d ( ) , g e t p i d ( ) %10) ;
16 soma+= g e t p i d ( ) %10; s l e e p ( 5 ) ;
17 i n t b i s n e t o = f o r k ( ) ;
18 i f ( b i s n e t o ==0){
19 p r i n t f ( ” Sou o b i s n e t o . PID : %d .
Minha soma : %d\n ” , g e t p i d ( ) , g e t p i d ( ) %10) ;
20 soma+= g e t p i d ( ) %10; e x i t (
EXIT SUCCESS ) ;
21 }
22 e x i t ( EXIT SUCCESS ) ;
23 }
24 i n t s t a t u s 1 ;
25 w a i t (& s t a t u s 1 ) ;
26 i f ( ( s t a t u s 1 & 255) == 0) e x i t (
EXIT SUCCESS ) ;
27
28 }
29 e l s e {
30 i n t s t a t u s ;
31 w a i t (& s t a t u s ) ;
32 i f ( ( s t a t u s & 255) == 0){
33 i n t s F i l h o = f o r k ( ) , s t a t u s ;
34 w a i t (& s t a t u s ) ;
35 i f WIFEXITED ( s t a t u s )
36 p r i n t f ( ” Souo P a i . PID : %d . Minha
soma : %d\n ” , g e t p i d ( ) , g e t p i d ( ) %10) ;
37 i f ( s F i l h o ==0 ) {
38 p r i n t f ( ” Sou o segundo f i l h o . PID :
%d . Minha soma : %d\n ” , g e t p i d ( ) , g e t p i d ( )
%10) ;
39 soma+= g e t p i d ( ) %10; s l e e p ( 5 ) ;
40 i n t sNeto = f o r k ( ) ;
41 i f ( sNeto ==0){
42 p r i n t f ( ” Sou o segundo n e t o .
PID : %d . Minha soma : %d\n ” , g e t p i d ( ) , g e t p i d
( ) %10) ;
43 soma+= g e t p i d ( ) %10;
44 e x i t ( EXIT SUCCESS ) ;
45 }
46 }
47 }
48 }
49 r e t u r n 0 ;
50
51 }
Listing 2. Co´digo da questa˜o 4
6. Questa˜o V
Nesta questa˜o deve-se fazer uma ana´lie dissertativa do
co´digo exposo na figura 1 e responder a seguinte pergunta:
O que espera o processo pai?
Figura 1. Execuc¸a˜o do co´digo codigo.c
Segue ana´lise dissertativa:
Os passos de compilac¸a˜o e execuc¸a˜o do co´digo esta´ bem
claro na imagem, por tanto, vamos mergulhar no co´digo.
No co´digo existe um procedimento para que trecho dele
pro´prio seja executado em caso de interrupc¸a˜o e nesse caso,
o trecho que deve ser executado e´ a func¸a˜o void func-
tion(int s).
Segundo Griffiths(2103) (2), Para que o computador possa
executar o pro´prio co´digo em caso de interrupc¸a˜o e´ ne-
cessa´rio fazer um sigaction, enta˜o, nas primeiras linhas
ale´m de declaras as varia´veis linha e valor devolvido dos
tipos char e int respectivamente, faz-se a declarac¸a˜o da
varia´vel ss que e´ um action.
A func¸a˜o switch e´ responsa´vel pelo tratamento na criac¸a˜o
do processo, validando-o e direcionando para as ac¸o˜es de-
pedndo do tipo Filho ou Pai
Caso o processo seja um filho, executa um loop seguindo de
uma pausa, caso o processo seja o Pai, a magia acontece. O
programa informa qual a func¸a˜o que deve ser chamada pelo
computador, no nosse caso e´ informado que function deve
ser chamada. Em seguida usa-se sa mask que ficara´ encar-
regado de filtrar os sinais que signation tratara´.
Apo´s criado o signation, devemos coloca´-la a` disposic¸a˜o
do computador, e isso e´ feito na declarac¸a˜o sigac-
tion(SIGUSR1,ss,NULL) onde e´ passado o nu´mero do si-
nal, a ac¸a˜o (o endenrec¸o de memo´ria da signation) e caso
tivesse, a func¸a˜o que esta´ sendo substituı´da, no caso na˜o ha´.
Se a func¸a˜o falhar, retornara´ -1 que no co´digo apresentado
informa apenas uma string finalizando o programa no caso
de falha.
No trecho aparesentado, e respondendo a pergunta O que
o processo pai espera, ele esta´ esperando o processo Filho
terminar sua execuc¸a˜o.
7. Conclusa˜o
Diferente da pa´tica 1, esta pra´tica se aprofundou um
pouco mais na linguagem C. Pode-se observar como
podemos lidar com os processos manipulando-os para
atenderem a`s nossas necessidades. Pode-se observar ainda
a versatilidaide da linguagem C em poder apontar para
seu pro´prio co´digo quando existe uma interrupc¸a˜o em sua
execuc¸a˜o, isso garante, de certa forma, a continuidade da
execuc¸a˜o do programa.
Refereˆncias
[1] C. A. Maziero. (2008) Sistemas operacionais
2 - gereˆncia de tarefas. [Online]. Available:
http://www.ppgia.pucpr.br/maziero
[2] D. Griffiths and D. Griffiths, Use a
Cabec¸a! C:, ser. Use a Cabec¸a! Alta
Books Editora, 2013. [Online]. Available:
https://books.google.com.br/books?id=63e6BAAAQBAJ