Queues e funções de API em sistemas operacionais

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 e funções de API em sistemas operacionais

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (9)

Semelhante a Queues e funções de API em sistemas operacionais

Semelhante a Queues e funções de API em sistemas operacionais (20)

Mais de Mayara Mônica

Mais de Mayara Mônica (20)

Último

Último (20)

Queues e funções de API em sistemas operacionais