Técnicas Avançadas de ProgramaçãoTécnicas Avançadas de Programação Prof. João Marcos M. da Silva Departamento de Engenharia de Telecomunicações Escola de Engenharia Universidade

Sumário

Técnicas Avançadas de Programação

Prof. João Marcos M. da Silva

Departamento de Engenharia de TelecomunicaçõesEscola de Engenharia

Universidade Federal Fluminense

Agosto de 2011

Prof. João Marcos Meirelles da Silva Aula 02 — pg. 1/33

Sumário

Sumário

1 Processos Concorrentes I

2 Exercícios


Sumário

Sumário


2 Exercícios


Processos Concorrentes IExercícios

IntroduçãoIdentificação de ProcessosPrimitivas

Sumário

1 Processos Concorrentes IIntroduçãoIdentificação de ProcessosPrimitivas

2 Exercícios




Sobre os processos

Os processos são programas carregados na memória docomputador e podem ser classificados como pesados ou leves.

Processos PesadosOs processos pesados são os programas tradicionais, possuindo umconjunto de operações iniciais básicas que começam a suaexecução. Estas operações iniciais são o que chamamos de thread .A função “void main” de um programa escrito em C é uma threadinicial.




Sobre os processos

Atenção

É importante entender que cada programa é, ao menos, umprocesso e que cada processo possui uma série de atributos:

PIDPPIDUID e GIDetc...




Atributos de um processo

PID O Process Identification é um número deidentificação único. O primeiro processo chama-seinit e recebe o PID de número 1;

PPID Nenhum processo é executado de forma independentedos outros. Todos os processos no sistema, comexceção do init, possuem um processo pai. O atributoParent Process ID armazena o PID do processo pai.

UID e GID O User ID e o Group ID auxiliam para que osprocessos sejam executados conforme os privilégiosde uma conta de usuário e o seu grupo associado.





Variáveis de ambiente Cada processo herda do processo paialgumas variáveis de ambiente que guardam algunsvalores que podem ser utilizados pelo processo emexecução;

Diretório de trabalho Os processos também são associados a umdiretório de trabalho, onde podem fazer a leitura e agravação em disco.=;

Temporizadores O Kernel mantém registros da hora em que osprocessos são criados, bem como o tempo de CPUque eles consomem durante a sua execução.





Além de um estado de execução (ready, wait e exec), um processoocupa uma área de memória formada basicamente por 3 partes:

Figure: Estrutura de um processo.





Text Segment O segmento de código contém as instruções demáquina geradas na compilação do programa;

User Data Segment O segmento de dados de usuário contém asvariáveis utilizadas pelo programa;

System Data Segment O segmento de dados do sistema contémos valores dos registradores da CPU quando nãoestiver sendo executado por algum motivo.

Atenção !Como as instruções são separadas dos dados, é possívelcompartilhar o mesmo código entre vários programas em execução.





Um mesmo programa pode ser ativado mais de uma vez, dandoorigem a vários processos. Nesse caso, o segmento de código écompartilhado entre eles, conforme mostrado na Figura abaixo:

Figure: Compartilhamento do segmento de código entre processos.





ImportanteTodos os processos que existam ao mesmo tempo sãoconcorrentes. Eles podem funcionar completamente independentesuns dos outros, ou ocasionalmente necessitar de sincronização ecooperação.

Se certas operações podem ser logicamente executadas emparalelo, temos os chamados processos paralelos.




Racing Conditions

Racing ConditionsSuponha que 3 processos compartilham o acesso a variável A. Doisdeles fazem operações de modificação e um imprime o valor davariável.

Processo 1 → A = A + 5;Processo 2 → A = A + 1;Processo 3 → Imprimir A;




Sumário


2 Exercícios




Identificando um processo

O identificador de cada processo PID é fornecido pelo SistemaOperacional. A linguagem C tem diferentes primitivas quepermitem conhecer este número.

Essas primitivas estão declaradas no cabeçalho unistd.h.

pid_t getpid() A função getpid() retorna o número do processoem execução;

pid_t getppid() A função getppid() retorna o número do processopai que criou o processo em execução.

pid_t getpgrp() Esta função retorna o GID do processo.




Exemplo 1:

#include <stdio.h>#include <unistd.h>

int main(){printf(‘‘Eu sou o processo \%d. Meu pai é o \%d. O ID dogrupo de processo é o \%d.\n’’, getpid(),getppid(),getpgrp());

exit(0);}

Para compilar, salve como ‘‘meupid.c’’:

#gcc meupid.c -o meupid#./meupid




Sumário


2 Exercícios




A primitiva EXEC

A primitiva exec é representada pelas funções:execl()execle()execlp()execv()execve()execvp()

Cada uma das funções desta família trocam a imagem do processoem execução pela imagem de outro processo.




A primitiva EXEC

O arquivo que será chamado por estas funções precisa ser umarquivo binário ou script para ser interpretado por um outroprocesso;O arquivo precisa ter permissões de execução;Essas funções não retornam nenhum valor que indique seusucesso uma vez que o processo em execução é inteiramentetrocado pelo processo novo;No caso de falha, as funções retornam o valor -1.

⇒ Essas funções estão declaradas em unistd.h.




A primitiva EXEC

Atenção !Um script, para ser interpretado no Linux, precisa iniciar com aindicação de qual programa será usado para a sua interpretação.Para fazer isso, sua primeira linha deve começar com:

#!/caminho/programa




int execv(const char *arquivo, char const *argv[ ])

Exemplo 2:


int main{char *cmd[] = {"cat", "/etc/passwd", (char *) 0};

printf("Vou chamar o programa cat para ler o conteúdo de /etc/passwd.\n");execv("/bin/cat", cmd);printf("Esta mensagem não será impressa.\n");

exit(0);}




A primitiva SYSTEM

A primitiva system() executa um programa especificado comparâmetro e retorna ao processo original quando este termina. Oprocesso original não é substituído, mas congelado.

A primitiva system() recebe apenas um único valor, onde ocomando e seus parâmetros devem ser passados como uma únicavariável string.

Esta função retorna -1 em caso de erro. Se for bem sucedida, afunção retorna o código de saída do programa chamado. Estecódigo poderá ser lido através da macro WEXITSTATUS(status).




int system(const char *string)

Exemplo 3:


int main{printf("Vou chamar o programa cat para ler o conteúdo de /etc/issue.\n");system("/bin/cat /etc/issue");printf("Esta mensagem será impressa.\n");

exit(0);}




As primitivas FORK e WAIT

As primitivas fork() e wait() foram as primeiras para especificarconcorrência. O fork() inicia um novo processo que compartilha oespaço de endereçamento do processo pai (criador).

Ambos os processos, pai e filho, continuam a execução em paralelo.

Esta função retorna um valor que pode ser utilizado no controle deexecução.





Características do fork() em Unix/Linux:

Ele duplica o processo que executa a chamada e os doisexecutam o mesmo código;Cada processo tem o seu próprio espaço de endereçamento,com cópia de todas as variáveis, que são independentes emrelação às variáveis do outro processo;Ambos executam a instrução seguinte à chamada de sistema;O retorno da chamada fork() para o processo pai contém aidentificação do PID do processo filho recém criado;





O retorno da chamada fork() para o processo filho é zero;Pode-se selecionar o trecho de código que será executadopelos processo com instrução condicional if ;A sincronização entre os processos pai e filho é feita com aprimitiva wait(), que bloqueia o processo que a executa atéque um processo filho termine.




int fork(void)

Exemplo 4:


int main{int id;

id = fork();if(id !=0){printf("Eu sou o pai e espero pelo meu filho %d.\n", id);wait(0);printf("Meu filho acabou de terminar...vou terminar também!\n");

}else{printf("Eu sou o filho %d e espero 10 segundos.\n", getpid());sleep(10);printf("Já esperei e vou embora...\n");

}}




Exemplo 5:


int main{int pid;

printf("Meu PID é %d. Vou criar um processo filho.\n", getpid());pid = fork();if(pid ==0) {printf("\t\tProcesso filho criado com PID = %d.\n", getpid());printf("Vou ficar executando indefinidamente.\n");for(;;);

}else {sleep(5);printf("O processo pai termina e deixa o filho órfão.\n");printf("Veja se o processo filho continua rodando com o comando\n");printf("ps\n");

}exit(0);

}





Herança entre Pai e FilhoOs processos filhos herdam uma duplicata de todos os descritoresdos arquivos abertos do processo pai. Se o processo filhomovimenta o ponteiro dentro de um arquivo, o processo pai iráfazer a próxima movimentação na nova posição.




Exemplo 6:

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

int main{int pid, fd;char *pidnum, c;int i, r;

printf("Meu PID é %d.\n", getpid());printf("Vou gravar meu número de PID no arquivo meupid.\n");if((fd=open("meupid",O_CREAT|O_RDWR|O_TRUNC,S_IRWXU))==-1){printf("Não consegui criar o arquivo meupid.\n");exit(-1);

}sprintf(pidnum, "%d surpresa", getpid());if(write(fd,pidnum,15)==-1){printf("Não consegui escrever no arquivo.");




exit(-1);}printf("Já escrevi o número. Fechando o arquivo.\n");close(fd);printf("Vou abrir o arquivo novamente para leitura.\n");if((fd=fopen("meupid", O_RDONLY,S_IRWXU))==-1){printf("Não foi possível abrir o arquivo.\n");exit(-1);

}printf("Vou criar um processo filho agora.\n");pid = fork();if(pid ==-1){perror("Não foi possível criar um processo filho.\n");exit(-1);

}else if (pid == 0){printf("\t\tSou o processo filho. Meu PID = %d.\n", getpid());

printf("\t\tVou ler o arquivo que já estava aberto pelo processo pai antes.\n");printf("\t\tda minha criação e que eu herdei.\n");for(i=1; i<= 5; i++){




if(read(fd,&c,1)==-1){printf("Não consegui ler o arquivo...");exit(-1);

}printf("O número que foi lido no arquivo é %c.\n", c);

}printf("\t\tFechando o arquivo e terminando minha execução...\n");close(fd);exit(1);

}else /* aqui começam as instruções do processo pai. */{wait();printf("O processo filho criado tinha o PID número %d.\n", pid);printf("Vou ler o arquivo meupid.\n");while((r=read(fd,&c,1)) != 0){if(r == -1){printf("Impossível ler o arquivo.");exit(-1);

}printf("Consegui ler => %c\n", c);




}printf("Meu filho leu o número do PID no arquivo e mexeu no meu ponteiro.\n");printf("Terminando minha executando.\n");close(fd);

}exit(0);

}





A primitiva wait() tem como objetivo suspender a execução doprocesso pai até que o processo filho termine a sua execução. Estainstrução é especialmente útil, principalmente para evitarmagentaracing conditions.

Outra primitiva da mesma classe á a waitpid(). Ela suspende aexecução de um determinado processo até que o processo filho,especificado pelo PID informado, tenha terminado.

Estas primitivas retornam o valor do PID do processo que foiterminado. Casso ocorra algo inesperado, irão retornar o valor -1.

⇒ Elas estão declaradas no cabeçalho wait.h.





A função waitpid() precisa receber como argumento um número dePID de um processo filho ou os seguintes valores predeterminados:

<-1 Um valor menor que -1 diz à função waitpid() parasuspender o processamento e esperar o término dequalquer processo filho cujo valor de seu GID sejaigual ao número absoluto do valor passado;

-1 Diz à função para suspender o processamento atéque qualquer processo filho termine. Este é ocomportamento padrão;





0 Diz à função para suspender o processamento atéque um processo filho com o mesmo GID do processopai termine;

>0 Diz à função para suspender o processamento atéque o processo filho identificado pelo PID informadoesteja terminado.




pid_t wait(int *status) e pid_t waitpid(pid_t pid, int *status, int options)

Exemplo 7:

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

int main{int pid;

printf("\nMeu PID é %d e meu GID é %d. Irei criar um processo filho.\n",getpid(), getpgrp());if(fork() == 0) /* Instruções do processo filho. */{printf("\t\tProcesso filho criado. Meu PID é %d e meu GID é %d.\n",getpid(), getpgrp());sleep(4);printf("Vou sair com código 7.\n\n");exit(7);

}else /* Instruções do processo pai. */




{int ret1, status1;printf("Sou o processo pai. Estou esperando o processo filho.\n");ret1 = wait(&status1);printf("O processo filho que terminou foi o de de PID = %d.\n", ret1);printf("Ele terminou com o parâmetro de exit() = %d.\n", (status1>>8));

}exit(0);

}




As primitivas EXIT, ABORT e KILL

As primitivas que implementam o término de processos podem serde dois tipos:

exit() Termina o processo normalmente e seus recursos sãoliberados pelo sistema operacional;

abort(pid), kill(pid) São utilizados pelo processo pai para terminarforçadamente os processos filhos.





Processos Zombie

É possível que um determinado processo filho termine por algummotivo inesperado, se torne um processo zombie (ou defunct). Osprocessos zombie não podem ser terminados com o comando kill,porque eles já não existem mais. É preciso terminar o processo pai.




Exemplo 8: Processo zombie (zombie.c)

#include <signal.h>#include <stdio.h>#include <unistd.h>

int main{int pid;

printf("Meu PID é %d e vou criar um processo filho.\n", getpid());pid = fork();if(pid == 0) /* Aqui começam as instruções do processo filho. */{printf("\t\tMeu PID é %d e fui criado por %d.\n", getpid(), getppid());printf("\t\tVerifique os processos em execução com o comando ps.\n");sleep(10);printf("Processo filho terminado normalmente.\n");exit(0);

}else /* Aqui começam as instruções do processo pai. */{ for(;;);}

}





Para compilar e executar o programa, digite:

#gcc zombie.c -o zombie#./zombie &

Para finalizar o processo zombie, digite:

#killall zombie



Atributos de ProcessosIdentificação de Processos

Sumário


2 ExercíciosAtributos de ProcessosIdentificação de Processos




Exercício 1:

Em uma máquina Linux, abra um terminal e digite o comando top.Verifique quais as informações (colunas) são exibidas e tenteidentificar algumas delas. O que você encontrou?




Sumário


2 ExercíciosAtributos de ProcessosIdentificação de Processos




Exercício 2:

Abra um terminal em uma máquina Linux e digite:

#pstree -c -p

Descreva o que você está vendo.


Documents

Técnicas Avançadas de ProgramaçãoTécnicas Avançadas de Programação Prof. João Marcos M. da Silva Departamento de Engenharia de Telecomunicações Escola de Engenharia Universidade