O documento descreve o KURT Real-Time Linux, uma modificação do kernel Linux que permite escalonamento de eventos em tempo real com latência de 10 microsegundos. Ele adiciona novas políticas de escalonamento às já existentes no Linux e possui dois modos de funcionamento: normal e tempo real.

1. KU Real-Time Linux - KURT
Leandro Pinheiro – 261209
Isaac Teles - 261233

2. Índice
Overview
●
Introdução
●
Comparação
●
Modos de operação
●
Escalonamento
●
Módulos de tempo real
●
Arquitetura
●

3. Overview
Modificação do Linux que permite
●
escalonamento de eventos de tempo real.
Tempo de latência de 10 microsegundos
●
Novas políticas de escalonamento
●
adicionada àquelas já existentes no Linux.
Dois modos de funcionamento
●

4. Introdução
O kernel padrão do Linux oferece resolução
●
de tempo de 10ms.
UTIME é uma modificação do kernel padrão
●
para suportar resolução de tempo de 10μs.
Ex:- nanosleep: UTIME permite processos dormirem com precisão de
microsegungos (milisegundos no linux padrão).
KURT provê facilidade de escalonamento
●
event-driven real-time, utilizando a resolução
de tempo em microsegundos provida pelo
UTIME.

5. Comparação
O kernel do linux padrão oferece vários tipos
●
de escalonamento dos processos com
políticas de prioridade.
- Altas prioridades não garatem que certos
processos sempre vencerão na decisão de
escalonamento.
No Kurt, os mecanismos de escalonamento
●
event-driven garantem a execução de
processos por demanda, numa ordem
previamente explicitada.

6. Modos de operação
Modo normal: o sistema age como um sistema
●
Linux genérico.
Modo de tempo real:
●
- Focussed mode: permite apenas processos real-
time;
- Mixed mode: execução de todas as tarefas,
priorizando aquelas de tempo real. As tarefas
convencionais são escalonadas caso não haja
nenhuma tarefa de tempo real para executar.
Uma simples chamada de sitema permite que o
kernel altere de normal/tempo-real e vice-versa.

7. Escalonamento
No Kurt, as aplicações precisam especificar
●
explicitamente o instante em que os eventos de
tempo real estão para ocorrer.
Estes instantes são guardados em um arquivo
●
de classificação e, baseando-se nele, os
eventos são explicitamente escalonados.
-O termo explicitamente é usado propositadamente pois
expressa como o escalonamento ocorre de acordo com
os instanstes previamente determinados no arquivo de
classificação.

8. Escalonamento
O arquivo de classificação que informa qual rotina
●
presente em um módulo de tempo real deve executar
e quando.
Toda rotina de tempo real executa a partir da hora
●
marcada e suspende a si própria usando uma
chamada de sistema apropriada.
- Desta forma, a precisão do relógio de hardware é
transferida para o comportamento das tarefas.
Através da construção e manutenção de uma escala
●
de execução apropriada, a interferência entre tarefas
de tempo real podem ser resolvidas.

9. Escalonamento
Tarefas periódicas também são aceitas. Elas
●
definem o período desejado e são ativadas
pelo Kurt-Linux no início de cada período.
Quando a tarefa completa uma dada
●
ativação, ela suspende a si mesma para ser
acordada pelo sistema no início do próximo
período.

10. Módulos de tempo real
O sistema KU Real-Time consise de módulos
de tempo real (RTmods), no kernel, que
realizam atividades específicas para as
aplicações e um sistema base que chama
estes módulos em tempos determinados
pela aplicação (arquivo de classificação).
● Executam em modo kernel.
● Podem acessar dispositivos e outras partes
do kernel.

11. Arquitetura

12. Modulo de processos
Além dos módulos específicos para uma
●
aplicação, Kurt tem um módulo de processos
cuja função é efetuar a troca de contextos
entre processos.
Um arquivo de classificação especifica dois
●
parâmetros: o instante em que o módulo de
processo deve ser chamado e o para qual
processo a troca de contexto deve ser
realizada.

13. Kurt API Overview
A KURT API é dividida em três categorias:
Operações de utilidade geral
●
Inicialização, registro e controle de
●
processos
Schedule submission
●

14. Kurt API Overview
Operações de utilidade geral
●
Int kurt_open(void)
●
- abre uma instância do KURT pseudo device
Int get_num_rtprocs(int file_desc)
●
- retorna o numero de processos real-time registrados no momento
Int get_rtstats(int file_desc, int pid, struct rtstats *info)
●
- Encontra e retorna a estrutura rtstats. Essa estrutura reporta o comportamento do processo real-time

15. Kurt API Overview
Int get_rt_id_from_name(int file_desc, char *name, int length)
●
- Retorna o id do processo real-time através do nomedo processo
Int event_stats(int file_desc)
●
- Imprime informações esttisticas do real-time timer, acumuladas desde
o boot ou quando o módulo do kurt foi instalada pela ultima vez.
Int proc_stats(int file_desc)
●
Imprime informações estatisticas de todos processos real-time no
momneto
Int set_scheduling_offset(int file_desc, unsigned long value)
●
Seta o offset do escalonamento do KURT
Unsigned long get_scheduling_off(int file_desc)
●
Retorna o offset.

16. Kurt API Overview
Inicialização, registro e controle de processos
●
Int tr_suspend(int file_desc, int susp_mode)
●
- Suspende o processo real-time, marcando-o como interruptivel e
chamando o escalonador. Para processos que utilizam o modo
KURT_EPISODIC, essa rotina deve ser chamada em cada intervalo de
execução. Para os que usam o modo KURT_CONTINUOUS, isso é
opcional.
Int set_rtparams(int file_desc, int pid, int policy, struct rtparams
●
*params)
- Set, reseta, ou unseta a estrutura de parametros real-time de um
processo em particular, dependendo da variavel policy.
Int get_rtparams(int file_desc, int pid, struct rtparams *params)
●
- Retorna a estrutura de parametros real-time de um processo em
particular.

17. Kurt API Overview
Schedule submission
●
Int rt_schedule_events(int file_desc, struct timeval *start_time, int type, int
●
num_times, char *filename)
- Envia um arquivo binário de escalonamento de timers real-time continuos do
tipo timer_list ao kernel.
Int set_scheduling_task( int file_desc)
●
- Registra o processo como uma tarefa no escalonador.
Int clear_scheduling_task( int file_desc)
●
- Desfaz o registro do processo no escalonador.
Int switch_to_rt(int file_desc, int rt_mode, const char *cmdline, int length)
●
- Alterna o kernel para um modo específico de real-time, habilitando o
escalonador real-time
Int switch_to_normal(int file_desc, int force)
●
- Alterna o kernel do modo real-time para o modo normal, desabilitando o
escalonador real-time. Ao menos que seja forçado, essa rotina estará bloqueada
até

18. Kurt API Overview
Inicialiazação e registro de processos real-time no KURT
●
Antes que um processo real-time seja registrado, é necessário que seja
●
determinado qual tipo de escalonador será utilizado. O kurt possui
diversos tipos de escalonamento event-driven disponíveis:

19. Kurt Api Overview
Modos de escalonamento do kernel
●
Há três modos de escalonamento do kernel real-time. Por default, o KURT
●
kernel se encontra no modo normal, ou seja, chama apenas o escalonar padrão
do Linux e bypass o escalonador real-time. Alternando o kernel para o modo
real-time, habilita o escalonador real-time. Isso é feito através da chamada da
rotina switch_to_rt e passando um dos seguintes argumentos rt_mode:
SCHED_KURT_FOCUSSED – Apenas processos KURT real-time podem rodar
●
nesse modo.
SCHED_KURT_PREFERRED – Dá preferência a processos KURT real-time, se
●
não houver nenhum processo real-time pronto para ser executado, o
escalonador padrão do linux é chamado, selecionado uma tarefa non-real-time
ou uma tarefa idle.
SCHED_KURT_MIXED – Dá preferência apenas a processos KURT_EXPLICIT,
●
KURT_ANYTIME e KURT_PERIODIC que triggered uma chamada ao
escalonador, caso o escalonador seja triggered por qualquer outro motivo, o
escalonador linux

20. Kurt API Overview
Modos de escalonamento dos processos
●
Os processo seleciona o tipo de escalonamento, configurando o campo rt_mode da sua
●
estrutura rtparams. Uma vez inicialiazada a estrutura rtparams propriamente, ela deve ser
associada com o processo, chamando a rotina set_rtparams. Isso vai fazer com que a
estrutura seja copiado para o kernel e ligada ao processo especifico.
Há três modos top-level de escalonamento disponíveis para processos real-time:
●
KURT_EXPLICIT – Estas tarefas executam explicitamente durante intervalos de execução
●
real-time. Elas não podem executar fora desses intervalos, exceto quando tratam sinais.
Possuem preferência sobre todos outros processos.
KURT_ANYTIME – Se diferenciam do KURT_EXPLICIT por poderem ser executados fora
●
dos intervalos. Executando fora dos intervalos, são dependentes do modo de
escalonamento atual do kernel.
KURT_PERIODIC – Esse modo é especial, reservado para apenas um processo real-time
●
por vez. O processo especifica um período, em microsegundos, e o kernel usa esse valor
para gera wakeup timers dinamicamente, para esse processo. Um processo
KURT_PERIODIC só ira

21. Instalação
Para instalar o KURT Linux no seu sistema, sigua os seguintes passos:
●
Faça o download da ultima versão do KURT-linux kernel patch, atualmente a
versão kurt-2.4.18-2.patch, no site http://www.ittc.ku.edu/kurt.
Faça também o download de uma cópia do linux kernel correspondente ao
KURT-linux kernel patch, no site http://www.kernel.org
Agora aplique o patch ao kernel:
# patch -p1 -s < /diretorio/kurt-2.4.18.patch
Feito o patch, configure, compile e instale o kernel.
Não esquecer de marcar todas opções que tem a ver com UTIME e KURT como
'build-in', na configuração do kernel.
Reinicie o novo UTIME/KURT Kernel...

22. Instalação
Agora no sistema:
●
Faça o download das API e programas exemplo.
http://www.ittc.ku.edu/kurt/downloads/kurt-2.4.18-2.tar.bz2
Set a várialvel de ambiente KURTLINUX para apintar para seu patched KURT
KERNEL. Por exemplo, se o KURT kernel seride em /usr/src/linux, faça o
seguinte:
>> setenv KURTLINUX /usr/src/linux
Configure e compile a API e programas exemplo. Isso vai fazer com que seja
instalada a biblioteca libkurt.a no /usr/local/lib/
Agora crie os seguinte devices:
# mknod /dev/kurt c 240 0
# mknod /dev/utime c 241 0
# mknod /dev/dstream c 242 0