Ufdjrw

I got 2 producers and 1 consumer utilizing a single fifo. Messages are enqueued using k_fifo_alloc_put as shown below:

#include <zephyr.h>

struct message_t 
 u32_t info;
;

K_FIFO_DEFINE(fifo);

void thread_func(void *arg1, void *arg2, void *arg3)

 ARG_UNUSED(arg1);
 ARG_UNUSED(arg2);
 ARG_UNUSED(arg3);

 while(1) 
 struct message_t msg = 
 .info = 1,
 ;
 k_fifo_alloc_put(&fifo, &msg);
 k_sleep(K_SECONDS(1));
 



K_THREAD_STACK_DEFINE(thread1_stack_area, 256);
static struct k_thread thread1_data;

void tick_handler(struct k_timer *timer) 

 struct message_t msg = 
 .info = 2,
 ;
 k_thread_system_pool_assign(k_current_get());
 k_fifo_alloc_put(&fifo, &msg);


void main(void)

 k_thread_system_pool_assign(k_current_get());
 k_thread_create(&thread1_data, thread1_stack_area,
 K_THREAD_STACK_SIZEOF(thread1_stack_area),
 thread_func,
 NULL, NULL, NULL,
 7, 0, K_NO_WAIT);

 struct k_timer timer;
 k_timer_init(&timer, tick_handler, NULL);
 k_timer_start(&timer, K_SECONDS(1), K_SECONDS(1));

 struct message_t *msg;
 for(;;) 
 msg = k_fifo_get(&fifo, K_FOREVER);
 if(msg) printk("Received message from fifo: %drn", msg->info);
 

Both producers are allocating from the same heap. Timer explicitily assigns system heap to itself using k_thread_system_pool_assign(k_current_get()); and the second thread inherits the same heap from main.

Is it safe to do it like this? If not, how should I implement such behavior?

What I really don't understand here is how k_fifo_alloc_put is performing the allocation and how this resource if freed on retrieval as stated in the interface docs:

k_fifo_alloc_put(fifo, data):

This routine adds a data item to @a fifo. There is an implicit
memory allocation from the calling thread's resource pool, which is
automatically freed when the item is removed.