add a set of dyn(create / destroy) interface

1. tos_ring_q_create_dyn
2. tos_chr_fifo_create_dyn
3. tos_msg_q_create_dyn
4. tos_mail_q_create_dyn
5. tos_bin_heap_create_dyn
6. tos_prio_q_create_dyn
7. tos_prio_msg_q_create_dyn
8. tos_prio_mail_q_create_dyn

board/ALIENTEK_STM32F429/TOS-CONFIG/tos_config.h

@@ -7,7 +7,7 @@
 
 #define TOS_CFG_ROUND_ROBIN_EN      1u
 
-#define TOS_CFG_OBJECT_VERIFY_EN       0u
+#define TOS_CFG_OBJECT_VERIFY_EN       1u
 
 #define TOS_CFG_TASK_DYNAMIC_CREATE_EN  0u
 

board/GigaDevice_GD32VF103C_START/TOS_CONFIG/tos_config.h

@@ -11,7 +11,7 @@
 #define TOS_CFG_ROUND_ROBIN_EN 0u
 
 // 配置TencentOS tiny是否校验指针合法
-#define TOS_CFG_OBJECT_VERIFY 0u
+#define TOS_CFG_OBJECT_VERIFY_EN 0u
 
 #define TOS_CFG_TASK_DYNAMIC_CREATE_EN  0u
 

board/NUCLEO_STM32F401RE/TOS_CONFIG/tos_config.h

@@ -7,7 +7,7 @@
 
 #define TOS_CFG_ROUND_ROBIN_EN          1u
 
-#define TOS_CFG_OBJECT_VERIFY           0u
+#define TOS_CFG_OBJECT_VERIFY_EN           0u
 
 #define TOS_CFG_TASK_DYNAMIC_CREATE_EN  0u
 

board/NUCLEO_STM32F746ZG/TOS_CONFIG/tos_config.h

@@ -7,7 +7,7 @@
 
 #define TOS_CFG_ROUND_ROBIN_EN      1u
 
-#define TOS_CFG_OBJECT_VERIFY_EN       0u
+#define TOS_CFG_OBJECT_VERIFY_EN       1u
 
 #define TOS_CFG_TASK_DYNAMIC_CREATE_EN  0u
 

board/QEMU_Spike/TOS-CONFIG/tos_config.h

@@ -7,7 +7,7 @@
 
 #define TOS_CFG_ROUND_ROBIN_EN 0u // 配置TencentOS tiny的内核是否开启时间片轮转
 
-#define TOS_CFG_OBJECT_VERIFY 0u // 配置TencentOS tiny是否校验指针合法
+#define TOS_CFG_OBJECT_VERIFY_EN 0u // 配置TencentOS tiny是否校验指针合法
 
 #define TOS_CFG_TASK_DYNAMIC_CREATE_EN  0u
 

board/Sipeed_LonganNano/TOS_CONFIG/tos_config.h

@@ -11,7 +11,7 @@
 #define TOS_CFG_ROUND_ROBIN_EN 0u
 
 // 配置TencentOS tiny是否校验指针合法
-#define TOS_CFG_OBJECT_VERIFY 0u
+#define TOS_CFG_OBJECT_VERIFY_EN 0u
 
 #define TOS_CFG_TASK_DYNAMIC_CREATE_EN  0u
 

kernel/core/include/tos_binary_heap.h

@@ -21,9 +21,7 @@
 typedef int (*k_bin_heap_cmp)(void *first, void *second);
 
 typedef struct k_binary_heap_st {
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_obj_t           knl_obj;
-#endif
 
     size_t              total;
 
@@ -71,6 +69,39 @@ __API__ k_err_t tos_bin_heap_create(k_bin_heap_t *bin_heap, void *pool, size_t i
  */
 __API__ k_err_t tos_bin_heap_destroy(k_bin_heap_t *bin_heap);
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+/**
+ * @brief Create a binary heap with a dynamic allocated pool.
+ * create a binary heap with a dynamic allocated pool.
+ *
+ * @attention None
+ *
+ * @param[in]   bin_heap    pointer to the handler of the binary heap.
+ * @param[in]   item_cnt    item count of the binary heap.
+ * @param[in]   item_size   size of each item of the binary heap.
+ * @param[in]   cmp         compare function to determine two items which is bigger or smaller.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_bin_heap_create_dyn(k_bin_heap_t *bin_heap, size_t item_cnt, size_t item_size, k_bin_heap_cmp cmp);
+
+/**
+ * @brief Destroy a binary heap with a dynamic allocated pool.
+ * destroy a binary heap with a dynamic allocated pool.
+ *
+ * @attention None
+ *
+ * @param[in]   bin_heap    pointer to the handler of the binary heap.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_bin_heap_destroy_dyn(k_bin_heap_t *bin_heap);
+
+#endif
+
 /**
  * @brief Push an item.
  * push an item into the binary heap.

kernel/core/include/tos_char_fifo.h

@@ -19,9 +19,7 @@
 #define  _TOS_CHAR_FIFO_H_
 
 typedef struct k_char_fifo_st {
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_obj_t   knl_obj;
-#endif
 
     k_ring_q_t  ring_q;
 } k_chr_fifo_t;
@@ -57,6 +55,40 @@ __API__ k_err_t tos_chr_fifo_create(k_chr_fifo_t *chr_fifo, void *buffer, size_t
  */
 __API__ k_err_t tos_chr_fifo_destroy(k_chr_fifo_t *chr_fifo);
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+/**
+ * @brief Create a character fifo with a dynamic allocated buffer.
+ * Create a character fifo with a dynamic allocated buffer.
+ *
+ * @attention the buffer is dynamic allocated(tos_mmheap_alloc)
+ *
+ * @param[in]   fifo        pointer to the handler of the fifo.
+ * @param[in]   fifo_size   size of the fifo.
+ *
+ * @return  errno
+ * @retval  #K_ERR_OBJ_PTR_NULL fifo is a NULL pointer.
+ * @retval  #K_ERR_NONE         return successfully.
+ */
+__API__ k_err_t tos_chr_fifo_create_dyn(k_chr_fifo_t *chr_fifo, size_t fifo_size);
+
+/**
+ * @brief Destroy a character fifo with a dynamic allocated buffer.
+ * Destroy a character fifo with a dynamic allocated buffer.
+ *
+ * @attention None
+ *
+ * @param[in]   fifo        pointer to the handler of the fifo.
+ *
+ * @return  errno
+ * @retval  #K_ERR_OBJ_PTR_NULL fifo is a NULL pointer.
+ * @retval  #K_ERR_OBJ_INVALID  not a valid pointer to a fifo.
+ * @retval  #K_ERR_NONE         return successfully.
+ */
+__API__ k_err_t tos_chr_fifo_destroy_dyn(k_chr_fifo_t *chr_fifo);
+
+#endif
+
 /**
  * @brief Push data into character fifo.
  * Push one single data into the character fifo.

kernel/core/include/tos_completion.h

@@ -23,6 +23,10 @@
 typedef uint16_t    completion_done_t;
 
 typedef struct k_completion_st {
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_obj_t           knl_obj;
+#endif
+
     pend_obj_t          pend_obj;
     completion_done_t   done;
 } k_completion_t;

kernel/core/include/tos_countdownlatch.h

@@ -21,6 +21,10 @@
 #if TOS_CFG_COUNTDOWNLATCH_EN > 0u
 
 typedef struct k_countdownlatch_st {
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_obj_t               knl_obj;
+#endif
+
     pend_obj_t              pend_obj;
     k_countdownlatch_cnt_t  count;
 } k_countdownlatch_t;

kernel/core/include/tos_err.h

@@ -58,6 +58,7 @@ typedef enum k_err_en {
 
     K_ERR_OBJ_PTR_NULL                          = 1100u,
     K_ERR_OBJ_INVALID,
+    K_ERR_OBJ_INVALID_ALLOC_TYPE,
 
     K_ERR_OUT_OF_MEMORY                         = 1150u,
 

kernel/core/include/tos_event.h

@@ -20,10 +20,10 @@
 
 #if TOS_CFG_EVENT_EN > 0
 
-// if we are pending an event, for any flag we expect is set is ok, this flag should be passed to tos_event_pend 
+// if we are pending an event, for any flag we expect is set is ok, this flag should be passed to tos_event_pend
 #define TOS_OPT_EVENT_PEND_ANY          (k_opt_t)0x0001
 
-// if we are pending an event, must all the flag we expect is set is ok, this flag should be passed to tos_event_pend 
+// if we are pending an event, must all the flag we expect is set is ok, this flag should be passed to tos_event_pend
 #define TOS_OPT_EVENT_PEND_ALL          (k_opt_t)0x0002
 
 // if we are pending an event, and we wanna clear the event's flag after we read, this flag should be passed to tos_event_pend
@@ -41,6 +41,10 @@ typedef enum opt_event_post_en {
 } opt_event_post_t;
 
 typedef struct k_event_st {
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_obj_t       knl_obj;
+#endif
+
     pend_obj_t      pend_obj;
     k_event_flag_t  flag;
 } k_event_t;
@@ -128,6 +132,6 @@ __API__ k_err_t tos_event_post(k_event_t *event, k_event_flag_t flag);
 __API__ k_err_t tos_event_post_keep(k_event_t *event, k_event_flag_t flag);
 
 #endif
-    
+
 #endif /* _TOS_EVENT_H_ */
 

kernel/core/include/tos_klib.h

@@ -37,6 +37,13 @@
         }   \
     } while(0)
 
+#define TOS_PTR_SANITY_CHECK_RC(ptr, return_code) \
+    do {    \
+        if (unlikely((ptr) == K_NULL)) {    \
+            return return_code;    \
+        }   \
+    } while(0)
+
 #define TOS_IN_IRQ_CHECK()    \
     do {    \
         if (unlikely(knl_is_inirq())) {   \
@@ -44,6 +51,26 @@
         }   \
     } while(0)
 
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+#define TOS_OBJ_VERIFY(obj, obj_type) \
+    do {    \
+        if (!knl_object_verify(&obj->knl_obj, obj_type)) {    \
+            return K_ERR_OBJ_INVALID;   \
+        }   \
+    } while (0)
+
+#define TOS_OBJ_VERIFY_RC(obj, obj_type, return_code) \
+    do {    \
+        if (!knl_object_verify(&obj->knl_obj, obj_type)) {    \
+            return return_code;   \
+        }   \
+    } while (0)
+
+#else
+#define TOS_OBJ_VERIFY(obj, obj_type)
+#define TOS_OBJ_VERIFY_RC(obj, obj_type, return_code)
+#endif
+
 // currently we use default microlib supplied by mdk
 #define tos_kprintf(...)         printf(__VA_ARGS__);
 

kernel/core/include/tos_mail_queue.h

@@ -21,6 +21,8 @@
 #if TOS_CFG_MAIL_QUEUE_EN > 0u
 
 typedef struct k_mail_queue_st {
+    knl_obj_t   knl_obj;
+
     pend_obj_t  pend_obj;
     k_ring_q_t  ring_q;
 } k_mail_q_t;
@@ -54,6 +56,38 @@ __API__ k_err_t tos_mail_q_create(k_mail_q_t *mail_q, void *pool, size_t mail_cn
  */
 __API__ k_err_t tos_mail_q_destroy(k_mail_q_t *mail_q);
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+/**
+ * @brief Create a mail queue with dynamic allocated pool.
+ * create a mail queue with dynamic allocated pool.
+ *
+ * @attention a MAIL is a buffer with a certain size.
+ *
+ * @param[in]   mail_q      pointer to the handler of the mail queue.
+ * @param[in]   mail_cnt    mail count of the mail queue.
+ * @param[in]   mail_size   size of each mail in the mail queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_mail_q_create_dyn(k_mail_q_t *mail_q, size_t mail_cnt, size_t mail_size);
+
+/**
+ * @brief Destroy a mail queue with dynamic allocated pool.
+ * destroy a mail queue with dynamic allocated pool.
+ *
+ * @attention None
+ *
+ * @param[in]   mail_q      pointer to the handler of the mail queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_mail_q_destroy_dyn(k_mail_q_t *mail_q);
+
+#endif
+
 /**
  * @brief Flush the mail queue.
  * flush the mail queue.

kernel/core/include/tos_message_queue.h

@@ -21,6 +21,8 @@
 #if TOS_CFG_MESSAGE_QUEUE_EN > 0u
 
 typedef struct k_message_queue_st {
+    knl_obj_t   knl_obj;
+
     pend_obj_t  pend_obj;
     k_ring_q_t  ring_q;
 } k_msg_q_t;
@@ -53,6 +55,37 @@ __API__ k_err_t tos_msg_q_create(k_msg_q_t *msg_q, void *pool, size_t msg_cnt);
  */
 __API__ k_err_t tos_msg_q_destroy(k_msg_q_t *msg_q);
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+/**
+ * @brief Create a message queue with dynamic allocated pool.
+ * create a message queue with dynamic allocated pool.
+ *
+ * @attention a MESSAGE is a "void *" pointer.
+ *
+ * @param[in]   msg_q       pointer to the handler of the message queue.
+ * @param[in]   msg_cnt     message count of the message queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_msg_q_create_dyn(k_msg_q_t *msg_q, size_t msg_cnt);
+
+/**
+ * @brief Destroy a message queue with dynamic allocated pool.
+ * destroy a message queue with dynamic allocated pool.
+ *
+ * @attention None
+ *
+ * @param[in]   msg_q       pointer to the handler of the message queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_msg_q_destroy_dyn(k_msg_q_t *msg_q);
+
+#endif
+
 /**
  * @brief Flush the message queue.
  * flush the message queue.

kernel/core/include/tos_mutex.h

@@ -21,6 +21,10 @@
 #if TOS_CFG_MUTEX_EN > 0u
 
 typedef struct k_mutex_st {
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_obj_t       knl_obj;
+#endif
+
     pend_obj_t      pend_obj;
     k_nesting_t     pend_nesting;
     k_task_t       *owner;

kernel/core/include/tos_pend.h

@@ -32,39 +32,19 @@ typedef enum pend_state_en {
     PEND_STATE_OWNER_DIE,   /**< the pend object owner task is destroyed. */
 } pend_state_t;
 
-// what we are pending
-/* actually, it's some kind of magic number, mainly for identifing whether the pend
-   is initialized, or whether user pass the correct parameter.
- */
-typedef enum pend_type_en {
-    PEND_TYPE_NONE                      = 0x0000,
-    PEND_TYPE_SEM                       = 0x1BEE,
-    PEND_TYPE_MUTEX                     = 0x2BEE,
-    PEND_TYPE_EVENT                     = 0x3BEE,
-    PEND_TYPE_MAIL_QUEUE                = 0x4BEE,
-    PEND_TYPE_MESSAGE_QUEUE             = 0x5BEE,
-    PEND_TYPE_PRIORITY_MAIL_QUEUE       = 0x6BEE,
-    PEND_TYPE_PRIORITY_MESSAGE_QUEUE    = 0x7BEE,
-    PEND_TYPE_COUNTDOWNLATCH            = 0x8BEE,
-    PEND_TYPE_COMPLETION                = 0x9BEE,
-} pend_type_t;
-
 typedef enum opt_post_en {
     OPT_POST_ONE,
     OPT_POST_ALL,
 } opt_post_t;
 
 typedef struct pend_object_st {
-    pend_type_t     type;
     k_list_t        list;
 } pend_obj_t;
 
-__KERNEL__ void     pend_object_init(pend_obj_t *object, pend_type_t type);
+__KERNEL__ void     pend_object_init(pend_obj_t *object);
 
 __KERNEL__ void     pend_object_deinit(pend_obj_t *object);
 
-__KERNEL__ int      pend_object_verify(pend_obj_t *object, pend_type_t type);
-
 __KERNEL__ int      pend_is_nopending(pend_obj_t *object);
 
 __KERNEL__ k_prio_t pend_highest_pending_prio_get(pend_obj_t *object);

kernel/core/include/tos_priority_mail_queue.h

@@ -21,6 +21,8 @@
 #if TOS_CFG_PRIORITY_MAIL_QUEUE_EN > 0u
 
 typedef struct k_priority_mail_queue_st {
+    knl_obj_t   knl_obj;
+
     pend_obj_t  pend_obj;
 
     void       *prio_q_mgr_array;
@@ -56,6 +58,35 @@ __API__ k_err_t tos_prio_mail_q_create(k_prio_mail_q_t *prio_mail_q, void *pool,
  */
 __API__ k_err_t tos_prio_mail_q_destroy(k_prio_mail_q_t *prio_mail_q);
 
+/**
+ * @brief Create a priority mail queue with dynamic allocated pool.
+ * create a priority mail queue with dynamic allocated pool.
+ *
+ * @attention a MAIL is a buffer with a certain size.
+ *
+ * @param[in]   prio_mail_q pointer to the handler of the priority mail queue.
+ * @param[in]   pool        pool buffer of the priority mail queue.
+ * @param[in]   mail_cnt    mail count of the priority mail queue.
+ * @param[in]   mail_size   size of each mail in the priority mail queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_prio_mail_q_create_dyn(k_prio_mail_q_t *prio_mail_q, size_t mail_cnt, size_t mail_size);
+
+/**
+ * @brief Destroy a priority mail queue with dynamic allocated pool.
+ * destroy a priority mail queue with dynamic allocated pool.
+ *
+ * @attention None
+ *
+ * @param[in]   prio_mail_q pointer to the handler of the priority mail queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_prio_mail_q_destroy_dyn(k_prio_mail_q_t *prio_mail_q);
+
 /**
  * @brief Flush the priority mail queue.
  * flush the priority mail queue.

kernel/core/include/tos_priority_message_queue.h

@@ -21,6 +21,8 @@
 #if TOS_CFG_PRIORITY_MESSAGE_QUEUE_EN > 0u
 
 typedef struct k_priority_message_queue_st {
+    knl_obj_t   knl_obj;
+
     pend_obj_t  pend_obj;
 
     void       *prio_q_mgr_array;
@@ -55,6 +57,34 @@ __API__ k_err_t tos_prio_msg_q_create(k_prio_msg_q_t *prio_msg_q, void *pool, si
  */
 __API__ k_err_t tos_prio_msg_q_destroy(k_prio_msg_q_t *prio_msg_q);
 
+/**
+ * @brief Create a priority message queue with dynamic allocated pool.
+ * create a priority message queue with dynamic allocated pool.
+ *
+ * @attention a MESSAGE is a "void *" pointer.
+ *
+ * @param[in]   prio_msg_q  pointer to the handler of the priority message queue.
+ * @param[in]   pool        pool buffer of the priority message queue.
+ * @param[in]   msg_cnt     message count of the priority message queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_prio_msg_q_create_dyn(k_prio_msg_q_t *prio_msg_q, size_t msg_cnt);
+
+/**
+ * @brief Destroy a priority message queue with dynamic allocated pool.
+ * destroy a priority message queue with dynamic allocated pool.
+ *
+ * @attention None
+ *
+ * @param[in]   prio_msg_q  pointer to the handler of the priority message queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_prio_msg_q_destroy_dyn(k_prio_msg_q_t *prio_msg_q);
+
 /**
  * @brief Flush the priority message queue.
  * flush the priority message queue.

kernel/core/include/tos_priority_queue.h

@@ -40,9 +40,7 @@ typedef struct prio_q_prio_manager_st {
 } prio_q_prio_mgr_t;
 
 typedef struct k_priority_queue_st {
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_obj_t           knl_obj;
-#endif
 
     prio_q_pool_mgr_t   pool_mgr;
     prio_q_prio_mgr_t   prio_mgr;
@@ -51,7 +49,8 @@ typedef struct k_priority_queue_st {
     size_t              item_size;
     size_t              item_cnt;
 
-    uint8_t            *pool;
+    uint8_t            *mgr_pool;
+    uint8_t            *data_pool;
 } k_prio_q_t;
 
 #define PRIO_Q_POOL_SLOT_INVALID    ((prio_q_slot_t)-1)
@@ -62,7 +61,7 @@ typedef struct k_priority_queue_st {
 #define PRIO_Q_PRIO_MGR_ENT_POOL_SIZE(item_cnt) \
     (item_cnt * sizeof(prio_q_prio_mgr_ent_t))
 
-#define PRIO_Q_THE_ITEM(prio_q, slot)       (void *)(&prio_q->pool[slot * prio_q->item_size])
+#define PRIO_Q_THE_ITEM(prio_q, slot)       (void *)(&prio_q->data_pool[slot * prio_q->item_size])
 
 // get the size of mgr_array to create a priority queue
 #define TOS_PRIO_Q_MGR_ARRAY_SIZE(item_cnt) \
@@ -98,6 +97,40 @@ __API__ k_err_t tos_prio_q_create(k_prio_q_t *prio_q, void *mgr_array, void *poo
  */
 __API__ k_err_t tos_prio_q_destroy(k_prio_q_t *prio_q);
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+/**
+ * @brief Create a priority queue with dynamic allocated mgr array and data pool.
+ * create a priority queue with dynamic allocated mgr array and data pool.
+ *
+ * @attention if we wanna create a priority queue, we should offer a manager array buffer of which the size can be calculated by TOS_PRIO_Q_MGR_ARRAY_SIZE.
+ *
+ * @param[in]   prio_q      pointer to the handler of the priority queue.
+ * @param[in]   mgr_array   manager array buffer of the priority queue.
+ * @param[in]   pool        pool buffer of the priority queue.
+ * @param[in]   item_cnt    item count of the priority queue.
+ * @param[in]   item_size   size of each item of the priority queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_prio_q_create_dyn(k_prio_q_t *prio_q, size_t item_cnt, size_t item_size);
+
+/**
+ * @brief Destroy a priority queue with dynamic allocated mgr array and data pool.
+ * destroy a priority queue with dynamic allocated mgr array and data pool.
+ *
+ * @attention None
+ *
+ * @param[in]   prio_q      pointer to the handler of the bpriority queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                   return successfully.
+ */
+__API__ k_err_t tos_prio_q_destroy_dyn(k_prio_q_t *prio_q);
+
+#endif
+
 /**
  * @brief Enqueue an priority queue.
  * enqueue an item into the priority queue.

kernel/core/include/tos_ring_queue.h

@@ -19,9 +19,7 @@
 #define  _TOS_RING_QUEUE_H_
 
 typedef struct k_ring_queue_st {
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_obj_t   knl_obj;
-#endif
 
     uint16_t    head;
     uint16_t    tail;
@@ -62,10 +60,46 @@ __API__ k_err_t tos_ring_q_create(k_ring_q_t *ring_q, void *pool, size_t item_cn
  * @param[in]   ring_q      pointer to the handler of the ring queue.
  *
  * @return  errcode
- * @retval  #K_ERR_NONE                   return successfully.
+ * @retval  #K_ERR_NONE                     return successfully.
+ * @retval  #K_ERR_OBJ_INVALID_ALLOC_TYPE   invalid alloc type(is dynamic allocated not static)
  */
 __API__ k_err_t tos_ring_q_destroy(k_ring_q_t *ring_q);
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+/**
+ * @brief Create a ring queue with dynamic allocated pool.
+ * create a ring queue with dynamic allocated pool.
+ *
+ * @attention pool inside is dynamic allocated.
+ *
+ * @param[in]   ring_q      pointer to the handler of the ring queue.
+ * @param[in]   item_cnt    item count of the ring queue.
+ * @param[in]   item_size   size of each item of the ring queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                 return successfully.
+ * @retval  #K_ERR_OUT_OF_MEMORY        out of memory
+ */
+__API__ k_err_t tos_ring_q_create_dyn(k_ring_q_t *ring_q, size_t item_cnt, size_t item_size);
+
+/**
+ * @brief Destroy a ring queue with a dynamic allocated pool.
+ * destroy a ring queue with a dynamic allocated pool.
+ *
+ * @attention None
+ *
+ * @param[in]   ring_q      pointer to the handler of the ring queue.
+ *
+ * @return  errcode
+ * @retval  #K_ERR_NONE                     return successfully.
+ * @retval  #K_ERR_OBJ_INVALID_ALLOC_TYPE   invalid alloc type(is static allocated not dynamic)
+ */
+__API__ k_err_t tos_ring_q_destroy_dyn(k_ring_q_t *ring_q);
+
+#endif
+
+
 /**
  * @brief Enqueue an item.
  * enqueue an item into the ring queue.

kernel/core/include/tos_sem.h

@@ -21,6 +21,10 @@
 #if TOS_CFG_SEM_EN > 0u
 
 typedef struct k_sem_st {
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_obj_t       knl_obj;
+#endif
+
     pend_obj_t      pend_obj;
     k_sem_cnt_t     count;
     k_sem_cnt_t     count_max;

kernel/core/include/tos_sys.h

@@ -26,25 +26,42 @@ typedef enum knl_state_en {
     KNL_STATE_RUNNING,
 } knl_state_t;
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
 // some kind of magic number, mainly for identifing whether the object is initialized, or whether user pass the correct parameter.
 typedef enum knl_obj_type_en {
     KNL_OBJ_TYPE_NONE                   = 0x0000,
     KNL_OBJ_TYPE_TASK                   = 0xDAD1,
-    KNL_OBJ_TYPE_TASK_DYN               = 0xDAD2,
-    KNL_OBJ_TYPE_TIMER                  = 0xDAD3,
-    KNL_OBJ_TYPE_MSG_QUEUE              = 0xDAD4,
-    KNL_OBJ_TYPE_MMBLK_POOL             = 0xDAD5,
-    KNL_OBJ_TYPE_RING_QUEUE             = 0xDAD6,
-    KNL_OBJ_TYPE_BINARY_HEAP            = 0xDAD7,
-    KNL_OBJ_TYPE_PRIORITY_QUEUE         = 0xDAD8,
-    KNL_OBJ_TYPE_CHAR_FIFO              = 0xDAD9,
+    KNL_OBJ_TYPE_TIMER                  = 0xDAD2,
+    KNL_OBJ_TYPE_MSG_QUEUE              = 0xDAD3,
+    KNL_OBJ_TYPE_MMBLK_POOL             = 0xDAD4,
+    KNL_OBJ_TYPE_RING_QUEUE             = 0xDAD5,
+    KNL_OBJ_TYPE_BINARY_HEAP            = 0xDAD6,
+    KNL_OBJ_TYPE_PRIORITY_QUEUE         = 0xDAD7,
+    KNL_OBJ_TYPE_CHAR_FIFO              = 0xDAD8,
+
+    // ipc object
+    KNL_OBJ_TYPE_SEMAPHORE              = 0x1BEE,
+    KNL_OBJ_TYPE_MUTEX                     = 0x2BEE,
+    KNL_OBJ_TYPE_EVENT                     = 0x3BEE,
+    KNL_OBJ_TYPE_MAIL_QUEUE                = 0x4BEE,
+    KNL_OBJ_TYPE_MESSAGE_QUEUE             = 0x5BEE,
+    KNL_OBJ_TYPE_PRIORITY_MAIL_QUEUE       = 0x6BEE,
+    KNL_OBJ_TYPE_PRIORITY_MESSAGE_QUEUE    = 0x7BEE,
+    KNL_OBJ_TYPE_COUNTDOWNLATCH            = 0x8BEE,
+    KNL_OBJ_TYPE_COMPLETION                = 0x9BEE,
 } knl_obj_type_t;
 
+typedef enum knl_obj_alloc_type_en {
+    KNL_OBJ_ALLOC_TYPE_NONE,
+    KNL_OBJ_ALLOC_TYPE_STATIC,
+    KNL_OBJ_ALLOC_TYPE_DYNAMIC,
+} knl_obj_alloc_type_t;
+
 typedef struct knl_object_st {
-    knl_obj_type_t type;
-} knl_obj_t;
+    knl_obj_alloc_type_t    alloc_type; /* is dynamic allocated(using tos_mmheap) or static memory? */
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_obj_type_t          type;
 #endif
+} knl_obj_t;
 
 /**
  * @brief Initialize the kernel.
@@ -149,9 +166,17 @@ __KERNEL__ k_tick_t knl_next_expires_get(void);
 __KERNEL__ void     knl_sched(void);
 
 #if TOS_CFG_OBJECT_VERIFY_EN > 0u
-__KERNEL__ int      knl_object_verify(knl_obj_t *object, knl_obj_type_t type);
-__KERNEL__ int      knl_object_init(knl_obj_t *object, knl_obj_type_t type);
-__KERNEL__ int      knl_object_deinit(knl_obj_t *object);
+__KERNEL__ int      knl_object_verify(knl_obj_t *knl_obj, knl_obj_type_t type);
+__KERNEL__ void     knl_object_init(knl_obj_t *knl_obj, knl_obj_type_t type);
+__KERNEL__ void     knl_object_deinit(knl_obj_t *knl_obj);
+#endif
+
+#if TOS_CFG_MMHEAP_EN > 0u
+__KERNEL__ void     knl_object_alloc_reset(knl_obj_t *knl_obj);
+__KERNEL__ void     knl_object_alloc_set_dynamic(knl_obj_t *knl_obj);
+__KERNEL__ void     knl_object_alloc_set_static(knl_obj_t *knl_obj);
+__KERNEL__ int      knl_object_alloc_is_dynamic(knl_obj_t *knl_obj);
+__KERNEL__ int      knl_object_alloc_is_static(knl_obj_t *knl_obj);
 #endif
 
 __KERNEL__ int      knl_is_sched_locked(void);

kernel/core/include/tos_task.h

@@ -69,9 +69,7 @@ typedef void (*k_task_walker)(k_task_t *task);
 typedef struct k_task_st {
     k_stack_t          *sp;                 /**< task stack pointer. This lady always comes first, we count on her in port_s.S for context switch. */
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_obj_t           knl_obj;            /**< just for verification, test whether current object is really a task. */
-#endif
 
     char               *name;               /**< task name */
     k_task_entry_t      entry;              /**< task entry */

kernel/core/include/tos_timer.h

@@ -48,9 +48,7 @@ typedef void (*k_timer_callback_t)(void *arg);
  * timer control block
  */
 typedef struct k_timer_st {
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_obj_t               knl_obj;    /**< just for verification, test whether current object is really a timer */
-#endif
 
     k_timer_callback_t      cb;         /**< callback when time is up */
     void                   *cb_arg;     /**< argument for callback */

kernel/core/tos_binary_heap.c

@@ -123,6 +123,9 @@ __API__ k_err_t tos_bin_heap_create(k_bin_heap_t *bin_heap, void *pool, size_t i
 #if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_object_init(&bin_heap->knl_obj, KNL_OBJ_TYPE_BINARY_HEAP);
 #endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_set_static(&bin_heap->knl_obj);
+#endif
 
     bin_heap->total     = 0;
     bin_heap->cmp       = cmp;
@@ -136,10 +139,11 @@ __API__ k_err_t tos_bin_heap_create(k_bin_heap_t *bin_heap, void *pool, size_t i
 __API__ k_err_t tos_bin_heap_destroy(k_bin_heap_t *bin_heap)
 {
     TOS_PTR_SANITY_CHECK(bin_heap);
+    TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&bin_heap->knl_obj, KNL_OBJ_TYPE_BINARY_HEAP)) {
-        return K_ERR_OBJ_INVALID;
+#if TOS_CFG_MMHEAP_EN > 0u
+    if (!knl_object_alloc_is_static(&bin_heap->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
 #endif
 
@@ -152,22 +156,77 @@ __API__ k_err_t tos_bin_heap_destroy(k_bin_heap_t *bin_heap)
 #if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_object_deinit(&bin_heap->knl_obj);
 #endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_reset(&bin_heap->knl_obj);
+#endif
 
     return K_ERR_NONE;
 }
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+__API__ k_err_t tos_bin_heap_create_dyn(k_bin_heap_t *bin_heap, size_t item_cnt, size_t item_size, k_bin_heap_cmp cmp)
+{
+    void *pool;
+
+    TOS_PTR_SANITY_CHECK(bin_heap);
+    TOS_PTR_SANITY_CHECK(cmp);
+
+    pool = tos_mmheap_alloc(item_cnt * item_size);
+    if (!pool) {
+        return K_ERR_OUT_OF_MEMORY;
+    }
+
+    bin_heap->total     = 0;
+    bin_heap->cmp       = cmp;
+    bin_heap->item_size = item_size;
+    bin_heap->item_cnt  = item_cnt;
+    bin_heap->pool      = (uint8_t *)pool;
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&bin_heap->knl_obj, KNL_OBJ_TYPE_BINARY_HEAP);
+#endif
+    knl_object_alloc_set_dynamic(&bin_heap->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+__API__ k_err_t tos_bin_heap_destroy_dyn(k_bin_heap_t *bin_heap)
+{
+    TOS_PTR_SANITY_CHECK(bin_heap);
+    TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
+
+#if TOS_CFG_MMHEAP_EN > 0u
+    if (!knl_object_alloc_is_dynamic(&bin_heap->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
+    }
+#endif
+
+    tos_mmheap_free(bin_heap->pool);
+
+    bin_heap->total     = 0;
+    bin_heap->cmp       = K_NULL;
+    bin_heap->item_size = 0;
+    bin_heap->item_cnt  = 0;
+    bin_heap->pool      = K_NULL;
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&bin_heap->knl_obj);
+#endif
+    knl_object_alloc_reset(&bin_heap->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+#endif
+
 __API__ k_err_t tos_bin_heap_push(k_bin_heap_t *bin_heap, void *item, size_t item_size)
 {
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(bin_heap);
     TOS_PTR_SANITY_CHECK(item);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&bin_heap->knl_obj, KNL_OBJ_TYPE_BINARY_HEAP)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
 
     if (item_size != bin_heap->item_size) {
         return K_ERR_BIN_HEAP_ITEM_SIZE_NOT_MATCH;
@@ -193,12 +252,7 @@ __API__ k_err_t tos_bin_heap_pop(k_bin_heap_t *bin_heap, void *item, size_t *ite
 
     TOS_PTR_SANITY_CHECK(bin_heap);
     TOS_PTR_SANITY_CHECK(item);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&bin_heap->knl_obj, KNL_OBJ_TYPE_BINARY_HEAP)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
 
     TOS_CPU_INT_DISABLE();
 
@@ -221,12 +275,7 @@ __API__ k_err_t tos_bin_heap_flush(k_bin_heap_t *bin_heap)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(bin_heap);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&bin_heap->knl_obj, KNL_OBJ_TYPE_BINARY_HEAP)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
 
     TOS_CPU_INT_DISABLE();
     bin_heap->total = 0;
@@ -240,15 +289,8 @@ __API__ int tos_bin_heap_is_empty(k_bin_heap_t *bin_heap)
     TOS_CPU_CPSR_ALLOC();
     int is_empty = 0;
 
-    if (!bin_heap) {
-        return K_FALSE;
-    }
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&bin_heap->knl_obj, KNL_OBJ_TYPE_BINARY_HEAP)) {
-        return K_FALSE;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(bin_heap, K_FALSE);
+    TOS_OBJ_VERIFY_RC(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP, K_FALSE);
 
     TOS_CPU_INT_DISABLE();
     is_empty = (bin_heap->total == 0);
@@ -262,15 +304,8 @@ __API__ int tos_bin_heap_is_full(k_bin_heap_t *bin_heap)
     TOS_CPU_CPSR_ALLOC();
     int is_full = 0;
 
-    if (!bin_heap) {
-        return K_FALSE;
-    }
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&bin_heap->knl_obj, KNL_OBJ_TYPE_BINARY_HEAP)) {
-        return K_FALSE;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(bin_heap, K_FALSE);
+    TOS_OBJ_VERIFY_RC(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP, K_FALSE);
 
     TOS_CPU_INT_DISABLE();
     is_full = (bin_heap->total == bin_heap->item_cnt);

kernel/core/tos_char_fifo.c

@@ -19,9 +19,10 @@
 
 __API__ k_err_t tos_chr_fifo_create(k_chr_fifo_t *chr_fifo, void *buffer, size_t size)
 {
+    k_err_t err;
+
     TOS_PTR_SANITY_CHECK(chr_fifo);
     TOS_PTR_SANITY_CHECK(buffer);
-    k_err_t err;
 
     err = tos_ring_q_create(&chr_fifo->ring_q, buffer, size, sizeof(uint8_t));
     if (err != K_ERR_NONE) {
@@ -31,18 +32,23 @@ __API__ k_err_t tos_chr_fifo_create(k_chr_fifo_t *chr_fifo, void *buffer, size_t
 #if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_object_init(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO);
 #endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_set_static(&chr_fifo->knl_obj);
+#endif
 
     return K_ERR_NONE;
 }
 
 __API__ k_err_t tos_chr_fifo_destroy(k_chr_fifo_t *chr_fifo)
 {
-    TOS_PTR_SANITY_CHECK(chr_fifo);
     k_err_t err;
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO)) {
-        return K_ERR_OBJ_INVALID;
+    TOS_PTR_SANITY_CHECK(chr_fifo);
+    TOS_OBJ_VERIFY(chr_fifo, KNL_OBJ_TYPE_CHAR_FIFO);
+
+#if TOS_CFG_MMHEAP_EN > 0u
+    if (!knl_object_alloc_is_static(&chr_fifo->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
 #endif
 
@@ -54,39 +60,76 @@ __API__ k_err_t tos_chr_fifo_destroy(k_chr_fifo_t *chr_fifo)
 #if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_object_deinit(&chr_fifo->knl_obj);
 #endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_reset(&chr_fifo->knl_obj);
+#endif
 
     return K_ERR_NONE;
 }
 
-__API__ k_err_t tos_chr_fifo_push(k_chr_fifo_t *chr_fifo, uint8_t data)
+#if TOS_CFG_MMHEAP_EN > 0u
+
+__API__ k_err_t tos_chr_fifo_create_dyn(k_chr_fifo_t *chr_fifo, size_t fifo_size)
 {
     k_err_t err;
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK(chr_fifo);
 
-    err = tos_ring_q_enqueue(&chr_fifo->ring_q, &data, sizeof(uint8_t));
+    err = tos_ring_q_create_dyn(&chr_fifo->ring_q, fifo_size, sizeof(uint8_t));
     if (err != K_ERR_NONE) {
         return err;
     }
 
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO);
+#endif
+    knl_object_alloc_set_dynamic(&chr_fifo->knl_obj);
+
     return K_ERR_NONE;
 }
 
+__API__ k_err_t tos_chr_fifo_destroy_dyn(k_chr_fifo_t *chr_fifo)
+{
+    k_err_t err;
+
+    TOS_PTR_SANITY_CHECK(chr_fifo);
+    TOS_OBJ_VERIFY(chr_fifo, KNL_OBJ_TYPE_CHAR_FIFO);
+
+    if (!knl_object_alloc_is_dynamic(&chr_fifo->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
+    }
+
+    err = tos_ring_q_destroy_dyn(&chr_fifo->ring_q);
+    if (err != K_ERR_NONE) {
+        return err;
+    }
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&chr_fifo->knl_obj);
+#endif
+    knl_object_alloc_reset(&chr_fifo->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+#endif
+
+__API__ k_err_t tos_chr_fifo_push(k_chr_fifo_t *chr_fifo, uint8_t data)
+{
+    TOS_PTR_SANITY_CHECK(chr_fifo);
+    TOS_OBJ_VERIFY(chr_fifo, KNL_OBJ_TYPE_CHAR_FIFO);
+
+    return tos_ring_q_enqueue(&chr_fifo->ring_q, &data, sizeof(uint8_t));
+}
+
 __API__ int tos_chr_fifo_push_stream(k_chr_fifo_t *chr_fifo, uint8_t *stream, size_t size)
 {
     TOS_CPU_CPSR_ALLOC();
     k_err_t err;
     int i = 0;
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(chr_fifo, 0);
+    TOS_OBJ_VERIFY_RC(chr_fifo, KNL_OBJ_TYPE_CHAR_FIFO, 0);
 
     TOS_CPU_INT_DISABLE();
 
@@ -105,20 +148,10 @@ __API__ int tos_chr_fifo_push_stream(k_chr_fifo_t *chr_fifo, uint8_t *stream, si
 
 __API__ k_err_t tos_chr_fifo_pop(k_chr_fifo_t *chr_fifo, uint8_t *out)
 {
-    k_err_t err;
+    TOS_PTR_SANITY_CHECK(chr_fifo);
+    TOS_OBJ_VERIFY(chr_fifo, KNL_OBJ_TYPE_CHAR_FIFO);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
-
-    err = tos_ring_q_dequeue(&chr_fifo->ring_q, (void *)out, K_NULL);
-    if (err != K_ERR_NONE) {
-        return err;
-    }
-
-    return K_ERR_NONE;
+    return tos_ring_q_dequeue(&chr_fifo->ring_q, (void *)out, K_NULL);
 }
 
 __API__ int tos_chr_fifo_pop_stream(k_chr_fifo_t *chr_fifo, uint8_t *buffer, size_t size)
@@ -127,11 +160,8 @@ __API__ int tos_chr_fifo_pop_stream(k_chr_fifo_t *chr_fifo, uint8_t *buffer, siz
     int i = 0;
     uint8_t data;
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(chr_fifo, 0);
+    TOS_OBJ_VERIFY_RC(chr_fifo, KNL_OBJ_TYPE_CHAR_FIFO, 0);
 
     TOS_CPU_INT_DISABLE();
 
@@ -149,33 +179,24 @@ __API__ int tos_chr_fifo_pop_stream(k_chr_fifo_t *chr_fifo, uint8_t *buffer, siz
 
 __API__ k_err_t tos_chr_fifo_flush(k_chr_fifo_t *chr_fifo)
 {
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK(chr_fifo);
+    TOS_OBJ_VERIFY(chr_fifo, KNL_OBJ_TYPE_CHAR_FIFO);
 
     return tos_ring_q_flush(&chr_fifo->ring_q);
 }
 
 __API__ int tos_chr_fifo_is_empty(k_chr_fifo_t *chr_fifo)
 {
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(chr_fifo, K_FALSE);
+    TOS_OBJ_VERIFY_RC(chr_fifo, KNL_OBJ_TYPE_CHAR_FIFO, K_FALSE);
 
     return tos_ring_q_is_empty(&chr_fifo->ring_q);
 }
 
 __API__ int tos_chr_fifo_is_full(k_chr_fifo_t *chr_fifo)
 {
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&chr_fifo->knl_obj, KNL_OBJ_TYPE_CHAR_FIFO)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(chr_fifo, K_FALSE);
+    TOS_OBJ_VERIFY_RC(chr_fifo, KNL_OBJ_TYPE_CHAR_FIFO, K_FALSE);
 
     return tos_ring_q_is_full(&chr_fifo->ring_q);
 }

kernel/core/tos_completion.c

@@ -23,7 +23,11 @@ __API__ k_err_t tos_completion_create(k_completion_t *completion)
 {
     TOS_PTR_SANITY_CHECK(completion);
 
-    pend_object_init(&completion->pend_obj, PEND_TYPE_COMPLETION);
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&completion->knl_obj, KNL_OBJ_TYPE_COMPLETION);
+#endif
+
+    pend_object_init(&completion->pend_obj);
     completion->done = (completion_done_t)0u;
 
     return K_ERR_NONE;
@@ -34,12 +38,7 @@ __API__ k_err_t tos_completion_destroy(k_completion_t *completion)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(completion);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&completion->pend_obj, PEND_TYPE_COMPLETION)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(completion, KNL_OBJ_TYPE_COMPLETION);
 
     TOS_CPU_INT_DISABLE();
 
@@ -49,6 +48,10 @@ __API__ k_err_t tos_completion_destroy(k_completion_t *completion)
 
     pend_object_deinit(&completion->pend_obj);
 
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&completion->knl_obj);
+#endif
+
     TOS_CPU_INT_ENABLE();
     knl_sched();
 
@@ -60,12 +63,7 @@ __API__ k_err_t tos_completion_pend_timed(k_completion_t *completion, k_tick_t t
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(completion);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&completion->pend_obj, PEND_TYPE_COMPLETION)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(completion, KNL_OBJ_TYPE_COMPLETION);
 
     TOS_CPU_INT_DISABLE();
 
@@ -107,12 +105,7 @@ __STATIC__ k_err_t completion_do_post(k_completion_t *completion, opt_post_t opt
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(completion);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&completion->pend_obj, PEND_TYPE_COMPLETION)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(completion, KNL_OBJ_TYPE_COMPLETION);
 
     TOS_CPU_INT_DISABLE();
 
@@ -151,12 +144,7 @@ __API__ k_err_t tos_completion_reset(k_completion_t *completion)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(completion);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&completion->pend_obj, PEND_TYPE_COMPLETION)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(completion, KNL_OBJ_TYPE_COMPLETION);
 
     TOS_CPU_INT_DISABLE();
     completion->done = (completion_done_t)0u;
@@ -170,13 +158,8 @@ __API__ int tos_completion_is_done(k_completion_t *completion)
     TOS_CPU_CPSR_ALLOC();
     int is_done = K_FALSE;
 
-    TOS_PTR_SANITY_CHECK(completion);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&completion->pend_obj, PEND_TYPE_COMPLETION)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(completion, K_FALSE);
+    TOS_OBJ_VERIFY_RC(completion, KNL_OBJ_TYPE_COMPLETION, K_FALSE);
 
     TOS_CPU_INT_DISABLE();
     is_done = (completion->done > (completion_done_t)0u ? K_TRUE : K_FALSE);

kernel/core/tos_countdownlatch.c

@@ -23,7 +23,11 @@ __API__ k_err_t tos_countdownlatch_create(k_countdownlatch_t *countdownlatch, k_
 {
     TOS_PTR_SANITY_CHECK(countdownlatch);
 
-    pend_object_init(&countdownlatch->pend_obj, PEND_TYPE_COUNTDOWNLATCH);
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&countdownlatch->knl_obj, KNL_OBJ_TYPE_COUNTDOWNLATCH);
+#endif
+
+    pend_object_init(&countdownlatch->pend_obj);
     countdownlatch->count = count;
 
     return K_ERR_NONE;
@@ -34,12 +38,7 @@ __API__ k_err_t tos_countdownlatch_destroy(k_countdownlatch_t *countdownlatch)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(countdownlatch);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&countdownlatch->pend_obj, PEND_TYPE_COUNTDOWNLATCH)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(countdownlatch, KNL_OBJ_TYPE_COUNTDOWNLATCH);
 
     TOS_CPU_INT_DISABLE();
 
@@ -49,6 +48,10 @@ __API__ k_err_t tos_countdownlatch_destroy(k_countdownlatch_t *countdownlatch)
 
     pend_object_deinit(&countdownlatch->pend_obj);
 
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&countdownlatch->knl_obj);
+#endif
+
     TOS_CPU_INT_ENABLE();
     knl_sched();
 
@@ -60,12 +63,7 @@ __API__ k_err_t tos_countdownlatch_pend_timed(k_countdownlatch_t *countdownlatch
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(countdownlatch);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&countdownlatch->pend_obj, PEND_TYPE_COUNTDOWNLATCH)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(countdownlatch, KNL_OBJ_TYPE_COUNTDOWNLATCH);
 
     TOS_CPU_INT_DISABLE();
 
@@ -107,12 +105,7 @@ __API__ k_err_t tos_countdownlatch_post(k_countdownlatch_t *countdownlatch)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(countdownlatch);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&countdownlatch->pend_obj, PEND_TYPE_COUNTDOWNLATCH)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(countdownlatch, KNL_OBJ_TYPE_COUNTDOWNLATCH);
 
     TOS_CPU_INT_DISABLE();
 
@@ -141,12 +134,7 @@ __API__ k_err_t tos_countdownlatch_reset(k_countdownlatch_t *countdownlatch, k_c
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(countdownlatch);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&countdownlatch->pend_obj, PEND_TYPE_COUNTDOWNLATCH)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(countdownlatch, KNL_OBJ_TYPE_COUNTDOWNLATCH);
 
     TOS_CPU_INT_DISABLE();
     countdownlatch->count = count;

kernel/core/tos_event.c

@@ -23,7 +23,11 @@ __API__ k_err_t tos_event_create(k_event_t *event, k_event_flag_t init_flag)
 {
     TOS_PTR_SANITY_CHECK(event);
 
-    pend_object_init(&event->pend_obj, PEND_TYPE_EVENT);
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&event->knl_obj, KNL_OBJ_TYPE_EVENT);
+#endif
+
+    pend_object_init(&event->pend_obj);
     event->flag = init_flag;
     return K_ERR_NONE;
 }
@@ -33,12 +37,7 @@ __API__ k_err_t tos_event_destroy(k_event_t *event)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(event);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&event->pend_obj, PEND_TYPE_EVENT)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(event, KNL_OBJ_TYPE_EVENT);
 
     TOS_CPU_INT_DISABLE();
 
@@ -49,6 +48,10 @@ __API__ k_err_t tos_event_destroy(k_event_t *event)
     pend_object_deinit(&event->pend_obj);
     event->flag = (k_event_flag_t)0u;
 
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&event->knl_obj);
+#endif
+
     TOS_CPU_INT_ENABLE();
     knl_sched();
 
@@ -77,12 +80,7 @@ __API__ k_err_t tos_event_pend(k_event_t *event, k_event_flag_t flag_expect, k_e
 
     TOS_PTR_SANITY_CHECK(event);
     TOS_PTR_SANITY_CHECK(flag_match);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&event->pend_obj, PEND_TYPE_EVENT)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(event, KNL_OBJ_TYPE_EVENT);
 
     if (!(opt_pend & TOS_OPT_EVENT_PEND_ALL) && !(opt_pend & TOS_OPT_EVENT_PEND_ANY)) {
         return K_ERR_EVENT_PEND_OPT_INVALID;
@@ -140,12 +138,7 @@ __STATIC__ k_err_t event_do_post(k_event_t *event, k_event_flag_t flag, opt_even
     k_list_t *curr, *next;
 
     TOS_PTR_SANITY_CHECK(event);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&event->pend_obj, PEND_TYPE_EVENT)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(event, KNL_OBJ_TYPE_EVENT);
 
     if (opt_post == OPT_EVENT_POST_KEP) {
         event->flag |= flag;

kernel/core/tos_mail_queue.c

@@ -24,13 +24,20 @@ __API__ k_err_t tos_mail_q_create(k_mail_q_t *mail_q, void *pool, size_t mail_cn
     TOS_PTR_SANITY_CHECK(mail_q);
     k_err_t err;
 
-    pend_object_init(&mail_q->pend_obj, PEND_TYPE_MAIL_QUEUE);
-
     err = tos_ring_q_create(&mail_q->ring_q, pool, mail_cnt, mail_size);
     if (err != K_ERR_NONE) {
         return err;
     }
 
+    pend_object_init(&mail_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&mail_q->knl_obj, KNL_OBJ_TYPE_MAIL_QUEUE);
+#endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_set_static(&mail_q->knl_obj);
+#endif
+
     return K_ERR_NONE;
 }
 
@@ -40,10 +47,11 @@ __API__ k_err_t tos_mail_q_destroy(k_mail_q_t *mail_q)
     k_err_t err;
 
     TOS_PTR_SANITY_CHECK(mail_q);
+    TOS_OBJ_VERIFY(mail_q, KNL_OBJ_TYPE_MAIL_QUEUE);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&mail_q->pend_obj, PEND_TYPE_MAIL_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
+#if TOS_CFG_MMHEAP_EN > 0u
+    if (!knl_object_alloc_is_static(&mail_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
 #endif
 
@@ -61,32 +69,88 @@ __API__ k_err_t tos_mail_q_destroy(k_mail_q_t *mail_q)
 
     pend_object_deinit(&mail_q->pend_obj);
 
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&mail_q->knl_obj);
+#endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_reset(&mail_q->knl_obj);
+#endif
+
     TOS_CPU_INT_ENABLE();
     knl_sched();
 
     return K_ERR_NONE;
 }
 
-__API__ k_err_t tos_mail_q_flush(k_mail_q_t *mail_q)
+#if TOS_CFG_MMHEAP_EN > 0u
+
+__API__ k_err_t tos_mail_q_create_dyn(k_mail_q_t *mail_q, size_t mail_cnt, size_t mail_size)
 {
+    TOS_PTR_SANITY_CHECK(mail_q);
     k_err_t err;
 
-    TOS_PTR_SANITY_CHECK(mail_q);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&mail_q->pend_obj, PEND_TYPE_MAIL_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
-
-    err = tos_ring_q_flush(&mail_q->ring_q);
+    err = tos_ring_q_create_dyn(&mail_q->ring_q, mail_cnt, mail_size);
     if (err != K_ERR_NONE) {
         return err;
     }
 
+    pend_object_init(&mail_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&mail_q->knl_obj, KNL_OBJ_TYPE_MAIL_QUEUE);
+#endif
+    knl_object_alloc_set_dynamic(&mail_q->knl_obj);
+
     return K_ERR_NONE;
 }
 
+__API__ k_err_t tos_mail_q_destroy_dyn(k_mail_q_t *mail_q)
+{
+    TOS_CPU_CPSR_ALLOC();
+    k_err_t err;
+
+    TOS_PTR_SANITY_CHECK(mail_q);
+    TOS_OBJ_VERIFY(mail_q, KNL_OBJ_TYPE_MAIL_QUEUE);
+
+    if (!knl_object_alloc_is_dynamic(&mail_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
+    }
+
+    TOS_CPU_INT_DISABLE();
+
+    err = tos_ring_q_destroy_dyn(&mail_q->ring_q);
+    if (err != K_ERR_NONE) {
+        TOS_CPU_INT_ENABLE();
+        return err;
+    }
+
+    if (!pend_is_nopending(&mail_q->pend_obj)) {
+        pend_wakeup_all(&mail_q->pend_obj, PEND_STATE_DESTROY);
+    }
+
+    pend_object_deinit(&mail_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&mail_q->knl_obj);
+#endif
+    knl_object_alloc_reset(&mail_q->knl_obj);
+
+    TOS_CPU_INT_ENABLE();
+    knl_sched();
+
+    return K_ERR_NONE;
+}
+
+#endif
+
+__API__ k_err_t tos_mail_q_flush(k_mail_q_t *mail_q)
+{
+    TOS_PTR_SANITY_CHECK(mail_q);
+    TOS_OBJ_VERIFY(mail_q, KNL_OBJ_TYPE_MAIL_QUEUE);
+
+    return tos_ring_q_flush(&mail_q->ring_q);
+}
+
 __API__ k_err_t tos_mail_q_pend(k_mail_q_t *mail_q, void *mail_buf, size_t *mail_size, k_tick_t timeout)
 {
     TOS_CPU_CPSR_ALLOC();
@@ -94,12 +158,7 @@ __API__ k_err_t tos_mail_q_pend(k_mail_q_t *mail_q, void *mail_buf, size_t *mail
 
     TOS_PTR_SANITY_CHECK(mail_q);
     TOS_PTR_SANITY_CHECK(mail_buf);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&mail_q->pend_obj, PEND_TYPE_MAIL_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(mail_q, KNL_OBJ_TYPE_MAIL_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 
@@ -151,12 +210,7 @@ __STATIC__ k_err_t mail_q_do_post(k_mail_q_t *mail_q, void *mail_buf, size_t mai
 
     TOS_PTR_SANITY_CHECK(mail_q);
     TOS_PTR_SANITY_CHECK(mail_buf);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&mail_q->pend_obj, PEND_TYPE_MAIL_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(mail_q, KNL_OBJ_TYPE_MAIL_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 

kernel/core/tos_message_queue.c

@@ -21,16 +21,25 @@
 
 __API__ k_err_t tos_msg_q_create(k_msg_q_t *msg_q, void *pool, size_t msg_cnt)
 {
-    TOS_PTR_SANITY_CHECK(msg_q);
     k_err_t err;
 
-    pend_object_init(&msg_q->pend_obj, PEND_TYPE_MESSAGE_QUEUE);
+    TOS_PTR_SANITY_CHECK(msg_q);
+    TOS_PTR_SANITY_CHECK(pool);
 
     err = tos_ring_q_create(&msg_q->ring_q, pool, msg_cnt, sizeof(void *));
     if (err != K_ERR_NONE) {
         return err;
     }
 
+    pend_object_init(&msg_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&msg_q->knl_obj, KNL_OBJ_TYPE_MESSAGE_QUEUE);
+#endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_set_static(&msg_q->knl_obj);
+#endif
+
     return K_ERR_NONE;
 }
 
@@ -40,10 +49,11 @@ __API__ k_err_t tos_msg_q_destroy(k_msg_q_t *msg_q)
     k_err_t err;
 
     TOS_PTR_SANITY_CHECK(msg_q);
+    TOS_OBJ_VERIFY(msg_q, KNL_OBJ_TYPE_MESSAGE_QUEUE);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&msg_q->pend_obj, PEND_TYPE_MESSAGE_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
+#if TOS_CFG_MMHEAP_EN > 0u
+    if (!knl_object_alloc_is_static(&msg_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
 #endif
 
@@ -61,21 +71,85 @@ __API__ k_err_t tos_msg_q_destroy(k_msg_q_t *msg_q)
 
     pend_object_deinit(&msg_q->pend_obj);
 
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&msg_q->knl_obj);
+#endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_reset(&msg_q->knl_obj);
+#endif
+
     TOS_CPU_INT_ENABLE();
     knl_sched();
 
     return K_ERR_NONE;
 }
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+__API__ k_err_t tos_msg_q_create_dyn(k_msg_q_t *msg_q, size_t msg_cnt)
+{
+    k_err_t err;
+
+    TOS_PTR_SANITY_CHECK(msg_q);
+
+    err = tos_ring_q_create_dyn(&msg_q->ring_q, msg_cnt, sizeof(void *));
+    if (err != K_ERR_NONE) {
+        return err;
+    }
+
+    pend_object_init(&msg_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&msg_q->knl_obj, KNL_OBJ_TYPE_MESSAGE_QUEUE);
+#endif
+    knl_object_alloc_set_dynamic(&msg_q->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+__API__ k_err_t tos_msg_q_destroy_dyn(k_msg_q_t *msg_q)
+{
+    TOS_CPU_CPSR_ALLOC();
+    k_err_t err;
+
+    TOS_PTR_SANITY_CHECK(msg_q);
+    TOS_OBJ_VERIFY(msg_q, KNL_OBJ_TYPE_MESSAGE_QUEUE);
+
+    if (!knl_object_alloc_is_dynamic(&msg_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
+    }
+
+    TOS_CPU_INT_DISABLE();
+
+    err = tos_ring_q_destroy_dyn(&msg_q->ring_q);
+    if (err != K_ERR_NONE) {
+        TOS_CPU_INT_ENABLE();
+        return err;
+    }
+
+    if (!pend_is_nopending(&msg_q->pend_obj)) {
+        pend_wakeup_all(&msg_q->pend_obj, PEND_STATE_DESTROY);
+    }
+
+    pend_object_deinit(&msg_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&msg_q->knl_obj);
+#endif
+    knl_object_alloc_reset(&msg_q->knl_obj);
+
+    TOS_CPU_INT_ENABLE();
+    knl_sched();
+
+    return K_ERR_NONE;
+}
+
+#endif
+
 __API__ k_err_t tos_msg_q_flush(k_msg_q_t *msg_q)
 {
     TOS_PTR_SANITY_CHECK(msg_q);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&msg_q->pend_obj, PEND_TYPE_MESSAGE_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(msg_q, KNL_OBJ_TYPE_MESSAGE_QUEUE);
 
     return tos_ring_q_flush(&msg_q->ring_q);
 }
@@ -87,12 +161,7 @@ __API__ k_err_t tos_msg_q_pend(k_msg_q_t *msg_q, void **msg_ptr, k_tick_t timeou
 
     TOS_PTR_SANITY_CHECK(msg_q);
     TOS_PTR_SANITY_CHECK(msg_ptr);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&msg_q->pend_obj, PEND_TYPE_MESSAGE_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(msg_q, KNL_OBJ_TYPE_MESSAGE_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 
@@ -140,12 +209,7 @@ __STATIC__ k_err_t msg_q_do_post(k_msg_q_t *msg_q, void *msg_ptr, opt_post_t opt
     k_list_t *curr, *next;
 
     TOS_PTR_SANITY_CHECK(msg_q);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&msg_q->pend_obj, PEND_TYPE_MESSAGE_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(msg_q, KNL_OBJ_TYPE_MESSAGE_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 

kernel/core/tos_mmblk.c

@@ -61,12 +61,7 @@ __API__ k_err_t tos_mmblk_pool_create(k_mmblk_pool_t *mbp, void *pool_start, siz
 __API__ k_err_t tos_mmblk_pool_destroy(k_mmblk_pool_t *mbp)
 {
     TOS_PTR_SANITY_CHECK(mbp);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&mbp->knl_obj, KNL_OBJ_TYPE_MMBLK_POOL)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(mbp, KNL_OBJ_TYPE_MMBLK_POOL);
 
     mbp->pool_start = K_NULL;
     mbp->free_list  = K_NULL;
@@ -86,12 +81,7 @@ __API__ k_err_t tos_mmblk_alloc(k_mmblk_pool_t *mbp, void **blk)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(mbp);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&mbp->knl_obj, KNL_OBJ_TYPE_MMBLK_POOL)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(mbp, KNL_OBJ_TYPE_MMBLK_POOL);
 
     TOS_CPU_INT_DISABLE();
     if (mbp->blk_free == 0) {
@@ -112,12 +102,7 @@ __API__ k_err_t tos_mmblk_free(k_mmblk_pool_t *mbp, void *blk)
 
     TOS_PTR_SANITY_CHECK(mbp);
     TOS_PTR_SANITY_CHECK(blk);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&mbp->knl_obj, KNL_OBJ_TYPE_MMBLK_POOL)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(mbp, KNL_OBJ_TYPE_MMBLK_POOL);
 
     TOS_CPU_INT_DISABLE();
     if (mbp->blk_free >= mbp->blk_max) {

kernel/core/tos_mutex.c

@@ -73,7 +73,11 @@ __API__ k_err_t tos_mutex_create(k_mutex_t *mutex)
 
     TOS_IN_IRQ_CHECK();
 
-    pend_object_init(&mutex->pend_obj, PEND_TYPE_MUTEX);
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&mutex->knl_obj, KNL_OBJ_TYPE_MUTEX);
+#endif
+
+    pend_object_init(&mutex->pend_obj);
     mutex->pend_nesting     = (k_nesting_t)0u;
     mutex->owner            = K_NULL;
     mutex->owner_orig_prio  = K_TASK_PRIO_INVALID;
@@ -88,12 +92,7 @@ __API__ k_err_t tos_mutex_destroy(k_mutex_t *mutex)
 
     TOS_PTR_SANITY_CHECK(mutex);
     TOS_IN_IRQ_CHECK();
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&mutex->pend_obj, PEND_TYPE_MUTEX)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(mutex, KNL_OBJ_TYPE_MUTEX);
 
     TOS_CPU_INT_DISABLE();
 
@@ -101,12 +100,16 @@ __API__ k_err_t tos_mutex_destroy(k_mutex_t *mutex)
         pend_wakeup_all(&mutex->pend_obj, PEND_STATE_DESTROY);
     }
 
-    pend_object_deinit(&mutex->pend_obj);
-
     if (mutex->owner) {
         mutex_old_owner_release(mutex);
     }
 
+    pend_object_deinit(&mutex->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&mutex->knl_obj);
+#endif
+
     TOS_CPU_INT_ENABLE();
     knl_sched();
 
@@ -119,12 +122,7 @@ __API__ k_err_t tos_mutex_pend_timed(k_mutex_t *mutex, k_tick_t timeout)
 
     TOS_PTR_SANITY_CHECK(mutex);
     TOS_IN_IRQ_CHECK();
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&mutex->pend_obj, PEND_TYPE_MUTEX)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(mutex, KNL_OBJ_TYPE_MUTEX);
 
     TOS_CPU_INT_DISABLE();
     if (mutex->pend_nesting == (k_nesting_t)0u) { // first come
@@ -180,12 +178,7 @@ __API__ k_err_t tos_mutex_post(k_mutex_t *mutex)
 
     TOS_PTR_SANITY_CHECK(mutex);
     TOS_IN_IRQ_CHECK();
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&mutex->pend_obj, PEND_TYPE_MUTEX)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(mutex, KNL_OBJ_TYPE_MUTEX);
 
     TOS_CPU_INT_DISABLE();
     if (!knl_is_self(mutex->owner)) {

kernel/core/tos_pend.c

@@ -61,15 +61,13 @@ __KERNEL__ void pend_list_remove(k_task_t *task)
     task_state_reset_pending(task);
 }
 
-__KERNEL__ void pend_object_init(pend_obj_t *object, pend_type_t type)
+__KERNEL__ void pend_object_init(pend_obj_t *object)
 {
-    object->type = type;
     tos_list_init(&object->list);
 }
 
 __KERNEL__ void pend_object_deinit(pend_obj_t *object)
 {
-    object->type = PEND_TYPE_NONE;
     tos_list_init(&object->list);
 }
 
@@ -86,11 +84,6 @@ __KERNEL__ void pend_list_adjust(k_task_t *task)
     pend_list_add(task, task->pending_obj);
 }
 
-__KERNEL__ int pend_object_verify(pend_obj_t *object, pend_type_t type)
-{
-    return object->type == type;
-}
-
 __KERNEL__ k_err_t pend_state2errno(pend_state_t state)
 {
     if (state == PEND_STATE_POST) {

kernel/core/tos_priority_mail_queue.c

@@ -37,7 +37,12 @@ __API__ k_err_t tos_prio_mail_q_create(k_prio_mail_q_t *prio_mail_q, void *pool,
     }
 
     prio_mail_q->prio_q_mgr_array = prio_q_mgr_array;
-    pend_object_init(&prio_mail_q->pend_obj, PEND_TYPE_PRIORITY_MAIL_QUEUE);
+    pend_object_init(&prio_mail_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&prio_mail_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_MAIL_QUEUE);
+#endif
+    knl_object_alloc_set_static(&prio_mail_q->knl_obj);
 
     return K_ERR_NONE;
 }
@@ -48,12 +53,11 @@ __API__ k_err_t tos_prio_mail_q_destroy(k_prio_mail_q_t *prio_mail_q)
     k_err_t err;
 
     TOS_PTR_SANITY_CHECK(prio_mail_q);
+    TOS_OBJ_VERIFY(prio_mail_q, KNL_OBJ_TYPE_PRIORITY_MAIL_QUEUE);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&prio_mail_q->pend_obj, PEND_TYPE_PRIORITY_MAIL_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
+    if (!knl_object_alloc_is_static(&prio_mail_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
-#endif
 
     TOS_CPU_INT_DISABLE();
 
@@ -67,10 +71,73 @@ __API__ k_err_t tos_prio_mail_q_destroy(k_prio_mail_q_t *prio_mail_q)
         pend_wakeup_all(&prio_mail_q->pend_obj, PEND_STATE_DESTROY);
     }
 
-    pend_object_deinit(&prio_mail_q->pend_obj);
     tos_mmheap_free(prio_mail_q->prio_q_mgr_array);
     prio_mail_q->prio_q_mgr_array = K_NULL;
 
+    pend_object_deinit(&prio_mail_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&prio_mail_q->knl_obj);
+#endif
+    knl_object_alloc_reset(&prio_mail_q->knl_obj);
+
+    TOS_CPU_INT_ENABLE();
+    knl_sched();
+
+    return K_ERR_NONE;
+}
+
+__API__ k_err_t tos_prio_mail_q_create_dyn(k_prio_mail_q_t *prio_mail_q, size_t mail_cnt, size_t mail_size)
+{
+    TOS_PTR_SANITY_CHECK(prio_mail_q);
+    k_err_t err;
+
+    err = tos_prio_q_create_dyn(&prio_mail_q->prio_q, mail_cnt, mail_size);
+    if (err != K_ERR_NONE) {
+        return err;
+    }
+
+    pend_object_init(&prio_mail_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&prio_mail_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_MAIL_QUEUE);
+#endif
+    knl_object_alloc_set_dynamic(&prio_mail_q->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+__API__ k_err_t tos_prio_mail_q_destroy_dyn(k_prio_mail_q_t *prio_mail_q)
+{
+    TOS_CPU_CPSR_ALLOC();
+    k_err_t err;
+
+    TOS_PTR_SANITY_CHECK(prio_mail_q);
+    TOS_OBJ_VERIFY(prio_mail_q, KNL_OBJ_TYPE_PRIORITY_MAIL_QUEUE);
+
+    if (!knl_object_alloc_is_dynamic(&prio_mail_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
+    }
+
+    TOS_CPU_INT_DISABLE();
+
+    err = tos_prio_q_destroy_dyn(&prio_mail_q->prio_q);
+    if (err != K_ERR_NONE) {
+        TOS_CPU_INT_ENABLE();
+        return err;
+    }
+
+    if (!pend_is_nopending(&prio_mail_q->pend_obj)) {
+        pend_wakeup_all(&prio_mail_q->pend_obj, PEND_STATE_DESTROY);
+    }
+
+    pend_object_deinit(&prio_mail_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&prio_mail_q->knl_obj);
+#endif
+    knl_object_alloc_reset(&prio_mail_q->knl_obj);
+
     TOS_CPU_INT_ENABLE();
     knl_sched();
 
@@ -80,12 +147,7 @@ __API__ k_err_t tos_prio_mail_q_destroy(k_prio_mail_q_t *prio_mail_q)
 __API__ k_err_t tos_prio_mail_q_flush(k_prio_mail_q_t *prio_mail_q)
 {
     TOS_PTR_SANITY_CHECK(prio_mail_q);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&prio_mail_q->pend_obj, PEND_TYPE_PRIORITY_MAIL_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(prio_mail_q, KNL_OBJ_TYPE_PRIORITY_MAIL_QUEUE);
 
     return tos_prio_q_flush(&prio_mail_q->prio_q);
 }
@@ -97,12 +159,7 @@ __API__ k_err_t tos_prio_mail_q_pend(k_prio_mail_q_t *prio_mail_q, void *mail_bu
 
     TOS_PTR_SANITY_CHECK(prio_mail_q);
     TOS_PTR_SANITY_CHECK(mail_buf);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&prio_mail_q->pend_obj, PEND_TYPE_PRIORITY_MAIL_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(prio_mail_q, KNL_OBJ_TYPE_PRIORITY_MAIL_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 
@@ -154,12 +211,7 @@ __STATIC__ k_err_t prio_mail_q_do_post(k_prio_mail_q_t *prio_mail_q, void *mail_
 
     TOS_PTR_SANITY_CHECK(prio_mail_q);
     TOS_PTR_SANITY_CHECK(mail_buf);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&prio_mail_q->pend_obj, PEND_TYPE_PRIORITY_MAIL_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(prio_mail_q, KNL_OBJ_TYPE_PRIORITY_MAIL_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 

kernel/core/tos_priority_message_queue.c

@@ -37,7 +37,12 @@ __API__ k_err_t tos_prio_msg_q_create(k_prio_msg_q_t *prio_msg_q, void *pool, si
     }
 
     prio_msg_q->prio_q_mgr_array = prio_q_mgr_array;
-    pend_object_init(&prio_msg_q->pend_obj, PEND_TYPE_PRIORITY_MESSAGE_QUEUE);
+    pend_object_init(&prio_msg_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&prio_msg_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_MESSAGE_QUEUE);
+#endif
+    knl_object_alloc_set_static(&prio_msg_q->knl_obj);
 
     return K_ERR_NONE;
 }
@@ -48,12 +53,11 @@ __API__ k_err_t tos_prio_msg_q_destroy(k_prio_msg_q_t *prio_msg_q)
     k_err_t err;
 
     TOS_PTR_SANITY_CHECK(prio_msg_q);
+    TOS_OBJ_VERIFY(prio_msg_q, KNL_OBJ_TYPE_PRIORITY_MESSAGE_QUEUE);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&prio_msg_q->pend_obj, PEND_TYPE_PRIORITY_MESSAGE_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
+    if (!knl_object_alloc_is_static(&prio_msg_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
-#endif
 
     TOS_CPU_INT_DISABLE();
 
@@ -67,10 +71,76 @@ __API__ k_err_t tos_prio_msg_q_destroy(k_prio_msg_q_t *prio_msg_q)
         pend_wakeup_all(&prio_msg_q->pend_obj, PEND_STATE_DESTROY);
     }
 
-    pend_object_deinit(&prio_msg_q->pend_obj);
     tos_mmheap_free(prio_msg_q->prio_q_mgr_array);
     prio_msg_q->prio_q_mgr_array = K_NULL;
 
+    pend_object_deinit(&prio_msg_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&prio_msg_q->knl_obj);
+#endif
+    knl_object_alloc_reset(&prio_msg_q->knl_obj);
+
+    TOS_CPU_INT_ENABLE();
+    knl_sched();
+
+    return K_ERR_NONE;
+}
+
+__API__ k_err_t tos_prio_msg_q_create_dyn(k_prio_msg_q_t *prio_msg_q, size_t msg_cnt)
+{
+    TOS_PTR_SANITY_CHECK(prio_msg_q);
+    k_err_t err;
+
+    err = tos_prio_q_create_dyn(&prio_msg_q->prio_q, msg_cnt, sizeof(void *));
+    if (err != K_ERR_NONE) {
+        return err;
+    }
+
+    pend_object_init(&prio_msg_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&prio_msg_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_MESSAGE_QUEUE);
+#endif
+    knl_object_alloc_set_dynamic(&prio_msg_q->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+__API__ k_err_t tos_prio_msg_q_destroy_dyn(k_prio_msg_q_t *prio_msg_q)
+{
+    TOS_CPU_CPSR_ALLOC();
+    k_err_t err;
+
+    TOS_PTR_SANITY_CHECK(prio_msg_q);
+    TOS_OBJ_VERIFY(prio_msg_q, KNL_OBJ_TYPE_PRIORITY_MESSAGE_QUEUE);
+
+    if (!knl_object_alloc_is_dynamic(&prio_msg_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
+    }
+
+    TOS_CPU_INT_DISABLE();
+
+    err = tos_prio_q_destroy_dyn(&prio_msg_q->prio_q);
+    if (err != K_ERR_NONE) {
+        TOS_CPU_INT_ENABLE();
+        return err;
+    }
+
+    if (!pend_is_nopending(&prio_msg_q->pend_obj)) {
+        pend_wakeup_all(&prio_msg_q->pend_obj, PEND_STATE_DESTROY);
+    }
+
+    tos_mmheap_free(prio_msg_q->prio_q_mgr_array);
+    prio_msg_q->prio_q_mgr_array = K_NULL;
+
+    pend_object_deinit(&prio_msg_q->pend_obj);
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&prio_msg_q->knl_obj);
+#endif
+    knl_object_alloc_reset(&prio_msg_q->knl_obj);
+
     TOS_CPU_INT_ENABLE();
     knl_sched();
 
@@ -80,12 +150,7 @@ __API__ k_err_t tos_prio_msg_q_destroy(k_prio_msg_q_t *prio_msg_q)
 __API__ k_err_t tos_prio_msg_q_flush(k_prio_msg_q_t *prio_msg_q)
 {
     TOS_PTR_SANITY_CHECK(prio_msg_q);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&prio_msg_q->pend_obj, PEND_TYPE_PRIORITY_MESSAGE_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(prio_msg_q, KNL_OBJ_TYPE_PRIORITY_MESSAGE_QUEUE);
 
     return tos_prio_q_flush(&prio_msg_q->prio_q);
 }
@@ -97,12 +162,7 @@ __API__ k_err_t tos_prio_msg_q_pend(k_prio_msg_q_t *prio_msg_q, void **msg_ptr,
 
     TOS_PTR_SANITY_CHECK(prio_msg_q);
     TOS_PTR_SANITY_CHECK(msg_ptr);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&prio_msg_q->pend_obj, PEND_TYPE_PRIORITY_MESSAGE_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(prio_msg_q, KNL_OBJ_TYPE_PRIORITY_MESSAGE_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 
@@ -150,12 +210,7 @@ __STATIC__ k_err_t prio_msg_q_do_post(k_prio_msg_q_t *prio_msg_q, void *msg_ptr,
     k_list_t *curr, *next;
 
     TOS_PTR_SANITY_CHECK(prio_msg_q);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&prio_msg_q->pend_obj, PEND_TYPE_PRIORITY_MESSAGE_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(prio_msg_q, KNL_OBJ_TYPE_PRIORITY_MESSAGE_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 

kernel/core/tos_priority_queue.c

@@ -167,10 +167,6 @@ __API__ k_err_t tos_prio_q_create(k_prio_q_t *prio_q, void *mgr_array, void *poo
     TOS_PTR_SANITY_CHECK(mgr_array);
     TOS_PTR_SANITY_CHECK(pool);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    knl_object_init(&prio_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_QUEUE);
-#endif
-
     pool_mgr_ent_array  = (prio_q_pool_mgr_ent_t *)mgr_array;
     prio_mgr_ent_pool   = (prio_q_prio_mgr_ent_t *)((uint8_t *)mgr_array + PRIO_Q_POOL_MGR_ENT_ARRAY_SIZE(item_cnt));
 
@@ -180,7 +176,15 @@ __API__ k_err_t tos_prio_q_create(k_prio_q_t *prio_q, void *mgr_array, void *poo
     prio_q->total       = 0;
     prio_q->item_size   = item_size;
     prio_q->item_cnt    = item_cnt;
-    prio_q->pool        = (uint8_t *)pool;
+    prio_q->mgr_pool    = (uint8_t *)mgr_array;
+    prio_q->data_pool   = (uint8_t *)pool;
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&prio_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_QUEUE);
+#endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_set_static(&prio_q->knl_obj);
+#endif
 
     return K_ERR_NONE;
 }
@@ -188,10 +192,11 @@ __API__ k_err_t tos_prio_q_create(k_prio_q_t *prio_q, void *mgr_array, void *poo
 __API__ k_err_t tos_prio_q_destroy(k_prio_q_t *prio_q)
 {
     TOS_PTR_SANITY_CHECK(prio_q);
+    TOS_OBJ_VERIFY(prio_q, KNL_OBJ_TYPE_PRIORITY_QUEUE);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&prio_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
+#if TOS_CFG_MMHEAP_EN > 0u
+    if (!knl_object_alloc_is_static(&prio_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
 #endif
 
@@ -201,15 +206,83 @@ __API__ k_err_t tos_prio_q_destroy(k_prio_q_t *prio_q)
     prio_q->total       = 0;
     prio_q->item_size   = 0;
     prio_q->item_cnt    = 0;
-    prio_q->pool        = K_NULL;
+    prio_q->mgr_pool    = K_NULL;
+    prio_q->data_pool   = K_NULL;
 
 #if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_object_deinit(&prio_q->knl_obj);
 #endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_reset(&prio_q->knl_obj);
+#endif
 
     return K_ERR_NONE;
 }
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+__API__ k_err_t tos_prio_q_create_dyn(k_prio_q_t *prio_q, size_t item_cnt, size_t item_size)
+{
+    k_err_t err;
+    void *mgr_pool, *data_pool;
+
+    TOS_PTR_SANITY_CHECK(prio_q);
+
+    mgr_pool = tos_mmheap_alloc(TOS_PRIO_Q_MGR_ARRAY_SIZE(item_cnt));
+    if (!mgr_pool) {
+        return K_ERR_OUT_OF_MEMORY;
+    }
+
+    data_pool = tos_mmheap_alloc(item_cnt * item_size);
+    if (!data_pool) {
+        tos_mmheap_free(mgr_pool);
+        return K_ERR_OUT_OF_MEMORY;
+    }
+
+    err = tos_prio_q_create(prio_q, mgr_pool, data_pool, item_cnt, item_size);
+    if (err != K_ERR_NONE) {
+        tos_mmheap_free(data_pool);
+        tos_mmheap_free(mgr_pool);
+    }
+
+    knl_object_alloc_set_dynamic(&prio_q->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+__API__ k_err_t tos_prio_q_destroy_dyn(k_prio_q_t *prio_q)
+{
+    TOS_PTR_SANITY_CHECK(prio_q);
+    TOS_OBJ_VERIFY(prio_q, KNL_OBJ_TYPE_PRIORITY_QUEUE);
+
+#if TOS_CFG_MMHEAP_EN > 0u
+    if (!knl_object_alloc_is_dynamic(&prio_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
+    }
+#endif
+
+    prio_q_pool_mgr_deinit(&prio_q->pool_mgr);
+    prio_q_prio_mgr_deinit(&prio_q->prio_mgr);
+
+    tos_mmheap_free(prio_q->mgr_pool);
+    tos_mmheap_free(prio_q->data_pool);
+
+    prio_q->total       = 0;
+    prio_q->item_size   = 0;
+    prio_q->item_cnt    = 0;
+    prio_q->mgr_pool    = K_NULL;
+    prio_q->data_pool   = K_NULL;
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&prio_q->knl_obj);
+#endif
+    knl_object_alloc_reset(&prio_q->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+#endif
+
 __STATIC__ void prio_q_do_enqueue(k_prio_q_t *prio_q, void *item, prio_q_slot_t slot, k_prio_t prio)
 {
     prio_q_item_copy_from(prio_q, item, slot);
@@ -224,12 +297,7 @@ __API__ k_err_t tos_prio_q_enqueue(k_prio_q_t *prio_q, void *item, size_t item_s
 
     TOS_PTR_SANITY_CHECK(prio_q);
     TOS_PTR_SANITY_CHECK(item);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&prio_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(prio_q, KNL_OBJ_TYPE_PRIORITY_QUEUE);
 
     if (item_size != prio_q->item_size) {
         return K_ERR_PRIO_Q_ITEM_SIZE_NOT_MATCH;
@@ -263,12 +331,7 @@ __API__ k_err_t tos_prio_q_dequeue(k_prio_q_t *prio_q, void *item, size_t *item_
 
     TOS_PTR_SANITY_CHECK(prio_q);
     TOS_PTR_SANITY_CHECK(item);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&prio_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(prio_q, KNL_OBJ_TYPE_PRIORITY_QUEUE);
 
     if (tos_prio_q_is_empty(prio_q)) {
         return K_ERR_PRIO_Q_EMPTY;
@@ -288,12 +351,7 @@ __API__ k_err_t tos_prio_q_flush(k_prio_q_t *prio_q)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(prio_q);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&prio_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(prio_q, KNL_OBJ_TYPE_PRIORITY_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 
@@ -310,15 +368,8 @@ __API__ int tos_prio_q_is_empty(k_prio_q_t *prio_q)
     TOS_CPU_CPSR_ALLOC();
     int is_empty = K_FALSE;
 
-    if (!prio_q) {
-        return K_FALSE;
-    }
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&prio_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_QUEUE)) {
-        return K_FALSE;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(prio_q, K_FALSE);
+    TOS_OBJ_VERIFY_RC(prio_q, KNL_OBJ_TYPE_PRIORITY_QUEUE, K_FALSE);
 
     TOS_CPU_INT_DISABLE();
     is_empty = (prio_q->total == 0);
@@ -332,15 +383,8 @@ __API__ int tos_prio_q_is_full(k_prio_q_t *prio_q)
     TOS_CPU_CPSR_ALLOC();
     int is_full = K_FALSE;
 
-    if (!prio_q) {
-        return K_FALSE;
-    }
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&prio_q->knl_obj, KNL_OBJ_TYPE_PRIORITY_QUEUE)) {
-        return K_FALSE;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(prio_q, K_FALSE);
+    TOS_OBJ_VERIFY_RC(prio_q, KNL_OBJ_TYPE_PRIORITY_QUEUE, K_FALSE);
 
     TOS_CPU_INT_DISABLE();
     is_full = (prio_q->total == prio_q->item_cnt);

kernel/core/tos_ring_queue.c

@@ -47,33 +47,39 @@ __STATIC_INLINE__ void ring_q_item_decrease(k_ring_q_t *ring_q)
     TOS_PTR_SANITY_CHECK(ring_q);
     TOS_PTR_SANITY_CHECK(pool);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    knl_object_init(&ring_q->knl_obj, KNL_OBJ_TYPE_RING_QUEUE);
-#endif
-
     ring_q->head        = 0u;
     ring_q->tail        = 0u;
     ring_q->total       = 0;
+
     ring_q->pool        = (uint8_t *)pool;
     ring_q->item_size   = item_size;
     ring_q->item_cnt    = item_cnt;
 
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&ring_q->knl_obj, KNL_OBJ_TYPE_RING_QUEUE);
+#endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_set_static(&ring_q->knl_obj);
+#endif
+
     return K_ERR_NONE;
 }
 
 __API__ k_err_t tos_ring_q_destroy(k_ring_q_t *ring_q)
 {
     TOS_PTR_SANITY_CHECK(ring_q);
+    TOS_OBJ_VERIFY(ring_q, KNL_OBJ_TYPE_RING_QUEUE);
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&ring_q->knl_obj, KNL_OBJ_TYPE_RING_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
+#if TOS_CFG_MMHEAP_EN > 0u
+    if (!knl_object_alloc_is_static(&ring_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
 #endif
 
     ring_q->head        = 0u;
     ring_q->tail        = 0u;
     ring_q->total       = 0;
+
     ring_q->pool        = K_NULL;
     ring_q->item_size   = 0u;
     ring_q->item_cnt    = 0u;
@@ -81,22 +87,78 @@ __API__ k_err_t tos_ring_q_destroy(k_ring_q_t *ring_q)
 #if TOS_CFG_OBJECT_VERIFY_EN > 0u
     knl_object_deinit(&ring_q->knl_obj);
 #endif
+#if TOS_CFG_MMHEAP_EN > 0u
+    knl_object_alloc_reset(&ring_q->knl_obj);
+#endif
 
     return K_ERR_NONE;
 }
 
+#if TOS_CFG_MMHEAP_EN > 0u
+
+ __API__ k_err_t tos_ring_q_create_dyn(k_ring_q_t *ring_q, size_t item_cnt, size_t item_size)
+{
+    void *pool;
+
+    TOS_PTR_SANITY_CHECK(ring_q);
+
+    pool = tos_mmheap_alloc(item_cnt * item_size);
+    if (!pool) {
+        return K_ERR_OUT_OF_MEMORY;
+    }
+
+    ring_q->head        = 0u;
+    ring_q->tail        = 0u;
+    ring_q->total       = 0;
+
+    ring_q->pool        = (uint8_t *)pool;
+    ring_q->item_size   = item_size;
+    ring_q->item_cnt    = item_cnt;
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&ring_q->knl_obj, KNL_OBJ_TYPE_RING_QUEUE);
+#endif
+    knl_object_alloc_set_dynamic(&ring_q->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+__API__ k_err_t tos_ring_q_destroy_dyn(k_ring_q_t *ring_q)
+{
+    TOS_PTR_SANITY_CHECK(ring_q);
+    TOS_OBJ_VERIFY(ring_q, KNL_OBJ_TYPE_RING_QUEUE);
+
+    if (!knl_object_alloc_is_dynamic(&ring_q->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
+    }
+
+    tos_mmheap_free(ring_q->pool);
+
+    ring_q->head        = 0u;
+    ring_q->tail        = 0u;
+    ring_q->total       = 0;
+
+    ring_q->pool        = K_NULL;
+    ring_q->item_size   = 0u;
+    ring_q->item_cnt    = 0u;
+
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&ring_q->knl_obj);
+#endif
+    knl_object_alloc_reset(&ring_q->knl_obj);
+
+    return K_ERR_NONE;
+}
+
+#endif
+
 __API__ k_err_t tos_ring_q_enqueue(k_ring_q_t *ring_q, void *item, size_t item_size)
 {
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(ring_q);
     TOS_PTR_SANITY_CHECK(item);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&ring_q->knl_obj, KNL_OBJ_TYPE_RING_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(ring_q, KNL_OBJ_TYPE_RING_QUEUE);
 
     if (item_size != ring_q->item_size) {
         return K_ERR_RING_Q_ITEM_SIZE_NOT_MATCH;
@@ -122,12 +184,7 @@ __API__ k_err_t tos_ring_q_dequeue(k_ring_q_t *ring_q, void *item, size_t *item_
 
     TOS_PTR_SANITY_CHECK(ring_q);
     TOS_PTR_SANITY_CHECK(item);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&ring_q->knl_obj, KNL_OBJ_TYPE_RING_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(ring_q, KNL_OBJ_TYPE_RING_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 
@@ -149,12 +206,7 @@ __API__ k_err_t tos_ring_q_flush(k_ring_q_t *ring_q)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(ring_q);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&ring_q->knl_obj, KNL_OBJ_TYPE_RING_QUEUE)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(ring_q, KNL_OBJ_TYPE_RING_QUEUE);
 
     TOS_CPU_INT_DISABLE();
 
@@ -172,15 +224,8 @@ __API__ int tos_ring_q_is_empty(k_ring_q_t *ring_q)
     TOS_CPU_CPSR_ALLOC();
     int is_empty = 0;
 
-    if (!ring_q) {
-        return K_FALSE;
-    }
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&ring_q->knl_obj, KNL_OBJ_TYPE_RING_QUEUE)) {
-        return K_FALSE;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(ring_q, K_FALSE);
+    TOS_OBJ_VERIFY_RC(ring_q, KNL_OBJ_TYPE_RING_QUEUE, K_FALSE);
 
     TOS_CPU_INT_DISABLE();
     is_empty = (ring_q->total == 0);
@@ -194,15 +239,8 @@ __API__ int tos_ring_q_is_full(k_ring_q_t *ring_q)
     TOS_CPU_CPSR_ALLOC();
     int is_full = 0;
 
-    if (!ring_q) {
-        return K_FALSE;
-    }
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&ring_q->knl_obj, KNL_OBJ_TYPE_RING_QUEUE)) {
-        return K_FALSE;
-    }
-#endif
+    TOS_PTR_SANITY_CHECK_RC(ring_q, K_FALSE);
+    TOS_OBJ_VERIFY_RC(ring_q, KNL_OBJ_TYPE_RING_QUEUE, K_FALSE);
 
     TOS_CPU_INT_DISABLE();
     is_full = (ring_q->total == ring_q->item_cnt);

kernel/core/tos_sem.c

@@ -23,7 +23,11 @@ __API__ k_err_t tos_sem_create_max(k_sem_t *sem, k_sem_cnt_t init_count, k_sem_c
 {
     TOS_PTR_SANITY_CHECK(sem);
 
-    pend_object_init(&sem->pend_obj, PEND_TYPE_SEM);
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_init(&sem->knl_obj, KNL_OBJ_TYPE_SEMAPHORE);
+#endif
+
+    pend_object_init(&sem->pend_obj);
     sem->count      = init_count;
     sem->count_max  = max_count;
 
@@ -40,12 +44,7 @@ __API__ k_err_t tos_sem_destroy(k_sem_t *sem)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(sem);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&sem->pend_obj, PEND_TYPE_SEM)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(sem, KNL_OBJ_TYPE_SEMAPHORE);
 
     TOS_CPU_INT_DISABLE();
 
@@ -55,6 +54,10 @@ __API__ k_err_t tos_sem_destroy(k_sem_t *sem)
 
     pend_object_deinit(&sem->pend_obj);
 
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    knl_object_deinit(&sem->knl_obj);
+#endif
+
     TOS_CPU_INT_ENABLE();
     knl_sched();
 
@@ -66,12 +69,7 @@ __STATIC__ k_err_t sem_do_post(k_sem_t *sem, opt_post_t opt)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(sem);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&sem->pend_obj, PEND_TYPE_SEM)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(sem, KNL_OBJ_TYPE_SEMAPHORE);
 
     TOS_CPU_INT_DISABLE();
 
@@ -109,12 +107,7 @@ __API__ k_err_t tos_sem_pend(k_sem_t *sem, k_tick_t timeout)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(sem);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!pend_object_verify(&sem->pend_obj, PEND_TYPE_SEM)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(sem, KNL_OBJ_TYPE_SEMAPHORE);
 
     TOS_CPU_INT_DISABLE();
 

kernel/core/tos_sys.c

@@ -198,22 +198,52 @@ __KERNEL__ k_tick_t knl_next_expires_get(void)
 
 #endif
 
-
 #if TOS_CFG_OBJECT_VERIFY_EN > 0u
-__KERNEL__ int knl_object_verify(knl_obj_t *object, knl_obj_type_t type)
+
+__KERNEL__ int knl_object_verify(knl_obj_t *knl_obj, knl_obj_type_t type)
 {
-    return object->type == type;
+    return knl_obj->type == type;
 }
 
-__KERNEL__ int knl_object_init(knl_obj_t *object, knl_obj_type_t type)
+__KERNEL__ void knl_object_init(knl_obj_t *knl_obj, knl_obj_type_t type)
 {
-    return object->type = type;
+    knl_obj->type = type;
 }
 
-__KERNEL__ int knl_object_deinit(knl_obj_t *object)
+__KERNEL__ void knl_object_deinit(knl_obj_t *knl_obj)
 {
-    return object->type = KNL_OBJ_TYPE_NONE;
+    knl_obj->type = KNL_OBJ_TYPE_NONE;
 }
+
+#endif
+
+#if TOS_CFG_MMHEAP_EN > 0u
+
+__KERNEL__ void knl_object_alloc_reset(knl_obj_t *knl_obj)
+{
+    knl_obj->alloc_type = KNL_OBJ_ALLOC_TYPE_NONE;
+}
+
+__KERNEL__ void knl_object_alloc_set_dynamic(knl_obj_t *knl_obj)
+{
+    knl_obj->alloc_type = KNL_OBJ_ALLOC_TYPE_DYNAMIC;
+}
+
+__KERNEL__ void knl_object_alloc_set_static(knl_obj_t *knl_obj)
+{
+    knl_obj->alloc_type = KNL_OBJ_ALLOC_TYPE_STATIC;
+}
+
+__KERNEL__ int knl_object_alloc_is_dynamic(knl_obj_t *knl_obj)
+{
+    return knl_obj->alloc_type == KNL_OBJ_ALLOC_TYPE_DYNAMIC;
+}
+
+__KERNEL__ int knl_object_alloc_is_static(knl_obj_t *knl_obj)
+{
+    return knl_obj->alloc_type == KNL_OBJ_ALLOC_TYPE_STATIC;
+}
+
 #endif
 
 __KERNEL__ void knl_sched(void)

kernel/core/tos_task.c

@@ -24,6 +24,8 @@ __STATIC_INLINE__ void task_reset(k_task_t *task)
 #endif
 
 #if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
+    knl_object_alloc_reset(&task->knl_obj);
+
     tos_list_init(&task->dead_list);
 #endif
     tos_list_init(&task->stat_list);
@@ -117,6 +119,10 @@ __API__ k_err_t tos_task_create(k_task_t *task,
     knl_object_init(&task->knl_obj, KNL_OBJ_TYPE_TASK);
 #endif
 
+#if TOS_CFG_TASK_DYNAMIC_CREATE_EN > 0u
+    knl_object_alloc_set_static(&task->knl_obj);
+#endif
+
     task->sp        = cpu_task_stk_init((void *)entry, arg, (void *)task_exit, stk_base, stk_size);
     task->entry     = entry;
     task->arg       = arg;
@@ -193,13 +199,15 @@ __API__ k_err_t tos_task_destroy(k_task_t *task)
         task = k_curr_task;
     }
 
+    TOS_OBJ_VERIFY(task, KNL_OBJ_TYPE_TASK);
+
     if (knl_is_self(task) && knl_is_sched_locked()) {
         return K_ERR_SCHED_LOCKED;
     }
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK)) {
-        return K_ERR_OBJ_INVALID;
+#if TOS_CFG_TASK_DYNAMIC_CREATE_EN
+    if (!knl_object_alloc_is_static(&task->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
 #endif
 
@@ -271,16 +279,14 @@ __API__ k_err_t tos_task_create_dyn(k_task_t **task,
         return K_ERR_TASK_OUT_OF_MEMORY;
     }
 
+    the_task->stk_base = stk_base;
     err = tos_task_create(the_task, name, entry, arg, prio, stk_base, stk_size, timeslice);
     if (err != K_ERR_NONE) {
-        tos_mmheap_free(stk_base);
-        tos_mmheap_free(the_task);
+        task_free(the_task);
         return err;
     }
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    knl_object_init(&the_task->knl_obj, KNL_OBJ_TYPE_TASK_DYN);
-#endif
+    knl_object_alloc_set_dynamic(&the_task->knl_obj);
 
     *task = the_task;
 
@@ -297,15 +303,15 @@ __API__ k_err_t tos_task_destroy_dyn(k_task_t *task)
         task = k_curr_task;
     }
 
+    TOS_OBJ_VERIFY(task, KNL_OBJ_TYPE_TASK);
+
     if (knl_is_self(task) && knl_is_sched_locked()) {
         return K_ERR_SCHED_LOCKED;
     }
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK_DYN)) {
-        return K_ERR_OBJ_INVALID;
+    if (!knl_object_alloc_is_dynamic(&task->knl_obj)) {
+        return K_ERR_OBJ_INVALID_ALLOC_TYPE;
     }
-#endif
 
     tos_knl_sched_lock();
 
@@ -355,15 +361,9 @@ __API__ k_err_t tos_task_prio_change(k_task_t *task, k_prio_t prio_new)
 #endif
 
     TOS_PTR_SANITY_CHECK(task);
+    TOS_OBJ_VERIFY(task, KNL_OBJ_TYPE_TASK);
     TOS_IN_IRQ_CHECK();
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK) &&
-        !knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK_DYN)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
-
     if (unlikely(prio_new >= K_TASK_PRIO_IDLE)) {
         return K_ERR_TASK_PRIO_INVALID;
     }
@@ -420,12 +420,7 @@ __API__ k_err_t tos_task_suspend(k_task_t *task)
         task = k_curr_task;
     }
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK) &&
-        !knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK_DYN)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(task, KNL_OBJ_TYPE_TASK);
 
     if (knl_is_idle(task)) {
         return K_ERR_TASK_SUSPEND_IDLE;
@@ -453,13 +448,7 @@ __API__ k_err_t tos_task_resume(k_task_t *task)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(task);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK) &&
-        !knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK_DYN)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(task, KNL_OBJ_TYPE_TASK);
 
     if (unlikely(knl_is_self(task))) {
         return K_ERR_TASK_RESUME_SELF;
@@ -520,15 +509,9 @@ __API__ k_err_t tos_task_delay_abort(k_task_t *task)
     TOS_CPU_CPSR_ALLOC();
 
     TOS_PTR_SANITY_CHECK(task);
+    TOS_OBJ_VERIFY(task, KNL_OBJ_TYPE_TASK);
     TOS_IN_IRQ_CHECK();
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK) &&
-        !knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK_DYN)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
-
     TOS_CPU_INT_DISABLE();
 
     if (knl_is_self(task) || !task_state_is_sleeping(task)) {
@@ -602,12 +585,7 @@ __API__ k_err_t tos_task_stack_draught_depth(k_task_t *task, int *depth)
         task = k_curr_task;
     }
 
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK) &&
-        !knl_object_verify(&task->knl_obj, KNL_OBJ_TYPE_TASK_DYN)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(task, KNL_OBJ_TYPE_TASK);
 
     TOS_CPU_INT_DISABLE();
     rc = cpu_task_stack_draught_depth(task->stk_base, task->stk_size, depth);

kernel/core/tos_timer.c

@@ -147,12 +147,7 @@ __API__ k_err_t tos_timer_create(k_timer_t *tmr,
 __API__ k_err_t tos_timer_destroy(k_timer_t *tmr)
 {
     TOS_PTR_SANITY_CHECK(tmr);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&tmr->knl_obj, KNL_OBJ_TYPE_TIMER)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(tmr, KNL_OBJ_TYPE_TIMER);
 
     if (tmr->state == TIMER_STATE_UNUSED) {
         return K_ERR_TIMER_INACTIVE;
@@ -169,12 +164,7 @@ __API__ k_err_t tos_timer_destroy(k_timer_t *tmr)
 __API__ k_err_t tos_timer_start(k_timer_t *tmr)
 {
     TOS_PTR_SANITY_CHECK(tmr);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&tmr->knl_obj, KNL_OBJ_TYPE_TIMER)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(tmr, KNL_OBJ_TYPE_TIMER);
 
     if (tmr->state == TIMER_STATE_UNUSED) {
         return K_ERR_TIMER_INACTIVE;
@@ -205,12 +195,7 @@ __API__ k_err_t tos_timer_start(k_timer_t *tmr)
 __API__ k_err_t tos_timer_stop(k_timer_t *tmr)
 {
     TOS_PTR_SANITY_CHECK(tmr);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&tmr->knl_obj, KNL_OBJ_TYPE_TIMER)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(tmr, KNL_OBJ_TYPE_TIMER);
 
     if (tmr->state == TIMER_STATE_UNUSED) {
         return K_ERR_TIMER_INACTIVE;
@@ -232,12 +217,7 @@ __API__ k_err_t tos_timer_stop(k_timer_t *tmr)
 __STATIC__ k_err_t timer_change(k_timer_t *tmr, k_tick_t new_val, timer_change_type_t change_type)
 {
     TOS_PTR_SANITY_CHECK(tmr);
-
-#if TOS_CFG_OBJECT_VERIFY_EN > 0u
-    if (!knl_object_verify(&tmr->knl_obj, KNL_OBJ_TYPE_TIMER)) {
-        return K_ERR_OBJ_INVALID;
-    }
-#endif
+    TOS_OBJ_VERIFY(tmr, KNL_OBJ_TYPE_TIMER);
 
     if (tmr->state == TIMER_STATE_UNUSED) {
         return K_ERR_TIMER_INACTIVE;

net/lwip/port/src/sys_arch.c

@@ -105,12 +105,20 @@ void sys_sem_free(sys_sem_t *sem)
 
 int sys_sem_valid(sys_sem_t *sem)
 {
-    return sem->pend_obj.type == PEND_TYPE_SEM;
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    return sem->knl_obj.type == KNL_OBJ_TYPE_SEMAPHORE;
+#else
+    #error  "need TOS_CFG_OBJECT_VERIFY_EN > 0u"
+#endif
 }
 
 void sys_sem_set_invalid(sys_sem_t *sem)
 {
-    sem->pend_obj.type = PEND_TYPE_NONE;
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    sem->knl_obj.type = KNL_OBJ_TYPE_NONE;
+#else
+    #error  "need TOS_CFG_OBJECT_VERIFY_EN > 0u"
+#endif
 }
 
 /*
@@ -178,12 +186,20 @@ void sys_mutex_free(sys_mutex_t *mutex)
 
 int sys_mutex_valid(sys_mutex_t *mutex)
 {
-    return mutex->pend_obj.type == PEND_TYPE_MUTEX;
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    return mutex->knl_obj.type == KNL_OBJ_TYPE_MUTEX;
+#else
+    #error  "need TOS_CFG_OBJECT_VERIFY_EN > 0u"
+#endif
 }
 
 void sys_mutex_set_invalid(sys_mutex_t *mutex)
 {
-    mutex->pend_obj.type = PEND_TYPE_NONE;
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    mutex->knl_obj.type = KNL_OBJ_TYPE_NONE;
+#else
+    #error  "need TOS_CFG_OBJECT_VERIFY_EN > 0u"
+#endif
 }
 
 void sys_mutex_lock(sys_mutex_t *mutex)
@@ -253,12 +269,20 @@ void sys_mbox_free(sys_mbox_t *mbox)
 
 int sys_mbox_valid(sys_mbox_t *mbox)
 {
-    return mbox->pend_obj.type == PEND_TYPE_MESSAGE_QUEUE;
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    return mbox->knl_obj.type == KNL_OBJ_TYPE_MESSAGE_QUEUE;
+#else
+    #error  "need TOS_CFG_OBJECT_VERIFY_EN > 0u"
+#endif
 }
 
 void sys_mbox_set_invalid(sys_mbox_t *mbox)
 {
-    mbox->pend_obj.type = PEND_TYPE_NONE;
+#if TOS_CFG_OBJECT_VERIFY_EN > 0u
+    mbox->knl_obj.type = KNL_OBJ_TYPE_NONE;
+#else
+    #error  "need TOS_CFG_OBJECT_VERIFY_EN > 0u"
+#endif
 }
 
 void sys_mbox_post(sys_mbox_t *q, void *msg)

test/suit_binary_heap.c

@@ -257,6 +257,77 @@ TEST test_tos_binary_heap_max_push(void)
     PASS();
 }
 
+TEST test_tos_binary_heap_max_push_dyn(void)
+{
+    k_err_t err;
+    int i = 0;
+    test_bin_heap_item_t items[TEST_BIN_HEAP_ITEM_CNT] = {
+        { 2, "222", '2' },
+        { 4, "444", '4' },
+        { 1, "111", '1' },
+        { 7, "777", '7' },
+        { 5, "555", '5' },
+        { 5, "555", '5' },
+        { 2, "222", '2' },
+        { 0, "000", '0' },
+        { 9, "999", '9' },
+        { 10, "aaa", 'a' },
+        { 5, "555", '5' },
+        { 12, "ccc", 'c' },
+        { 11, "bbb", 'b' },
+        { 3, "333", '3' },
+        { 6, "666", '6' },
+        { 8, "888", '8' },
+    };
+    test_bin_heap_item_t items_should[TEST_BIN_HEAP_ITEM_CNT] = {
+        { 12, "ccc", 'c' },
+        { 11, "bbb", 'b' },
+        { 10, "aaa", 'a' },
+        { 9, "999", '9' },
+        { 8, "888", '8' },
+        { 7, "777", '7' },
+        { 6, "666", '6' },
+        { 5, "555", '5' },
+        { 5, "555", '5' },
+        { 5, "555", '5' },
+        { 4, "444", '4' },
+        { 3, "333", '3' },
+        { 2, "222", '2' },
+        { 2, "222", '2' },
+        { 1, "111", '1' },
+        { 0, "000", '0' },
+    };
+    test_bin_heap_item_t item_popped;
+    size_t item_size;
+
+    // we gonna build a max heap
+    err = tos_bin_heap_create_dyn(&test_bin_heap_00, TEST_BIN_HEAP_ITEM_CNT, sizeof(test_bin_heap_item_t), test_bin_heap_max_cmp_dummy);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    for (i = 0; i < TEST_BIN_HEAP_ITEM_CNT; ++i) {
+        err = tos_bin_heap_push(&test_bin_heap_00, &items[i], sizeof(test_bin_heap_item_t));
+        ASSERT_EQ(err, K_ERR_NONE);
+    }
+
+    ASSERT(tos_bin_heap_is_full(&test_bin_heap_00));
+
+    for (i = 0; i < TEST_BIN_HEAP_ITEM_CNT; ++i) {
+        err = tos_bin_heap_pop(&test_bin_heap_00, &item_popped, &item_size);
+        ASSERT_EQ(err, K_ERR_NONE);
+        ASSERT_EQ(item_size, sizeof(test_bin_heap_item_t));
+        ASSERT_EQ(item_popped.a, items_should[i].a);
+        ASSERT_EQ(strcmp(item_popped.b, items_should[i].b), 0);
+        ASSERT_EQ(item_popped.c, items_should[i].c);
+    }
+
+    ASSERT(tos_bin_heap_is_empty(&test_bin_heap_00));
+
+    err = tos_bin_heap_destroy_dyn(&test_bin_heap_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_binary_heap_min_int_push(void)
 {
     k_err_t err;
@@ -395,6 +466,75 @@ TEST test_tos_binary_heap_max_int_push(void)
     PASS();
 }
 
+TEST test_tos_binary_heap_max_int_push_dyn(void)
+{
+    k_err_t err;
+    int i = 0;
+    int items[TEST_BIN_HEAP_ITEM_CNT] = {
+        2,
+        4,
+        1,
+        7,
+        5,
+        5,
+        2,
+        0,
+        9,
+        10,
+        5,
+        12,
+        11,
+        3,
+        6,
+        8,
+    };
+    int items_should[TEST_BIN_HEAP_ITEM_CNT] = {
+        12,
+        11,
+        10,
+        9,
+        8,
+        7,
+        6,
+        5,
+        5,
+        5,
+        4,
+        3,
+        2,
+        2,
+        1,
+        0,
+    };
+    int item_popped;
+    size_t item_size;
+
+    // we gonna build a max heap
+    err = tos_bin_heap_create_dyn(&test_bin_heap_00, TEST_BIN_HEAP_ITEM_CNT, sizeof(int), test_bin_heap_max_int_cmp_dummy);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    for (i = 0; i < TEST_BIN_HEAP_ITEM_CNT; ++i) {
+        err = tos_bin_heap_push(&test_bin_heap_00, &items[i], sizeof(int));
+        ASSERT_EQ(err, K_ERR_NONE);
+    }
+
+    ASSERT(tos_bin_heap_is_full(&test_bin_heap_00));
+
+    for (i = 0; i < TEST_BIN_HEAP_ITEM_CNT; ++i) {
+        err = tos_bin_heap_pop(&test_bin_heap_00, &item_popped, &item_size);
+        ASSERT_EQ(err, K_ERR_NONE);
+        ASSERT_EQ(item_size, sizeof(int));
+        ASSERT_EQ(item_popped, items_should[i]);
+    }
+
+    ASSERT(tos_bin_heap_is_empty(&test_bin_heap_00));
+
+    err = tos_bin_heap_destroy_dyn(&test_bin_heap_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_binary_heap_push_limit(void)
 {
     k_err_t err;
@@ -535,8 +675,10 @@ SUITE(suit_binary_heap)
     RUN_TEST(test_tos_binary_heap_destroy);
     RUN_TEST(test_tos_binary_heap_min_push);
     RUN_TEST(test_tos_binary_heap_max_push);
+    RUN_TEST(test_tos_binary_heap_max_push_dyn);
     RUN_TEST(test_tos_binary_heap_min_int_push);
     RUN_TEST(test_tos_binary_heap_max_int_push);
+    RUN_TEST(test_tos_binary_heap_max_int_push_dyn);
     RUN_TEST(test_tos_binary_heap_push_limit);
     RUN_TEST(test_tos_binary_flush);
 }

test/suit_char_fifo.c

@@ -86,6 +86,38 @@ TEST test_tos_fifo_char_push(void)
     PASS();
 }
 
+TEST test_tos_fifo_char_push_dyn(void)
+{
+    k_err_t err;
+    int i = 0;
+    uint8_t data;
+
+    err = tos_chr_fifo_create_dyn(&test_fifo_00, sizeof(fifo_buffer_00));
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    for (i = 0; i < FIFO_BUFFER_SIZE; ++i) {
+        err = tos_chr_fifo_push(&test_fifo_00, 'a' + i);
+        ASSERT_EQ(err, K_ERR_NONE);
+    }
+
+    err = tos_chr_fifo_push(&test_fifo_00, 'z');
+    ASSERT_EQ(err, K_ERR_RING_Q_FULL);
+
+    for (i = 0; i < FIFO_BUFFER_SIZE; ++i) {
+        err = tos_chr_fifo_pop(&test_fifo_00, &data);
+        ASSERT_EQ(err, K_ERR_NONE);
+        ASSERT_EQ(data, 'a' + i);
+    }
+
+    err = tos_chr_fifo_pop(&test_fifo_00, &data);
+    ASSERT_EQ(err, K_ERR_RING_Q_EMPTY);
+
+    err = tos_chr_fifo_destroy_dyn(&test_fifo_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_fifo_stream_push(void)
 {
     k_err_t err;
@@ -119,6 +151,7 @@ SUITE(suit_char_fifo)
     RUN_TEST(test_tos_fifo_create);
     RUN_TEST(test_tos_fifo_destory);
     RUN_TEST(test_tos_fifo_char_push);
+    RUN_TEST(test_tos_fifo_char_push_dyn);
     RUN_TEST(test_tos_fifo_stream_push);
 }
 

test/suit_mail_queue.c

@@ -158,6 +158,53 @@ TEST test_tos_mail_queue_pend(void)
     PASS();
 }
 
+TEST test_tos_mail_queue_pend_dyn(void)
+{
+    k_err_t err;
+    test_mail_t mail = {
+        0xDEADBEEF,
+        "test_mail",
+        'T',
+    };
+
+    test_mail_reset();
+    test_context_reset();
+    test_count_reset();
+    test_task_hook_set(test_count_inc);
+
+    err = tos_mail_q_create_dyn(&test_mail_q_00, TEST_MAIL_Q_MAIL_CNT, sizeof(test_mail_t));
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    // create a test task with a higher priority than current task
+    err = tos_task_create(&test_task_00, "test_task", test_mail_queue_pend_task_entry,
+                            (void *)(&test_mail_q_00), k_curr_task->prio - 1,
+                            test_task_stack_00, sizeof(test_task_stack_00),
+                            0);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    ASSERT_EQ(test_count, 0);
+    ASSERT_EQ(test_context, TEST_CONTEXT_00);
+
+    tos_mail_q_post(&test_mail_q_00, &mail, sizeof(test_mail_t));
+
+    ASSERT_EQ(test_count, 1);
+    ASSERT_EQ(test_err, K_ERR_NONE);
+    ASSERT_EQ(test_context, TEST_CONTEXT_00);
+
+    ASSERT_EQ(test_mail.a, mail.a);
+    ASSERT_EQ(strcmp(test_mail.b, mail.b), 0);
+    ASSERT_EQ(test_mail.c, mail.c);
+
+    tos_mail_q_destroy_dyn(&test_mail_q_00);
+    ASSERT_EQ(test_err, K_ERR_PEND_DESTROY);
+    ASSERT_EQ(test_context, TEST_CONTEXT_01);
+
+    err = tos_task_destroy(&test_task_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_mail_queue_pend_timed(void)
 {
     k_err_t err;
@@ -397,6 +444,7 @@ SUITE(suit_mail_queue)
     RUN_TEST(test_tos_mail_queue_create);
     RUN_TEST(test_tos_mail_queue_destroy);
     RUN_TEST(test_tos_mail_queue_pend);
+    RUN_TEST(test_tos_mail_queue_pend_dyn);
     RUN_TEST(test_tos_mail_queue_pend_timed);
     RUN_TEST(test_tos_mail_queue_post_all);
     RUN_TEST(test_tos_mail_queue_flush);

test/suit_message_queue.c

@@ -150,6 +150,47 @@ TEST test_tos_message_queue_pend(void)
     PASS();
 }
 
+TEST test_tos_message_queue_pend_dyn(void)
+{
+    k_err_t err;
+    void *msg = (void *)0xDEADBEEF;
+
+    test_msg_reset();
+    test_context_reset();
+    test_count_reset();
+    test_task_hook_set(test_count_inc);
+
+    err = tos_msg_q_create_dyn(&test_msg_q_00, TEST_MESSAGE_Q_MSG_CNT);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    // create a test task with a higher priority than current task
+    err = tos_task_create(&test_task_00, "test_task", test_message_queue_pend_task_entry,
+                            (void *)(&test_msg_q_00), k_curr_task->prio - 1,
+                            test_task_stack_00, sizeof(test_task_stack_00),
+                            0);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    ASSERT_EQ(test_count, 0);
+    ASSERT_EQ(test_context, TEST_CONTEXT_00);
+
+    tos_msg_q_post(&test_msg_q_00, msg);
+
+    ASSERT_EQ(test_count, 1);
+    ASSERT_EQ(test_err, K_ERR_NONE);
+    ASSERT_EQ(test_context, TEST_CONTEXT_00);
+
+    ASSERT_EQ(test_msg, msg);
+
+    tos_msg_q_destroy_dyn(&test_msg_q_00);
+    ASSERT_EQ(test_err, K_ERR_PEND_DESTROY);
+    ASSERT_EQ(test_context, TEST_CONTEXT_01);
+
+    err = tos_task_destroy(&test_task_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_message_queue_pend_timed(void)
 {
     k_err_t err;
@@ -363,6 +404,7 @@ SUITE(suit_message_queue)
     RUN_TEST(test_tos_message_queue_create);
     RUN_TEST(test_tos_message_queue_destroy);
     RUN_TEST(test_tos_message_queue_pend);
+    RUN_TEST(test_tos_message_queue_pend_dyn);
     RUN_TEST(test_tos_message_queue_pend_timed);
     RUN_TEST(test_tos_message_queue_post_all);
     RUN_TEST(test_tos_message_queue_flush);

test/suit_priority_mail_queue.c

@@ -190,6 +190,84 @@ TEST test_tos_prio_mail_queue_pend(void)
     PASS();
 }
 
+TEST test_tos_prio_mail_queue_pend_dyn(void)
+{
+    k_err_t err;
+    test_mail_t mail0 = {
+        0xDEAD0000,
+        "test_mail0",
+        'T',
+    };
+    test_mail_t mail1 = {
+        0xDEAD1111,
+        "test_mail1",
+        'U',
+    };
+    test_mail_t mail2 = {
+        0xDEAD2222,
+        "test_mail2",
+        'V',
+    };
+
+    test_mail_reset();
+    test_context_reset();
+    test_count_reset();
+    test_task_hook_set(test_count_inc);
+
+    err = tos_prio_mail_q_create_dyn(&test_prio_mail_q_00, TEST_PRIO_MAIL_Q_MAIL_CNT, sizeof(test_mail_t));
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    // create a test task with the same priority than current task
+    err = tos_task_create(&test_task_00, "test_task", test_prio_mail_queue_pend_task_entry,
+                            (void *)(&test_prio_mail_q_00), k_curr_task->prio,
+                            test_task_stack_00, sizeof(test_task_stack_00),
+                            0);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    ASSERT_EQ(test_count, 0);
+    ASSERT(test_context != TEST_CONTEXT_00);
+
+    // we post mail2, mail1, mail0 with the certain priority, the test_task should receive mail according the priority
+    tos_prio_mail_q_post(&test_prio_mail_q_00, &mail2, sizeof(test_mail_t), 2);
+    tos_prio_mail_q_post(&test_prio_mail_q_00, &mail1, sizeof(test_mail_t), 1);
+    tos_prio_mail_q_post(&test_prio_mail_q_00, &mail0, sizeof(test_mail_t), 0);
+
+    tos_task_yield(); // yeild to test_task
+
+    ASSERT_EQ(test_count, 0);
+    ASSERT_EQ(test_err, K_ERR_NONE);
+    ASSERT_EQ(test_context, TEST_CONTEXT_01);
+
+    ASSERT_EQ(test_mail.a, mail0.a);
+    ASSERT_EQ(strcmp(test_mail.b, mail0.b), 0);
+    ASSERT_EQ(test_mail.c, mail0.c);
+    tos_task_yield(); // yeild to test_task
+
+    ASSERT_EQ(test_count, 1);
+    ASSERT_EQ(test_err, K_ERR_NONE);
+    ASSERT_EQ(test_context, TEST_CONTEXT_01);
+
+    ASSERT_EQ(test_mail.a, mail1.a);
+    ASSERT_EQ(strcmp(test_mail.b, mail1.b), 0);
+    ASSERT_EQ(test_mail.c, mail1.c);
+    tos_task_yield(); // yeild to test_task
+
+    ASSERT_EQ(test_mail.a, mail2.a);
+    ASSERT_EQ(strcmp(test_mail.b, mail2.b), 0);
+    ASSERT_EQ(test_mail.c, mail2.c);
+    tos_task_yield(); // yeild to test_task
+
+    tos_prio_mail_q_destroy_dyn(&test_prio_mail_q_00);
+    tos_task_yield(); // yeild to test_task
+    ASSERT_EQ(test_err, K_ERR_PEND_DESTROY);
+    ASSERT_EQ(test_context, TEST_CONTEXT_01);
+
+    err = tos_task_destroy(&test_task_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_prio_mail_queue_pend_timed(void)
 {
     k_err_t err;
@@ -415,6 +493,7 @@ SUITE(suit_priority_mail_queue)
     RUN_TEST(test_tos_prio_mail_queue_create);
     RUN_TEST(test_tos_prio_mail_queue_destroy);
     RUN_TEST(test_tos_prio_mail_queue_pend);
+    RUN_TEST(test_tos_prio_mail_queue_pend_dyn);
     RUN_TEST(test_tos_prio_mail_queue_pend_timed);
     RUN_TEST(test_tos_prio_mail_queue_post_all);
     RUN_TEST(test_tos_prio_mail_queue_flush);

test/suit_priority_message_queue.c

@@ -172,6 +172,68 @@ TEST test_tos_priority_message_queue_pend(void)
     PASS();
 }
 
+TEST test_tos_priority_message_queue_pend_dyn(void)
+{
+    k_err_t err;
+    void *msg0 = (void *)0xDEAD0000, *msg1 = (void *)0xDEAD1111, *msg2 = (void *)0xDEAD2222;
+
+    test_msg_reset();
+    test_context_reset();
+    test_count_reset();
+    test_task_hook_set(test_count_inc);
+
+    err = tos_prio_msg_q_create_dyn(&test_prio_msg_q_00, TEST_PRIO_MESSAGE_Q_MSG_CNT);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    // create a test task with the same priority than current task
+    err = tos_task_create(&test_task_00, "test_task", test_priority_message_queue_pend_task_entry,
+                            (void *)(&test_prio_msg_q_00), k_curr_task->prio,
+                            test_task_stack_00, sizeof(test_task_stack_00),
+                            0);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    ASSERT_EQ(test_count, 0);
+    ASSERT(test_context != TEST_CONTEXT_00); // test_task is not running yet
+
+    // we post msg2, msg1, msg0 with the certain priority, the test_task should receive message according the priority
+    tos_prio_msg_q_post(&test_prio_msg_q_00, msg2, 2);
+    tos_prio_msg_q_post(&test_prio_msg_q_00, msg1, 1);
+    tos_prio_msg_q_post(&test_prio_msg_q_00, msg0, 0);
+
+    tos_task_yield(); // yeild to test_task
+
+    ASSERT_EQ(test_count, 0);
+    ASSERT_EQ(test_err, K_ERR_NONE);
+    ASSERT_EQ(test_context, TEST_CONTEXT_01);
+
+    ASSERT_EQ(test_msg, msg0);
+    tos_task_yield(); // yeild to test_task
+
+    ASSERT_EQ(test_count, 1);
+    ASSERT_EQ(test_err, K_ERR_NONE);
+    ASSERT_EQ(test_context, TEST_CONTEXT_01);
+
+    ASSERT_EQ(test_msg, msg1);
+    tos_task_yield(); // yeild to test_task
+
+    ASSERT_EQ(test_count, 2);
+    ASSERT_EQ(test_err, K_ERR_NONE);
+    ASSERT_EQ(test_context, TEST_CONTEXT_01);
+
+    ASSERT_EQ(test_msg, msg2);
+    tos_task_yield(); // yeild to test_task
+
+    tos_prio_msg_q_destroy_dyn(&test_prio_msg_q_00);
+    tos_task_yield(); // yeild to test_task
+    ASSERT_EQ(test_err, K_ERR_PEND_DESTROY);
+    ASSERT_EQ(test_context, TEST_CONTEXT_01);
+
+    err = tos_task_destroy(&test_task_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_priority_message_queue_pend_timed(void)
 {
     k_err_t err;
@@ -385,6 +447,7 @@ SUITE(suit_priority_message_queue)
     RUN_TEST(test_tos_priority_message_queue_create);
     RUN_TEST(test_tos_priority_message_queue_destroy);
     RUN_TEST(test_tos_priority_message_queue_pend);
+    RUN_TEST(test_tos_priority_message_queue_pend_dyn);
     RUN_TEST(test_tos_priority_message_queue_pend_timed);
     RUN_TEST(test_tos_priority_message_queue_post_all);
     RUN_TEST(test_tos_priority_message_queue_flush);

test/suit_priority_queue.c

@@ -132,6 +132,80 @@ TEST test_tos_priority_queue_enqueue(void)
     PASS();
 }
 
+TEST test_tos_priority_queue_enqueue_dyn(void)
+{
+    k_err_t err;
+    int i = 0;
+    k_prio_t prio;
+    test_prio_q_item_t items[TEST_PRIO_Q_ITEM_CNT] = {
+        { 2, "222", '2' },
+        { 4, "444", '4' },
+        { 1, "111", '1' },
+        { 7, "777", '7' },
+        { 5, "555", '5' },
+        { 5, "555", '5' },
+        { 2, "222", '2' },
+        { 0, "000", '0' },
+        { 9, "999", '9' },
+        { 10, "aaa", 'a' },
+        { 5, "555", '5' },
+        { 12, "ccc", 'c' },
+        { 11, "bbb", 'b' },
+        { 3, "333", '3' },
+        { 6, "666", '6' },
+        { 8, "888", '8' },
+    };
+    test_prio_q_item_t items_should[TEST_PRIO_Q_ITEM_CNT] = {
+        { 0, "000", '0' },
+        { 1, "111", '1' },
+        { 2, "222", '2' },
+        { 2, "222", '2' },
+        { 3, "333", '3' },
+        { 4, "444", '4' },
+        { 5, "555", '5' },
+        { 5, "555", '5' },
+        { 5, "555", '5' },
+        { 6, "666", '6' },
+        { 7, "777", '7' },
+        { 8, "888", '8' },
+        { 9, "999", '9' },
+        { 10, "aaa", 'a' },
+        { 11, "bbb", 'b' },
+        { 12, "ccc", 'c' },
+    };
+    test_prio_q_item_t item_dequeued;
+    size_t item_size;
+
+    // yes, our priority queue has a min heap inside(priority, numerically bigger, actually smaller)
+    err = tos_prio_q_create_dyn(&test_prio_q_00, TEST_PRIO_Q_ITEM_CNT, sizeof(test_prio_q_item_t));
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    for (i = 0; i < TEST_PRIO_Q_ITEM_CNT; ++i) {
+        // we enqueue the item with the domain "a" as the priority
+        err = tos_prio_q_enqueue(&test_prio_q_00, &items[i], sizeof(test_prio_q_item_t), items[i].a);
+        ASSERT_EQ(err, K_ERR_NONE);
+    }
+
+    ASSERT(tos_prio_q_is_full(&test_prio_q_00));
+
+    for (i = 0; i < TEST_PRIO_Q_ITEM_CNT; ++i) {
+        err = tos_prio_q_dequeue(&test_prio_q_00, &item_dequeued, &item_size, &prio);
+        ASSERT_EQ(err, K_ERR_NONE);
+        ASSERT_EQ(item_size, sizeof(test_prio_q_item_t));
+        ASSERT_EQ(prio, item_dequeued.a);
+        ASSERT_EQ(item_dequeued.a, items_should[i].a);
+        ASSERT_EQ(strcmp(item_dequeued.b, items_should[i].b), 0);
+        ASSERT_EQ(item_dequeued.c, items_should[i].c);
+    }
+
+    ASSERT(tos_prio_q_is_empty(&test_prio_q_00));
+
+    err = tos_prio_q_destroy_dyn(&test_prio_q_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_priority_queue_int_enqueue(void)
 {
     k_err_t err;
@@ -204,6 +278,78 @@ TEST test_tos_priority_queue_int_enqueue(void)
     PASS();
 }
 
+TEST test_tos_priority_queue_int_enqueue_dyn(void)
+{
+    k_err_t err;
+    int i = 0;
+    k_prio_t prio;
+    int items[TEST_PRIO_Q_ITEM_CNT] = {
+        2,
+        4,
+        1,
+        7,
+        5,
+        5,
+        2,
+        0,
+        9,
+        10,
+        5,
+        12,
+        11,
+        3,
+        6,
+        8,
+    };
+    int items_should[TEST_PRIO_Q_ITEM_CNT] = {
+        0,
+        1,
+        2,
+        2,
+        3,
+        4,
+        5,
+        5,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+    };
+    int item_dequeued;
+    size_t item_size;
+
+    // yes, our priority queue has a min heap inside(priority, numerically bigger, actually smaller)
+    err = tos_prio_q_create_dyn(&test_prio_q_00, TEST_PRIO_Q_ITEM_CNT, sizeof(int));
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    for (i = 0; i < TEST_PRIO_Q_ITEM_CNT; ++i) {
+        // we enqueue the item with the value of item as the priority
+        err = tos_prio_q_enqueue(&test_prio_q_00, &items[i], sizeof(int), items[i]);
+        ASSERT_EQ(err, K_ERR_NONE);
+    }
+
+    ASSERT(tos_prio_q_is_full(&test_prio_q_00));
+
+    for (i = 0; i < TEST_PRIO_Q_ITEM_CNT; ++i) {
+        err = tos_prio_q_dequeue(&test_prio_q_00, &item_dequeued, &item_size, &prio);
+        ASSERT_EQ(err, K_ERR_NONE);
+        ASSERT_EQ(item_size, sizeof(int));
+        ASSERT_EQ(prio, item_dequeued);
+        ASSERT_EQ(item_dequeued, items_should[i]);
+    }
+
+    ASSERT(tos_prio_q_is_empty(&test_prio_q_00));
+
+    err = tos_prio_q_destroy_dyn(&test_prio_q_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_priority_queue_enqueue_limit(void)
 {
     k_err_t err;
@@ -343,7 +489,9 @@ SUITE(suit_priority_queue)
     RUN_TEST(test_tos_priority_queue_create);
     RUN_TEST(test_tos_priority_queue_destroy);
     RUN_TEST(test_tos_priority_queue_enqueue);
+    RUN_TEST(test_tos_priority_queue_enqueue_dyn);
     RUN_TEST(test_tos_priority_queue_int_enqueue);
+    RUN_TEST(test_tos_priority_queue_int_enqueue_dyn);
     RUN_TEST(test_tos_priority_queue_enqueue_limit);
     RUN_TEST(test_tos_priority_queue_flush);
 }

test/suit_ring_queue.c

@@ -90,6 +90,39 @@ TEST test_tos_ring_queue_u8_enqueue(void)
     PASS();
 }
 
+TEST test_tos_ring_queue_u8_enqueue_dyn(void)
+{
+    k_err_t err;
+    int i = 0;
+    uint8_t items[TEST_RING_Q_U8_ITEM_CNT] = { 1, 2, 3, 4, 5 };
+    uint8_t item_dequeued;
+    size_t item_size;
+
+    err = tos_ring_q_create_dyn(&test_ring_q_00, TEST_RING_Q_U8_ITEM_CNT, TEST_RING_Q_U8_ITEM_SIZE);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    for (i = 0; i < TEST_RING_Q_U8_ITEM_CNT; ++i) {
+        err = tos_ring_q_enqueue(&test_ring_q_00, &items[i], sizeof(uint8_t));
+        ASSERT_EQ(err, K_ERR_NONE);
+    }
+
+    ASSERT(tos_ring_q_is_full(&test_ring_q_00));
+
+    for (i = 0; i < TEST_RING_Q_U8_ITEM_CNT; ++i) {
+        err = tos_ring_q_dequeue(&test_ring_q_00, &item_dequeued, &item_size);
+        ASSERT_EQ(err, K_ERR_NONE);
+        ASSERT_EQ(item_size, sizeof(uint8_t));
+        ASSERT_EQ(item_dequeued, items[i]);
+    }
+
+    ASSERT(tos_ring_q_is_empty(&test_ring_q_00));
+
+    err = tos_ring_q_destroy_dyn(&test_ring_q_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
 TEST test_tos_ring_queue_u8_enqueue_limit(void)
 {
     k_err_t err;
@@ -174,6 +207,48 @@ TEST test_tos_ring_queue_struct_enqueue(void)
     PASS();
 }
 
+TEST test_tos_ring_queue_struct_enqueue_dyn(void)
+{
+    k_err_t err;
+    int i = 0;
+    ring_q_item_t items[TEST_RING_Q_STRUCT_ITEM_CNT] = {
+            { 1, "111", '1' },
+            { 2, "222", '2' },
+            { 3, "333", '3' },
+            { 4, "444", '4' },
+            { 5, "555", '5' },
+    };
+    ring_q_item_t item_dequeued;
+    size_t item_size;
+
+    err = tos_ring_q_create_dyn(&test_ring_q_00, TEST_RING_Q_STRUCT_ITEM_CNT, TEST_RING_Q_STRUCT_ITEM_SIZE);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    for (i = 0; i < TEST_RING_Q_STRUCT_ITEM_CNT; ++i) {
+        err = tos_ring_q_enqueue(&test_ring_q_00, &items[i], sizeof(ring_q_item_t));
+        ASSERT_EQ(err, K_ERR_NONE);
+    }
+
+    ASSERT(tos_ring_q_is_full(&test_ring_q_00));
+
+    for (i = 0; i < TEST_RING_Q_STRUCT_ITEM_CNT; ++i) {
+        err = tos_ring_q_dequeue(&test_ring_q_00, &item_dequeued, &item_size);
+        ASSERT_EQ(err, K_ERR_NONE);
+        ASSERT_EQ(item_size, sizeof(ring_q_item_t));
+        ASSERT_EQ(item_dequeued.a, items[i].a);
+        ASSERT_EQ(strcmp(item_dequeued.b, items[i].b), 0);
+        ASSERT_EQ(item_dequeued.c, items[i].c);
+    }
+
+    ASSERT(tos_ring_q_is_empty(&test_ring_q_00));
+
+    err = tos_ring_q_destroy_dyn(&test_ring_q_00);
+    ASSERT_EQ(err, K_ERR_NONE);
+
+    PASS();
+}
+
+
 TEST test_tos_ring_queue_struct_enqueue_limit(void)
 {
     k_err_t err;
@@ -265,8 +340,10 @@ SUITE(suit_ring_queue)
     RUN_TEST(test_tos_ring_queue_create);
     RUN_TEST(test_tos_ring_queue_destroy);
     RUN_TEST(test_tos_ring_queue_u8_enqueue);
+    RUN_TEST(test_tos_ring_queue_u8_enqueue_dyn);
     RUN_TEST(test_tos_ring_queue_u8_enqueue_limit);
     RUN_TEST(test_tos_ring_queue_struct_enqueue);
+    RUN_TEST(test_tos_ring_queue_struct_enqueue_dyn);
     RUN_TEST(test_tos_ring_queue_struct_enqueue_limit);
     RUN_TEST(test_tos_ring_queue_flush);
 }