queues and hook functions

ESCOLA POLITÉCNICA DE PERNAMBUCO – UNIVERSIDADE DE PERNAMBUCO

SISTEMAS OPERACIONAIS

QUEUES E HOOK

FUNCTIONS



Introdução

Conceito de FIFO ( First In First Out ) onde os

dados são escritos no fim e lidos no início.



Introdução

Queues são a principal forma de comunicação entre tarefas.



Introdução

Elas podem ser usadas para enviar mensagens entre tarefas

e entre interrupções e tarefas.



Introdução

Novos dados podem ser enviados para o fim da fila

ou ainda podem ser enviados para a frente.



Introdução

Uma fila não pertence a nenhuma tarefa em

específico.



Introdução • Cada queue armazena um conjunto finito de itens

(uxLenght);

• Cada item do queue pode ter um tamanho fixo de bytes

(uxItemSize);

• Ambos “uxLenght” e “uxItemSize” são definidos no

momento da criação do queue;

• Escrever em uma queue significa copiar os dados byte a

byte. Ler de uma queue significa cópia e remoção dos

dados da queue. Se o elemento da queue for muito

grande, o ideal é trabalhar com ponteiros.



• Pequenas mensagens podem ser enviadas diretamente para a queue

ou lidas diretamente da queue através de variáveis.

• O envio para uma queue deste modo permite substituir a variável que

foi enviado para a queue.

• Usar queues que passam dados por cópia não impede que elas

também possam ser utilizadas para transmitir dados por referência.

• Quando o tamanho de uma mensagem chegar a um ponto em que não

é prático copiar toda a mensagem para a queue byte a byte, então são

utilizados ponteiros. O ponteiro é copiado para o lugar da mensagem

na queue.

Introdução



• Uma única queue pode ser usada para receber diferentes tipos de

mensagens e mensagens de vários locais.

• Uma queue pode armazenar uma estrutura que tem um elemento que

contém o tipo de mensagem, e um outro elemento que contém os

dados da mensagem ou ainda um ponteiro para os dados da

mensagem.

• Os dados são interpretados depende do tipo de mensagem.

• Por exemplo, isto é exatamente o que a tarefa que gerencia a pilha

FreeRTOS + UDP IP é capaz de fazer.

• Usa única fila para receber notificações de eventos do timer ARP,

pacotes sendo recebidos do hardware Ethernet, os pacotes recebidos

do aplicativo, a rede para baixo eventos, etc

Introdução



As funções da API de queues permite um tempo de bloqueio que

pode ser especificado caso uma das duas situações ocorram:

• Lendo da Queue:

• A tarefa esta aguardando um item da queue. A tarefa será colocada

no estado Blocked até que os dados estejam disponíveis na fila ou

até o tempo de bloqueio expirar (timeout de leitura). • Não consome tempo de CPU e outras tarefas podem ser executadas.

• Uma tarefa esperando um item na queue é automaticamente

colocada no estado Ready quando: • Um item é escrito na queue;

• O timeout de leitura expira ;

Bloqueio de Queues



• Lendo da Queue:

• Queues podem ter mais de uma tarefa esperando a leitura de um

item;

• A tarefa de maior prioridade é passada para o estado Ready;

• Se existir mais uma tarefa com a mesma prioridade, então a tarefa

que esta esperando a mais tempo será passada para o estado

Ready.

Bloqueio de Queues



• Lendo do Queue:

Bloqueio de Queues



• Escrevendo na queue:

• A tarefa tenta escrever em uma queue cheia. A tarefa será colocada

no estado Blocked até que haja espaço disponível na fila ou até o

tempo de bloqueio expirar (timeout de escrita). • Não consome tempo de CPU e outras tarefas podem ser executadas.

• Uma tarefa escrevendo um item na queue é colocada

automaticamente no estado Ready quando: • O elemento é escrito na queue com sucesso;

• O timeout de escrita expira;

• Se a queue estiver cheia assim que surgir um espaço livre a tarefa

de maior prioridade é colocada no estado Ready;

• Se houver mais de uma tarefa bloqueada com a mesma prioridade

aguardando, a tarefa que estiver a mais tempo será passada para o

estado Ready..

Bloqueio de Queues



• Escrevendo no queue:

Bloqueio de Queues



• Normalmente os eventos são tratados com interrupções

dentro de uma rotina de tratamento de interrupção (ISR);

• Queues são usados para comunicar eventos e transferir

dados;

• Portanto, o queue pode ser usado para transferir dados e

deferir trabalho de uma interrupção para uma tarefa do

RTOS;

• Em interrupções use sempre as funções que terminam com

FromISR();

Interrupções



API Functions



API Functions xQueueCreate

queue.h

QueueHandle_t xQueueCreate

(

BaseType_t uxQueueLength,

BaseType_t uxItemSize

);

Retorno:

Se a fila é criada com êxito, um identificador para a fila recém-criada é

retornado.

Se a fila não pode ser criada, é retornado 0.

Parâmetros:

• uxQueueLength: O número máximo de itens que a fila pode conter.

• uxItemSize: O número de bytes de cada item na fila vai exigir.



API Functions vQueueDelete queue.h

void vQueueDelete

{

QueueHandle_t xQueue

};

Parâmetros:

• xQueue - Um identificador para

a fila para ser excluído.

xQueueReset queue.h

BaseType_t xQueueReset

(


);

Parâmetros:

• xQueue : o identificador da fila é

passado,

Retorna:

Desde FreeRTOS V7.2.0 xQueueReset()

sempre retorna pdPASS.



API Functions

uxQueueSpacesAvailable

queue.h

BaseType_t uxQueueSpacesAvailable

(


);

Parâmetros:

• xQueue : O identificador da fila para

ser consultado.

Retorna:

O número de espaços livres em uma

fila.

uxQueueMessagesWaiting

queue.h

BaseType_t uxQueueMessagesWaiting

(


);

Parâmetros:

• xQueue : O identificador da fila para

ser consultado.

Retorna :

O número de mensagens disponíveis

na fila.



API Functions vQueueAddToRegistry

queue.h

void vQueueAddToRegistry

(

QueueHandle_t xQueue,

char * pcQueueName

);

Parâmetros:

• xQueue: O identificador da fila em

que o item será escrito.

• pcQueueName: O nome a ser

atribuído à fila. Esta é apenas uma

sequência de texto usado para facilitar a

depuração.

vQueueUnregisterQueue

queue.h

vazio vQueueUnregisterQueue

(


);

Parâmetros:

• xQueue: O identificador da fila

que será removida do registro.



API Functions xQueueOverwrite

queue.h

BaseType_t xQueueOverwrite

(


const void * pvItemToQueue

);

Retorna:

xQueueOverwrite() é uma macro que chama xQueueGenericSend(), e,

portanto, tem os mesmos valores de retorno como

xQueueSendToFront(). No entanto, pdPASS é o único valor que pode ser

retornado porque xQueueOverwrite() escreve na fila, mesmo quando a fila

já esta cheia.

Parâmetros:

• xQueue: O identificador da fila em que o

item será escrito.

• pvItemToQueue: Um ponteiro para o

item que será colocado na fila.



API Functions

xQueuePeek queue.h

BaseType_t xQueuePeek

(


void * pvBuffer, TickType_

t xTicksToWait

);

Retorna:

pdTRUE se o item foi recebido com êxito na fila, caso contrário pdFALSE.

Parâmetros:

• xQueue: O identificador da fila em que o item será escrito.

• pvBuffer: Ponteiro para o buffer no qual o item recebido será copiado.

• xTicksToWait: A quantidade máxima de tempo que a tarefa deve bloquear à espera de

um item caso a fila esteja vazia no momento da chamada.



API Functions uxQueueMessagesWaitingFromISR

queue.h

BaseType_t uxQueueMessagesWaiting

(


);

Parâmetros:

• xQueue: Um identificador da fila que será consultada.

Retorna:

O número de mensagens armazenadas em uma fila.



API Functions xQueueSendFromISR

queue.h

BaseType_t xQueueSendFromISR

(


const void * pvItemToQueue,

BaseType_t * pxHigherPriorityTaskWoken

);

Retorna:

pdTRUE se os dados foram enviados com sucesso para a fila, caso contrário

errQUEUE_FULL.



API Functions

Parâmetros:

• xQueue: O identificador da fila em que o item está a ser escrito.

• pvItemToQueue: Um ponteiro para o item que será colocado na fila. O tamanho dos

itens da fila já foram definidos quando a fila foi criada.

• pxHigherPriorityTaskWoken: xQueueSendFromISR() irá definir

*pxHigherPriorityTaskWoken para pdTRUE se enviar para a fila uma tarefa desbloqueada

e esta tarefa desbloqueada tiver uma prioridade maior do que a tarefa em execução. Se

xQueueSendFromISR() definir este valor para pdTRUE então uma mudança de contexto

deve ser solicitada antes da interrupção ser encerrada. No FreeRTOS V7.3.0

pxHigherPriorityTaskWoken é um parâmetro opcional e pode ser definido como NULL.



API Functions

xQueueSendToFrontFromISR

queue.h

BaseType_t xQueueSendToFrontFromISR

(


const void *pvItemToQueue,

BaseType_t *pxHigherPriorityTaskWoken

);

Retorno:

pdPass se os dados foram enviados com sucesso para a fila, senão

errQUEUE_FULL.



API Functions

Parâmetros:

• xQueue: O identificador da fila na qual o item deve ser publicado.

• pvItemToQueue: Um ponteiro para o item que será colocado na fila.

• pxHigherPriorityTaskWoken: xQueueSendToFrontFromISR() irá definir

*pxHigherPriorityTaskWoken para pdTRUE se enviar para a fila uma tarefa

desbloqueada e esta tarefa desbloqueada tiver uma prioridade maior do que a

tarefa em execução. Se xQueueSendFromISR() definir este valor para pdTRUE

então uma mudança de contexto deve ser solicitada antes da interrupção ser

encerrada. No FreeRTOS V7.3.0 pxHigherPriorityTaskWoken é um parâmetro

opcional e pode ser definido como NULL.



API Functions xQueueReceiveFromISR

queue.h

BaseType_t xQueueReceiveFromISR

(


void *pvBuffer,


);

Retorno:

pdTRUE se o item foi recebido com êxito na fila, senão pdFALSE.



API Functions

Parâmetros:

• xQueue: O identificador da fila para onde o item será enviado.

• pvBuffer: Ponteiro para o buffer no qual o item recebido será copiado

• pxHigherPriorityTaskWoken: Uma tarefa pode estar bloqueada esperando

pelo espaço disponível no âmbito da fila. Se xQueueReceiveFromISR provoca

tal tarefa para desbloquear *pxHigherPriorityTaskWoken irá ser definido para

pdTRUE, caso contrário *pxHigherPriorityTaskWoken permanecerá inalterado.

De FreeRTOS V7.3.0 pxHigherPriorityTaskWoken é um parâmetro opcional e

pode ser definido como NULL.



API Functions xQueueIsQueueEmptyFromISR

queue.h

BaseType_t xQueueIsQueueEmptyFromISR

(

const QueueHandle_t xQueue

);

Parâmetros:

• xQueue: O indicador da fila que está sendo consultada

Retorno:

pdFALSE se a fila não estiver vazia, ou qualquer outro valor se a fila estiver vazia.



API Functions xQueueIsQueueFullFromISR

queue.h

BaseType_t xQueueIsQueueFullFromISR

(

const QueueHandle_t xQueue

);

Parâmetros:

• xQueue: O identificador da fila que será consultada

Retorno:

pdFALSE se a fila não estiver cheia, ou qualquer outro valor se a fila estiver cheia.



API Functions xQueueOverwriteFromISR

queue.h

BaseType_t xQueueOverwrite

(


const void *pvItemToQueue,


);

Retorno:

xQueueOverwriteFromISR() é uma macro que chama

xQueueGenericSendFromISR(), e, portanto, tem os mesmos valores de retorno

como xQueueSendToFrontFromISR(). No entanto, pdPass é o único valor que

pode ser retornado porque xQueueOverwriteFromISR() vai escrever na fila, mesmo

quando a fila já estiver cheia.



API Functions

Parâmetros:

• xQueue: O identificador da fila para a qual os dados devem ser enviados.

• pvItemToQueue: Um ponteiro para o item que será colocado na fila.

• pxHigherPriorityTaskWoken: xQueueOverwriteFromISR() irá definir

*pxHigherPriorityTaskWoken para pdTRUE se enviar para a fila uma tarefa

desbloqueada e esta tarefa desbloqueada tiver uma prioridade maior do que a

tarefa em execução. Se xQueueOverwriteFromISR() definir este valor para

pdTRUE então uma mudança de contexto deve ser pedido antes da interrupção

ser encerrada.



Hook Functions



Tick Interrupt

• Em um kernel preemptivo: – Tarefas possuem um tempo para execução

– Time slice ou quantum

• No fim desta período de tempo: – Escalonador selecionará a próxima tarefa para

execução.

• O kernel usa uma interrupção do sistema: – tick interrupt (system tick ou clock tick).



• Tick interrupt (system tick ou clock tick) – Interrupção periódica

– configTICK_RATE_HZ no arquivo FreeRTOSConfig.h

#define configUSE_PREEMPTION 1 #define configUSE_IDLE_HOOK 0 #define configUSE_TICK_HOOK 0 #define configCPU_CLOCK_HZ ( SystemCoreClock ) #define configTICK_RATE_HZ ( ( portTickType ) 1000 )

Tick Interrupt



Tick Interrupt



• Uma função de callback pode ser chamada em

cada tick interrupt:

– executando uma rotina periódica, como zerar o

watchdog timer.

– Contexto de interrupção -> processamento o mais breve

possível.

• Habilitar opção:

– configUSE_TICK_HOOK

• Implemente a função:

– void vApplicationTickHook(void);

Tick Interrupt Hook



Tarefa Idle

• Ao se trabalhar com eventos:

– as tarefas estão quase sempre no estado Blocked.

– e não podem ser escolhidas e executadas pelo escalonador.

• Só que, a CPU precisará executar algo.

– a tarefa Idle

– criada automaticamente na inicialização do escalonador

– ao chamar a função vTaskStartScheduler().

– tem prioridade 0.



Tarefas em Execução



Idle Hook Function

• Função de callback chamada ao executar a tarefa Idle. – Executar um processamento contínuo em background.

– Medir a quantidade de processamento livre disponível.

– Colocar o processador em modo de baixo consumo.

• Habilitar a opção configUSE_IDLE_HOOK no arquivo FreeRTOSConfig.h.

• Implementar a função:

void vApplicationIdleHook(void);



Implementação

• A função de Idle Hook nunca deve bloquear ou suspender.

• Na tarefa Idle ocorre a limpeza das tarefas deletadas pela aplicação.

– se a aplicação usa a função vTaskDelete(),

– Então a função Idle Hook sempre deverá retornar.

void vApplicationIdleHook( void )

{

++u64IdleTicksCnt;

}



Gerenciamento de Memória

• O FreeRTOS precisa alocar memória dinamicamente toda

vez que cria uma tarefa, um queue ou um semáforo.

• Quando o kernel precisa alocar memória, em vez de

chamar malloc() diretamente, o kernel chama

pvPortMalloc().

• Da mesma forma, para liberar memória, em vez de chamar

a função free(), o kernel chamará a função vPortFree().



Alocação

• O FreeRTOS fornece 4 diferentes implementações para

alocação de memória:

• heap_1.c: apenas aloca memória.

• heap_2.c: aloca e desaloca memória, mas não trata fragmentação.

• heap_3.c: usa a implementação padrão de malloc() e free() da

biblioteca C.

• heap_4.c: disponível a partir da versão 7.2.0 do FreeRTOS. Aloca e

desaloca memória, trata fragmentação e é mais eficiente que a maioria

das implementações da biblioteca C padrão.



Malloc Failed Hook Function

• Os esquemas de alocação de memória implementados por

heap1.c, heap2.c, heap3.c e heap4 podem, opcionalmente,

incluir a função Malloc Failed Hook Function que pode ser

configurada para ser chamado se pvPortMalloc() retornar

NULL.

• Definir a função Malloc Failed Hook Function ajudará a

identificar os problemas causados pela falta de memória no

heap - especialmente quando falha uma chamada para

pvPortMalloc() dentro de uma função da aplicação.



Malloc Failed Hook Function

• A Malloc Failed Hook Function será chamada apenas se

configUSEMALLOCFAILEDHOOK estiver definida como 1

em FreeRTOSConfig.h.

• Quando isso é definido, a aplicação deve implementar o

método com a seguinte assinatura:

void vApplicationMallocFailedHook( void );



Stack

• Região de memória onde são salvos as variáveis locais,

registradores e parâmetros nas chamadas de função.

• Na criação de uma tarefa, um stack de uso particular desta

tarefa, também é definido.

• Um mau dimensionamento do stack pode levar uma tarefa

a ultrapassar este espaço alocado (stack overflow).



Stack Overflow Hook

• Dois mecanismos opcionais podem monitorar o stack das

tarefas em tempo de execução.

• O kernel irá monitorar o stack das tarefas, caso identifique

stack overflow, ele executará uma função de callback (stack

overflow hook).

• Tem como desvantagem o aumento do tempo na troca de

contexto.



Stack Overflow Hook

• Para ambos os métodos, a implementação da função de

callback de stack overflow é a seguinte:

void vApplicationStackOverflowHook

(xTaskHandle *pxTask, signed char *pcTaskName);

• Deve ser usada para:

– identificar e corrigir problemas de stack durante o desenvolvimento

da aplicação.

– Simplificar o debugging de problemas com o stack.

• Não existe nenhum jeito fácil de se recuperar de um stack

overflow.



MÉTODO 1

• É selecionado quando configuramos no arquivo FreeRTOSConfig.h:

configCHECK_FOR_STACK_OVERFLOW com 1.

• Após a troca de contexto de uma tarefa, o kernel verifica o stack pointer do stack associada a esta tarefa. Caso esteja fora dos limites será chamada a função de stack overflow hook.

• A desvantagem é que pode-se perder alguns stack overflows, já que apenas verifica-se o stack pointer na troca de contexto, ou seja, durante algum momento na execução da tarefa o stack pointer pode ter ultrapassado os limites do stack.

Stack Overflow Hook



Stack Overflow Hook MÉTODO 2

• É selecionado quando configuramos no arquivo FreeRTOSConfig.h:

configCHECK_FOR_STACK_OVERFLOW com 2.

• Acrescenta mais uma checagem ao método 1.

• O stack é preenchido com um padrão conhecido, que terá seus últimos

20 bytes verificados. Caso tenham sido sobrescrito, a função de stack

overflow hook será chamada.

• Tem a desvantagem de ser mais lento do que o método 1 , em

contrapartida garante quase que 100% de acerto.

queues and hook functions

Education