Definição de processos
0 gostou547 visualizações
O documento descreve um sistema de processos cooperativos implementado através de um buffer circular. O buffer armazena estruturas de processo contendo um ponteiro de função a ser executada. Há funções para adicionar, remover e executar processos no buffer mantendo a ordem de inserção.
![Exercício
typedef int (*ptrFunc)(void* param);
//definição da estrutura
typedef struct {
char tipo;
void* ptr;
ptrFunc func;
}process;
//definição do buffer circular
#define BUFFERSIZE 10
process buffer[BUFFERSIZE];
//definição dos “ponteiros” de acesso
int ini, fim;](https://image.slidesharecdn.com/elt048-04-processos-130414145150-phpapp02/85/Definicao-de-processos-4-320.jpg)
![Exercício
//função de adição de “process” no buffer
void addProc(process nProcesso){
//checagem de espaço disponível
if ( ((fim+1)%BUFFERSIZE) != ini){
//Atualização da posição atual
buffer[fim] = nProcesso;
//incremento da posição
fim = (fim+1)%(BUFFERSIZE);
}
}](https://image.slidesharecdn.com/elt048-04-processos-130414145150-phpapp02/85/Definicao-de-processos-5-320.jpg)
![Exercício
//função de adição de “process” no buffer
void exec(void){
//checar se existe alguem para ser executado
if (ini != fim){
//execução da função passando ptr como
parâmetro
buffer[ini].func(0);
}
}](https://image.slidesharecdn.com/elt048-04-processos-130414145150-phpapp02/85/Definicao-de-processos-7-320.jpg)
Definição de processos
- 1. ELT048 - SOE Processos Rodrigo Almeida Universidade Federal de Itajubá
- 2. Revisão ● Ponteiros de função ● Engine de processamento
- 3. Exercício ● Modifique a estrutura apresentada anteriormente para incluir também um ponteiro de função. ● Crie uma função que executa o ponteiro de função armazenado na “primeira” posição do buffer circular. ● Crie um main que adicione 3 elementos no buffer e execute cada um deles na ordem que foram inseridos. ● Add(x3), exec, remove, exec, remove, exec, remove
- 4. Exercício typedef int (*ptrFunc)(void* param); //definição da estrutura typedef struct { char tipo; void* ptr; ptrFunc func; }process; //definição do buffer circular #define BUFFERSIZE 10 process buffer[BUFFERSIZE]; //definição dos “ponteiros” de acesso int ini, fim;
- 5. Exercício //função de adição de “process” no buffer void addProc(process nProcesso){ //checagem de espaço disponível if ( ((fim+1)%BUFFERSIZE) != ini){ //Atualização da posição atual buffer[fim] = nProcesso; //incremento da posição fim = (fim+1)%(BUFFERSIZE); } }
- 6. Exercício //função de remoção de um “process” do buffer void removeProc (void){ //checagem se existe alguem pra retirar if ( ini != fim){ //incremento da posição ini = (ini+1)%(BUFFERSIZE); } }
- 7. Exercício //função de adição de “process” no buffer void exec(void){ //checar se existe alguem para ser executado if (ini != fim){ //execução da função passando ptr como parâmetro buffer[ini].func(0); } }
- 8. Exercício #include “stdio.h” void main (void){ process p1 = {"",0,func1}; process p2 = {"",0,func2}; process p3 = {"",0,func3}; ini = 0; fim = 0; addProc(p1); addProc(p2); addProc(p3); exec(); removeProc(); exec(); removeProc(); exec(); removeProc(); }
- 9. Processo ● Um processo é composto por uma unidade de código que pode ser executada, uma região delimitada de memória e um conjunto de informações sobre seu estado atual.
- 10. Processo ● A implementação de um processo é muito dependente do tipo de kernel utilizado e das interfaces disponíveis ao programador. ● O processo mais simples pode ser representado por uma função.
- 11. Processo //ponteiro para mapa de I/O #define LEDS (*((unsigned char*)0xF95)) //processo para piscar os leds void blinkLeds (int time){ int i; //liga os leds LEDS = 0x00; for(i = 0; i < time; i++){ __asm NOP } //desliga os leds LEDS = 0xFF; for(i = 0; i < time; i++){ __asm NOP } }
- 12. Processo ● Como fazer para que o processo continue executando? ● Re-executar a função? ● Fazer um loop interno com n repetições ● Fazer um loop infinito?
- 13. Processo ● Como fazer para que o processo continue executando? ● Antes é preciso saber: ● Que tipo de kernel está rodando: preemptivo ou cooperativo? ● Existe um escalonador temporal?
- 14. Processo ● Loop infinito: Só deve ser usado se o kernel for capaz de interromper o processo ou se este for o único processo do sistema. ● No último caso não faz sentido ter um kernel.
- 15. Processo – Loop infinito //processo para piscar os leds void blinkLeds (int time){ int i; //liga os leds for(;;){//ever LEDS = 0x00; for(i = 0; i < time; i++){ __asm NOP } //desliga os leds LEDS = 0xFF; for(i = 0; i < time; i++){ __asm NOP } } }
- 16. Processo ● Re-execução da função: permite que o processo deixe tempo livre para o kernel executar outras funções. Deve ser utilizado no kernel cooperativo. ● Quando possível omite-se as rotinas de tempo/delay deixando a cargo do kernel. ● Deste modo o sistema pode realizar alguma tarefa mais útil
- 17. Processo – Reexecução //Original //processo para piscar os leds void toggleLeds (int time){ int i; LEDS = 0x00; for(i = 0; i < time; i++){ __asm NOP } //desliga os leds LEDS = 0xFF; for(i = 0; i < time; i++){ __asm NOP } } //igual à primeira implementação. Gasta tempo atoa.
- 18. Processo – Reexecução //Omissão das rotinas de tempo 1 //processo para piscar os leds void toggleLeds (int time){ int i; //liga os leds LEDS = 0x00; //desliga os leds LEDS = 0xFF; } //Não funciona, deve ligar em uma chamada e desligar em outra
- 19. Processo – Reexecução //Omissão das rotinas de tempo 2 //processo para piscar os leds void toggleLeds (int time){ int i; LEDS = ~LEDS; } //Não funciona bem, os tempos não são respeitados
- 20. Processo – Reexecução //Omissão das rotinas de tempo 3 //processo para piscar os leds void toggleLeds (int time){ int i; static int lastTime; if ( (now() - lastTime) >= time){ LEDS = ~LEDS; LastTime = now(); } } //a função now() deve retornar o horário em unidades de segundo/milisegundo
- 21. Processo ● Como citado o processo é, a principio, uma função que deve ser executada quando o processo é chamado. ● Além disto existem diversas informações importantes que devem ser agregadas para que o processo seja gerenciavel ● Prioridade, tempo de execução, nome, região de memória reservada etc. ● Em geral é utilizado uma estrutura para agregar todas estas informações.
- 22. Processo typedef int (*ptrFunc)(void* param); //código antigo typedef struct { char* nomeDoProcesso; ptrFunc funcao; int prioridade; int tempo; }process;
- 23. Exercício ● Adaptar o código e executá-lo no kit de desenvolvimento. ● Reunir todas as funções relacionadas à operação com o buffer circular numa biblioteca. ● Utilizar o debugger da placa para verificar o funcionamento do programa.