KU Real-Time Linux - KURT

Leandro Pinheiro – 261209Isaac Teles - 261233

Índice

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

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

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.

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.

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.

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.

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.

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.

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.

Arquitetura

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.

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

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

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.

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.

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é

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:

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

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

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...

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