Semaphore starts to support multiple count limits.

Author: At-EC

build_version.h

@@ -12,11 +12,11 @@
 extern "C" {
 #endif
 
-#define ATOS_BUILD_TIME           "2024-05-03,15:38"
-#define ATOS_COMMIT_HEAD_ID       "89288f504ee15657abc039685265dec9f4f236be"
+#define ATOS_BUILD_TIME           "2024-05-03,19:06"
+#define ATOS_COMMIT_HEAD_ID       "4d863cac69b2f231fd7fc070f0956888261f741a"
 #define ATOS_VERSION_MAJOR_NUMBER (1u)
 #define ATOS_VERSION_MINOR_NUMBER (4u)
-#define ATOS_VERSION_PATCH_NUMBER (8u)
+#define ATOS_VERSION_PATCH_NUMBER (9u)
 
 #define ATOS_VERSION_MAJOR_NUMBER_MASK (0x03FFu)
 #define ATOS_VERSION_MAJOR_NUMBER_POS  (22u)

include/kernel/at_rtos.h

@@ -301,10 +301,8 @@ static inline u32_t os_timer_system_total_ms(void)
 /**
  * @brief Initialize a new semaphore.
  *
- * @param initial The initial count that allows the system take.
+ * @param remain The initial count that allows the system take.
  * @param limit The maximum count that it's the semaphore's limitation.
- * @param permit TRUE flag permits that all sem_give counts save until sem_take flush, even if the counts number higher than limitation
- *setting count. FALSE flag can reduce useless thread wakeup calling.
  * @param pName The semaphore name.
  *
  * @return The semaphore unique id.
@@ -318,14 +316,14 @@ static inline u32_t os_timer_system_total_ms(void)
  *     }
  *     ...
  */
-static inline os_sem_id_t os_sem_init(u8_t initial, u8_t limit, b_t permit, const char_t *pName)
+static inline os_sem_id_t os_sem_init(u8_t remain, u8_t limit, const char_t *pName)
 {
-    u32_t _impl_semaphore_os_id_to_number(os_id_t id);
-    os_id_t _impl_semaphore_init(u8_t initialCount, u8_t limitCount, b_t permit, const char_t *pName);
+    extern u32_t _impl_semaphore_os_id_to_number(os_id_t id);
+    extern os_id_t _impl_semaphore_init(u8_t remainCount, u8_t limitCount, const char_t *pName);
 
     os_sem_id_t id = {0u};
 
-    id.val = _impl_semaphore_init(initial, limit, permit, pName);
+    id.val = _impl_semaphore_init(remain, limit, pName);
     id.number = _impl_semaphore_os_id_to_number(id.val);
     id.pName = pName;
 
@@ -973,7 +971,7 @@ typedef struct {
     u32p_t (*timer_busy)(os_timer_id_t);
     u32_t (*timer_system_total_ms)(void);
 
-    os_sem_id_t (*sem_init)(u8_t, u8_t, b_t, const char_t *);
+    os_sem_id_t (*sem_init)(u8_t, u8_t, const char_t *);
     u32p_t (*sem_take)(os_sem_id_t, u32_t);
     u32p_t (*sem_give)(os_sem_id_t);
     u32p_t (*sem_flush)(os_sem_id_t);

include/kernel/kernel.h

@@ -81,7 +81,7 @@ u32_t kernel_schedule_time_get(void);
 u32_t kernel_thread_use_percent_take(os_id_t id);
 void kernel_privilege_call_inSVC_c(u32_t *svc_args);
 u32_t kernel_privilege_invoke(const void *pCallFun, arguments_t *pArgs);
-void kernel_semaphore_list_transfer_toLock(linker_head_t *pCurHead);
+void kernel_semaphore_list_transfer_toInit(linker_head_t *pCurHead);
 void kernel_schedule_thread(void);
 void kernel_idle_thread(void);
 void kthread_init(void);

include/kernel/kstruct.h

@@ -58,11 +58,9 @@ typedef struct {
     /* A common struct head to link with other context */
     linker_head_t head;
 
-    u8_t initialCount;
+    u8_t remains;
 
-    u8_t limitCount;
-
-    b_t isPermit;
+    u8_t limits;
 
     u32_t timeout_ms;
 
@@ -259,14 +257,12 @@ enum {
     KERNEL_MEMBER_LIST_TIMER_PEND,
     KERNEL_MEMBER_LIST_TIMER_RUN,
 
-    KERNEL_MEMBER_LIST_SEMAPHORE_LOCK,
-    KERNEL_MEMBER_LIST_SEMAPHORE_UNLOCK,
+    KERNEL_MEMBER_LIST_SEMAPHORE_INIT,
 
     KERNEL_MEMBER_LIST_MUTEX_LOCK,
     KERNEL_MEMBER_LIST_MUTEX_UNLOCK,
 
     KERNEL_MEMBER_LIST_EVENT_INIT,
-    KERNEL_MEMBER_LIST_EVENT_ACTIVE,
 
     KERNEL_MEMBER_LIST_QUEUE_INIT,
 

include/kernel/trace.h

@@ -36,7 +36,6 @@ typedef struct {
 typedef struct {
     u16_t initial_count;
     u16_t limit_count;
-    b_t permit;
     u32_t timeout_ms;
     list_t wait_list;
 } semaphore_snapshot_t;

kernel/event.c

@@ -41,16 +41,6 @@ static list_t *_event_list_initHeadGet(void)
     return (list_t *)kernel_member_list_get(KERNEL_MEMBER_EVENT, KERNEL_MEMBER_LIST_EVENT_INIT);
 }
 
-/**
- * @brief Get the active event list head.
- *
- * @return The value of the active list head.
- */
-static list_t *_event_list_activeHeadGet(void)
-{
-    return (list_t *)kernel_member_list_get(KERNEL_MEMBER_EVENT, KERNEL_MEMBER_LIST_EVENT_ACTIVE);
-}
-
 /**
  * @brief Pick up a highest priority thread that blocking by the event pending list.
  *
@@ -80,21 +70,6 @@ static void _event_list_transfer_toInit(linker_head_t *pCurHead)
     EXIT_CRITICAL_SECTION();
 }
 
-/**
- * @brief Push one event context into active list.
- *
- * @param pCurHead The pointer of the timer linker head.
- */
-static void _event_list_transfer_toActive(linker_head_t *pCurHead)
-{
-    ENTER_CRITICAL_SECTION();
-
-    list_t *pToActiveList = (list_t *)_event_list_activeHeadGet();
-    linker_list_transaction_common(&pCurHead->linker, pToActiveList, LIST_TAIL);
-
-    EXIT_CRITICAL_SECTION();
-}
-
 /**
  * @brief Check if the event unique id if is's invalid.
  *
@@ -535,7 +510,7 @@ b_t event_snapshot(u32_t instance, kernel_snapshot_t *pMsgs)
         return FALSE;
     }
 
-    if (pCurEvent->head.linker.pList == _event_list_activeHeadGet()) {
+    if (pCurEvent->head.linker.pList == _event_list_initHeadGet()) {
         pMsgs->pState = "init";
     } else if (pCurEvent->head.linker.pList) {
         pMsgs->pState = "*";

kernel/kernel.c

@@ -30,9 +30,9 @@ static kernel_member_setting_t g_kernel_member_setting[KERNEL_MEMBER_NUMBER] = {
     [KERNEL_MEMBER_THREAD] = {KERNEL_MEMBER_MAP_1, (SBITS(KERNEL_MEMBER_LIST_THREAD_WAIT, KERNEL_MEMBER_LIST_THREAD_EXIT))},
     [KERNEL_MEMBER_TIMER_INTERNAL] = {KERNEL_MEMBER_MAP_2, (SBITS(KERNEL_MEMBER_LIST_TIMER_STOP, KERNEL_MEMBER_LIST_TIMER_RUN))},
     [KERNEL_MEMBER_TIMER] = {KERNEL_MEMBER_MAP_3, (SBITS(KERNEL_MEMBER_LIST_TIMER_STOP, KERNEL_MEMBER_LIST_TIMER_RUN))},
-    [KERNEL_MEMBER_SEMAPHORE] = {KERNEL_MEMBER_MAP_4, (SBITS(KERNEL_MEMBER_LIST_SEMAPHORE_LOCK, KERNEL_MEMBER_LIST_SEMAPHORE_UNLOCK))},
+    [KERNEL_MEMBER_SEMAPHORE] = {KERNEL_MEMBER_MAP_4, (SBIT(KERNEL_MEMBER_LIST_SEMAPHORE_INIT))},
     [KERNEL_MEMBER_MUTEX] = {KERNEL_MEMBER_MAP_5, (SBITS(KERNEL_MEMBER_LIST_MUTEX_LOCK, KERNEL_MEMBER_LIST_MUTEX_UNLOCK))},
-    [KERNEL_MEMBER_EVENT] = {KERNEL_MEMBER_MAP_6, (SBITS(KERNEL_MEMBER_LIST_EVENT_INIT, KERNEL_MEMBER_LIST_EVENT_ACTIVE))},
+    [KERNEL_MEMBER_EVENT] = {KERNEL_MEMBER_MAP_6, (SBIT(KERNEL_MEMBER_LIST_EVENT_INIT))},
     [KERNEL_MEMBER_QUEUE] = {KERNEL_MEMBER_MAP_7, (SBIT(KERNEL_MEMBER_LIST_QUEUE_INIT))},
     [KERNEL_MEMBER_POOL] = {KERNEL_MEMBER_MAP_8, (SBIT(KERNEL_MEMBER_LIST_POOL_INIT))},
 };
@@ -348,6 +348,21 @@ u32_t kernel_schedule_time_get(void)
     return _kernel_pendsv_time_get();
 }
 
+/**
+ * @brief Push one semaphore context into lock list.
+ *
+ * @param pCurHead The pointer of the semaphore linker head.
+ */
+void kernel_semaphore_list_transfer_toInit(linker_head_t *pCurHead)
+{
+    ENTER_CRITICAL_SECTION();
+
+    list_t *pToLockList = (list_t *)(list_t *)kernel_member_list_get(KERNEL_MEMBER_SEMAPHORE, KERNEL_MEMBER_LIST_SEMAPHORE_INIT);
+    linker_list_transaction_common(&pCurHead->linker, pToLockList, LIST_TAIL);
+
+    EXIT_CRITICAL_SECTION();
+}
+
 /**
  * @brief kernel thread use percent value take.
  *
@@ -729,21 +744,6 @@ void kernel_thread_list_transfer_toPend(linker_head_t *pCurHead)
     EXIT_CRITICAL_SECTION();
 }
 
-/**
- * @brief Push one semaphore context into lock list.
- *
- * @param pCurHead The pointer of the semaphore linker head.
- */
-void kernel_semaphore_list_transfer_toLock(linker_head_t *pCurHead)
-{
-    ENTER_CRITICAL_SECTION();
-
-    list_t *pToLockList = (list_t *)(list_t *)kernel_member_list_get(KERNEL_MEMBER_SEMAPHORE, KERNEL_MEMBER_LIST_SEMAPHORE_LOCK);
-    linker_list_transaction_common(&pCurHead->linker, pToLockList, LIST_TAIL);
-
-    EXIT_CRITICAL_SECTION();
-}
-
 /**
  * @brief The thread is trying to exit into suspend.
  *

kernel/kthread.c

@@ -195,9 +195,8 @@ void kthread_init(void)
                         .pName = g_kernel_thread_resource.schedule_id.pName,
                         .linker = LINKER_NULL,
                     },
-                .initialCount = 0u,
-                .limitCount = OS_SEMPHORE_TICKET_BINARY,
-                .isPermit = FALSE, /* reduce useless thread calling */
+                .remains = 0u,
+                .limits = OS_SEMPHORE_TICKET_BINARY,
             },
     };
 
@@ -208,7 +207,7 @@ void kthread_init(void)
 
     pCurSemaphore =
         (semaphore_context_t *)kernel_member_unified_id_toContainerAddress(kernel_semaphore[KERNEL_SCHEDULE_SEMAPHORE_INSTANCE].head.id);
-    kernel_semaphore_list_transfer_toLock((linker_head_t *)&pCurSemaphore->head);
+    kernel_semaphore_list_transfer_toInit((linker_head_t *)&pCurSemaphore->head);
 }
 
 #ifdef __cplusplus