Desenvolvimento de um primeiro modelo de kernel que atende a requisitos temporais. Breve introdução sobre real time.

1. ELT048 - SOE
Requisitos temporais
Rodrigo Almeida
Universidade Federal de Itajubá

2. Revisão
● Kernel cooperativo
● Troca de processos
● Métodos de escalonamento

3. Exemplo
● Exemplo de kernel cooperativo
● O código apresentado pode ser compilado em
qualquer compilador C
● O kernel é composto por três funções:
● KernelInit(): Inicializa as variáveis internas
● KernelAddProc(): Adiciona processos no pool
● KernelLoop(): Inicializa o gerenciador de
processos
– Esta função possui um loop infinito pois ela só
precisa terminar quando o equipamento/placa for
desligado.

4. //return code
#define SUCESSO 0
#define FALHA 1
#define REPETIR 2
#define POOLSIZE 10
//function pointer declaration
typedef char(*ptrFunc)(void);
//process struct
typedef struct {
ptrFunc function;
} process;
process* pool[POOLSIZE];
Exemplo

5. char kernelInit(void){
ini = 0;
fim = 0;
return SUCESSO;
}
char kernelAddProc(process* newProc){
//checking for free space
if ( ((fim+1)%POOLSIZE) != ini){
pool[fim] = newProc;
fim = (fim+1)%POOLSIZE;
return SUCESSO;
}
return FALHA;
}
Exemplo

6. void kernelLoop(void){
for(;;){
//Do we have any process to execute?
if (ini != fim){
//check if there is need to reschedule
if (pool[start]->Func() == REPETIR){
kernelAddProc(pool[ini]);
}
//prepare to get the next process;
ini = (ini+1)%POOLSIZE;
}
}
}
Exemplo

7. void tst1(void){
printf("Process 1n");
return REPETIR;
}
void tst2(void){
printf("Process 2n");
return SUCESSO;
}
void tst3(void){
printf("Process 3n");
return REPETIR;
}
● Os processos
Exemplo

8. void main(void){
//declaring the processes
process p1 = {tst1};
process p2 = {tst2};
process p3 = {tst3};
kernelInit();
//Test if the process was added successfully
if (kernelAddProc(p1) == SUCESSO){
printf("1st process addedn");}
if (kernelAddProc(p2) == SUCESSO){
printf("2nd process addedn");}
if (kernelAddProc(p3) == SUCESSO){
printf("3rd process addedn");}
kernelLoop();
}
Exemplo

9. Console Output:
---------------------------
1st process added
2nd process added
3rd process added
Ite. 0, Slot. 0: Process 1
Ite. 1, Slot. 1: Process 2
Ite. 2, Slot. 2: Process 3
Ite. 3, Slot. 3: Process 1
Ite. 4, Slot. 0: Process 3
Ite. 5, Slot. 1: Process 1
Ite. 6, Slot. 2: Process 3
Ite. 7, Slot. 3: Process 1
Ite. 8, Slot. 0: Process 3
...
---------------------------
Exemplo

10. Requisitos temporais
Na maioria dos sistemas embarcados é
necessário garantir que algumas funções
sejam executadas com uma certa frequência.
Alguns sistema podem até mesmo falhar caso
estes requisitos não sejam atingidos.

11. Requisitos temporais
● Tempo real
● Velocidade
● Instantâneadade

12. Real time
● Capacidade de um
sistema em garantir
a peridiocidade de
uma tarefa
● O importante é o
determinismo na
execução, não a
velocidade
business2community.com

13. Real time
● Capacidade de um
sistema em garantir
a peridiocidade de
uma tarefa
● Determinismo

14. Real time
● Hard real time ● Soft real time

15. Requisitos temporais
● Para implementar um sistema que trabalhe
com requisitos temporais:
1)Deve existir um relógio que trabalhe com uma
frequência precisa.
2)O kernel deve ser informado da frequência, ou
período, de execução de cada processo.
3)A soma dos tempos de cada processo deve
“caber” no tempo disponível do processador.

16. ●
1a
condição:
● É necessário um timer que possa gerar uma
interrupção.
●
2a
condição:
● Adicionar as informações na estrutura do
processo
●
3a
condição:
● Testar, testar e testar.
● Em caso de falha:
– Chip mais rápido
– Otimização
Requisitos temporais

17. ● Agendamento dos processos:
● A utilização de um timer finito para medição de
tempo pode causar overflow
● Exemplo: agendamento de 2 processos para
10 e 50 segundos (1 bit = 1ms)
Agendamento

18. ● E se os dois processos forem agendados
para o mesmo tempo?
Agendamento

19. ● Suponha que o primeiro processo fosse
executado:
● Do diagrama de tempo abaixo o processo P2
está atrasado 10(s) ou foi agendado para
acontecer daqui 55(s)?
Agendamento

20. ● Solução:
● Utilizar um contador temporizado decrescente
para cada processo ao invés de um valor de
agendamento.
● Problema:
● Cada um dos contadores devem ser
decrementados na rotina de interrupção.
● Isso é um problema pra sua aplicação?
Agendamento

21. Kernel com requisitos temporais

22. ● A primeira modificação é adicionar
● Um contador para cada processo
● Uma variável para armazenar o período de
execução
//process struct
typedef struct {
ptrFunc function;
int period;
int start;
} process;
Kernel com requisitos temporais

23. ● Deve ser criada uma função de interrupção
para decrementar cada um dos contadores
dos processos
● Os detalhes intrínsecos do processo de
criação e manipulação de interrupções está
fora do escopo desta aula.
● Por facilidade será utilizado o Device
initialization
Kernel com requisitos temporais

24. Device initialization

25. Device initialization

26. Rotina de Interrupção

27. Rotina de Interrupção
//colocar no MCUinit.c na função isrVrti()
#include “kernel.h”
__interrupt void isrVrti(void){
KernelClock();
//limpar a flag de interrupção
CRGFLG = 0x80;
}

28. Rotina de Interrupção
//colocar no kernel.c
#define MIN_INT -30000
void KernelClock(void){
unsigned char i;
i = ini;
while(i!=fim){
if((pool[i].start)>(MIN_INT)){
pool[i].start--;
}
i = (i+1)%SLOT_SIZE;
}
}
//colocar no kernel.h
void KernelClock(void);

29. ● A função de adição de processos deve
inicializar corretamente as variáveis
char AddProc(process* newProc){
//checking for free space
if ( ((fim+1)%POOLSIZE) != ini){
pool[fim] = newProc;
//increment start timer with period
pool[fim].start += newProc.period;
fim = (end+1)%POOLSIZE;
return SUCESSO;
}
return FALHA;
}
Kernel com requisitos temporais

30. ● A função de execução do kernel apresenta
uma mudança maior.
● O processo de escalonamento muda de um
modelo FIFO (aula anterior) para um
escalonador baseado no menor tempo de
inicio.
Kernel com requisitos temporais

31. if (ini != fim){
//Procurando o processo com menor tempo de inicio
j = (ini+1) % POOLSIZE;
next = ini;
while(j!=fim){
if (pool[j].start < pool[next].start){
next = j;
}
j = (j+1)%POOLSIZE;
}
//trocando as posições no pool
tempProc = pool[next];
pool[next] = pool[ini];
pool[ini] = tempProc;
while(pool[ini].start>0){
//ótimo lugar para economia de energia
}
if ( (pool[ini]->function)() == REPETIR ){
AddProc(&(pool[ini]));
}
ini = (ini+1)%POOLSIZE;
}

32. Exercício
● Montar um relógio binário onde cada led
pisca numa frequência diferente
1
2
3
4
1 segundo
2 segundos
4 segundos
8 segundos //Ligar o 1o led
PORTB = PORTB | 0x01;
//Desligar o 1o led
PORTB = PORTB & ~0x01;
//Piscar o 1o led
PORTB = PORTB ^ 0x01;