Sync. Work on optimalizations.

build-generic/make.sh

@@ -8,7 +8,7 @@ AR_FLAGS="rcs"
 
 BUILD=$(dirname $(realpath $0))
 SOURCE=$BUILD/../sources
-HEADERS=$BUILD/../headers/zivuos
+HEADERS=$BUILD/../headers
 OUTPUT=libzivuos.a
 
 rm -f $BUILD/*.o

build-wch-riscv/zivuos.mk

@@ -0,0 +1,7 @@
+ZIVUOS_DIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST)))/..)
+ZIVUOS_SOURCES := $(wildcard  $(ZIVUOS_DIR)/sources/*.c)
+ZIVUOS_CFLAGS += -I$(ZIVUOS_DIR)/headers/
+ZIVUOS_CFLAGS += -DZIVUOS_PLATFORM_WCH_RISCV
+
+CFLAGS += $(ZIVUOS_CFLAGS)
+ADDITIONAL_C_FILES += $(ZIVUOS_SOURCES)

headers/zivuos/kernel.h

@@ -7,23 +7,42 @@
 #include "zv_types.h"
 #include "task.h"
 
+/**
+ * @brief That return number of tasks from tasks array (x for zv_task_t [x]).
+ * Usefull for zv_kernel_init
+ */
 #define ZV_COUNT_TASKS(X) (sizeof(X) / sizeof(zv_task_t))
 
-typedef enum zv_scheduler_mode_e {
-    ZV_SCHEDULER_BASIC,
-    ZV_SCHEDULER_PRIORITY_STRICT,
-    ZV_SCHEDULER_PRIORITY_AGING,
-} zv_scheduler_mode_t;
-
+/**
+ * @brief That is main kernel structure. 
+ * It store pointer to tasks stack, and size of that stack.
+ */
 typedef struct zv_kernel_s {
-    zv_scheduler_mode_t scheduler;
+    
+    /** Pointer to tasks stack. */
     zv_task_t *tasks;
+
+    /** Size of tasks stack. */
     zv_tid_t tasks_count;
+
 } zv_kernel_t;
 
-bool zv_kernel_init(zv_kernel_t *self, zv_task_t *tasks, zv_tid_t count);
+/**
+ * @brief That initialize kernel structure.
+ * @param self Pointer to kernel structure to work on.
+ * @param tasks Pointer to tasks stack.
+ * @param count Number of tasks slots on stack.
+ */
+void zv_kernel_init(zv_kernel_t *self, zv_task_t *tasks, zv_tid_t count);
+
+/** 
+ * @brief That boot OS. It return when task stack is empty.
+ * @return True when everything is executed, and all tasks had been killed.
+ *         False when something went wrong.
+ */
 bool zv_kernel_boot(zv_kernel_t *self);
 
+
 zv_tid_t zv_kernel_create_process(
     zv_kernel_t *self,
     zv_worker_t worker,
@@ -31,7 +50,7 @@ zv_tid_t zv_kernel_create_process(
     void *param
 );
 
-bool zv_kernel_kill_process(
+void zv_kernel_kill_process(
     zv_kernel_t *self,
     zv_tid_t target
 );

headers/zivuos/zv_time.h

@@ -4,7 +4,11 @@
 #include "zv_types.h"
 
 typedef uint64_t zv_time_t;
+typedef uint32_t zv_ticks_t;
 
-zv_time_t zv_platform_get_time();
+void zv_platform_init(void);
+zv_time_t zv_platform_get_time(void);
+zv_ticks_t zv_platform_get_ticks(void);
+zv_ticks_t zv_platform_get_time_us(void);
 
 #endif

sources/event.c → sources/event.c.bak

@@ -2,11 +2,11 @@
 #include <stddef.h>
 #include <stdbool.h>
 
-#include "zv_types.h"
-#include "kernel.h"
-#include "task.h"
-#include "event.h"
-#include "zv_time.h"
+#include "zivuos/zv_types.h"
+#include "zivuos/kernel.h"
+#include "zivuos/task.h"
+#include "zivuos/event.h"
+#include "zivuos/zv_time.h"
 
 static inline bool __zv_event_empty(zv_event_t *self) {
     return self->type == ZV_EVENT_EMPTY;

sources/kernel.c

@@ -1,66 +1,27 @@
-#include <stddef.h>
-#include <stdint.h>
-
-#include "task.h"
-#include "kernel.h"
-#include "scheduler.h"
-
-bool zv_kernel_init(zv_kernel_t *self, zv_task_t *tasks, zv_tid_t count) {
-    if (self == NULL || tasks == NULL || count < 1) {
-        return false;
-    }
-
+#include <zivuos.h>
+
+/**
+ * @brief That initialize kernel structure.
+ * @param self Pointer to kernel structure to work on.
+ * @param tasks Pointer to tasks stack.
+ * @param count Number of tasks slots on stack.
+ */
+void zv_kernel_init(zv_kernel_t *self, zv_task_t *tasks, zv_tid_t count) {
     self->tasks = tasks;
     self->tasks_count = count;
-    self->scheduler = ZV_SCHEDULER_PRIORITY_AGING;
-
-    for (zv_tid_t count = 0; count < self->tasks_count; ++count) {
-        zv_task_t *current = self->tasks + count;
-        current->state = ZV_TASK_EMPTY;
-    }
-    
-    return true;
 }
 
-
+/** 
+ * @brief That boot OS. It return when task stack is empty.
+ * @return True when everything is executed, and all tasks had been killed.
+ *         False when something went wrong.
+ */
 bool zv_kernel_boot(zv_kernel_t *self) {
-    if (self == NULL || self->tasks == NULL || self->tasks_count < 1) {
-        return false;
-    }
-
     while (true) {
-        __zv_scheduler_update_tasks(self);
-        zv_task_t *next = __zv_scheduler_find_task(self);
-
-        if (next == NULL) {
-            break;
-        }
-
-        __zv_scheduler_run_task(self, next);
-    }   
-    
-    return true;
-}
-
-zv_tid_t __zv_kernel_get_empty_slot(zv_kernel_t *self) {
-    for (zv_tid_t count = 0; count < self->tasks_count; ++count) {
-        zv_task_t *current = self->tasks + count;
-        
-        if (current->state == ZV_TASK_EMPTY) {
-            return count;
-        }
+         
     }
-
-    return ZV_TID_NULL;
 }
 
-zv_task_t *__zv_kernel_get_task(zv_kernel_t *self, zv_tid_t target) {
-    if (self->tasks_count <= target) {
-        return NULL;
-    }
-
-    return self->tasks + target;
-}
 
 zv_tid_t zv_kernel_create_process(
     zv_kernel_t *self,
@@ -68,46 +29,49 @@ zv_tid_t zv_kernel_create_process(
     zv_priority_t priority,
     void *param
 ) {
-    if (self == NULL || worker == NULL) {
-        return ZV_TID_NULL;
-    }
-
-    zv_tid_t target_tid = __zv_kernel_get_empty_slot(self);
-    zv_task_t *target = __zv_kernel_get_task(self, target_tid);
+    zv_tid_t slot = __zv_kernel_get_empty_slot(self);
 
-    if (target == NULL) {
-        return ZV_TID_NULL;
+    if (slot == ZV_TID_NULL) {
+        return false;
     }
 
-    target->worker = worker;
+    zv_task_t target = self->tasks + slot;
+
     target->param = param;
+    target->worker = worker;
+    target->age = 0;
     target->priority = priority;
-    
-    target->event.type = ZV_EVENT_EMPTY;
-    target->event.content.unumber = 0x00;
-    
     target->state = ZV_TASK_READY;
-    return target_tid;
+
+    return slot;
 }
 
-bool zv_kernel_kill_process(
+void zv_kernel_kill_process(
     zv_kernel_t *self,
-    zv_tid_t target_tid
+    zv_tid_t target
 ) {
-    if (self == NULL) {
-        return false;
-    }
+    zv_task_t current = self->tasks + target; 
+    current->state = ZV_TASK_EMPTY;
+}
 
-    zv_task_t *target = __zv_kernel_get_task(self, target_tid);
+zv_tid_t __zv_kernel_get_empty_slot(zv_kernel_t *self) {
+    for (zv_tid_t count = 0; count < self->tasks_count; ++count) {
+        zv_task_t current = self->tasks + count;
 
-    if (target == NULL) {
-        return false;
+        if (current->state == ZV_TASK_EMPTY) {
+            return count;
+        }
     }
 
-    target->state = ZV_TASK_EMPTY;
-    return true;
+    return ZV_TID_NULL;
+}
+
+zv_task_t * __zv_kernel_get_task(zv_kernel_t *self, zv_tid_t target) {
+    return self->tasks + target;
 }
 
 zv_tid_t __zv_kernel_get_tid(zv_kernel_t *self, zv_task_t *target) {
     return target - self->tasks;
-}
+}       
+
+

sources/kernel.c.bak

@@ -0,0 +1,113 @@
+#include <stddef.h>
+#include <stdint.h>
+
+#include "zivuos/task.h"
+#include "zivuos/kernel.h"
+#include "zivuos/scheduler.h"
+
+bool zv_kernel_init(zv_kernel_t *self, zv_task_t *tasks, zv_tid_t count) {
+    if (self == NULL || tasks == NULL || count < 1) {
+        return false;
+    }
+
+    self->tasks = tasks;
+    self->tasks_count = count;
+    self->scheduler = ZV_SCHEDULER_PRIORITY_AGING;
+
+    for (zv_tid_t count = 0; count < self->tasks_count; ++count) {
+        zv_task_t *current = self->tasks + count;
+        current->state = ZV_TASK_EMPTY;
+    }
+    
+    return true;
+}
+
+
+bool zv_kernel_boot(zv_kernel_t *self) {
+    if (self == NULL || self->tasks == NULL || self->tasks_count < 1) {
+        return false;
+    }
+
+    while (true) {
+        __zv_scheduler_update_tasks(self);
+        zv_task_t *next = __zv_scheduler_find_task(self);
+
+        if (next == NULL) {
+            break;
+        }
+
+        __zv_scheduler_run_task(self, next);
+    }   
+    
+    return true;
+}
+
+zv_tid_t __zv_kernel_get_empty_slot(zv_kernel_t *self) {
+    for (zv_tid_t count = 0; count < self->tasks_count; ++count) {
+        zv_task_t *current = self->tasks + count;
+        
+        if (current->state == ZV_TASK_EMPTY) {
+            return count;
+        }
+    }
+
+    return ZV_TID_NULL;
+}
+
+zv_task_t *__zv_kernel_get_task(zv_kernel_t *self, zv_tid_t target) {
+    if (self->tasks_count <= target) {
+        return NULL;
+    }
+
+    return self->tasks + target;
+}
+
+zv_tid_t zv_kernel_create_process(
+    zv_kernel_t *self,
+    zv_worker_t worker,
+    zv_priority_t priority,
+    void *param
+) {
+    if (self == NULL || worker == NULL) {
+        return ZV_TID_NULL;
+    }
+
+    zv_tid_t target_tid = __zv_kernel_get_empty_slot(self);
+    zv_task_t *target = __zv_kernel_get_task(self, target_tid);
+
+    if (target == NULL) {
+        return ZV_TID_NULL;
+    }
+
+    target->worker = worker;
+    target->param = param;
+    target->priority = priority;
+    
+    target->event.type = ZV_EVENT_EMPTY;
+    target->event.content.unumber = 0x00;
+    
+    target->state = ZV_TASK_READY;
+    return target_tid;
+}
+
+bool zv_kernel_kill_process(
+    zv_kernel_t *self,
+    zv_tid_t target_tid
+) {
+    if (self == NULL) {
+        return false;
+    }
+
+    zv_task_t *target = __zv_kernel_get_task(self, target_tid);
+
+    if (target == NULL) {
+        return false;
+    }
+
+    target->state = ZV_TASK_EMPTY;
+    return true;
+}
+
+zv_tid_t __zv_kernel_get_tid(zv_kernel_t *self, zv_task_t *target) {
+    return target - self->tasks;
+}

sources/platform_linux.c → sources/platform_linux.c.bak

@@ -7,10 +7,14 @@
 #include <math.h>
 #include <time.h>
 
-#include "zv_types.h"
-#include "zv_time.h"
+#include "zivuos/zv_types.h"
+#include "zivuos/zv_time.h"
 
-zv_time_t zv_platform_get_time() {
+void zv_platform_init(void) {
+    
+}
+
+zv_time_t zv_platform_get_time(void) {
     struct timespec current_time;
 
     clock_gettime(CLOCK_REALTIME, &current_time);
@@ -30,4 +34,15 @@ zv_time_t zv_platform_get_time() {
     return result;
 }
 
+zv_ticks_t zv_platform_get_ticks(void) {
+    struct timespec current_time;
+
+    clock_gettime(CLOCK_REALTIME, &current_time);
+    return current_time.tv_nsec;
+}   
+
+zv_ticks_t zv_platform_get_time_us(void) {
+    return zv_platform_get_ticks() / 1000; 
+}
+
 #endif

sources/platform_wch_riscv.c.bak

@@ -0,0 +1,56 @@
+#ifdef ZIVUOS_PLATFORM_WCH_RISCV
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#include <ch32fun.h>
+
+#include "zivuos/zv_types.h"
+#include "zivuos/zv_time.h"
+
+#ifndef FUNCONF_SYSTEM_CORE_CLOCK
+#error "MCU core clock (FUNCONF_SYSTEM_CORE_CLOCK) not defined."
+#endif
+
+#define ZV_TICKS_PER_US ((uint32_t) FUNCONF_SYSTEM_CORE_CLOCK / 1000000)
+#define ZV_TICKS_PER_MS ((uint32_t) FUNCONF_SYSTEM_CORE_CLOCK / 1000)
+
+volatile uint32_t __zv_current_time_miliseconds;
+
+void zv_platform_init(void) {
+    __zv_current_time_miliseconds = 0;
+    
+    SysTick->CTLR = (
+        SYSTICK_CTLR_STE |
+        SYSTICK_CTLR_STCLK |
+        SYSTICK_CTLR_STIE
+    );
+
+    NVIC_EnableIRQ(SysTick_IRQn);
+
+    SysTick->CNT = 0x00;
+    SysTick->CMP = ZV_TICKS_PER_MS;
+}
+
+void SysTick_Handler(void) __attribute__((interrupt));
+void SysTick_Handler(void) {
+    SysTick->CMP += ZV_TICKS_PER_MS;
+    SysTick->SR = 0x00;
+
+    ++__zv_current_time_miliseconds;
+}
+
+zv_time_t zv_platform_get_time(void) {
+    return __zv_current_time_miliseconds;
+}
+
+zv_ticks_t zv_platform_get_ticks(void) {
+    return SysTick->CNT;
+}
+
+zv_ticks_t zv_platform_get_time_us(void) {
+    return SysTick->CNT / ZV_TICKS_PER_US;
+}
+
+#endif

sources/scheduler.c → sources/scheduler.c.bak

@@ -1,13 +1,13 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "task.h"
-#include "kernel.h"
-#include "scheduler.h"
-#include "zv_time.h"
+#include "zivuos/task.h"
+#include "zivuos/kernel.h"
+#include "zivuos/scheduler.h"
+#include "zivuos/zv_time.h"
 
 static bool __zv_scheduler_event_ready(
-    zv_kernel_t *,
+    zv_kernel_t *kernel,
     zv_task_t *target
 ) {
     zv_event_t *event = &target->event;
@@ -80,7 +80,7 @@ static zv_task_t * __zv_scheduler_priority_strict(zv_kernel_t *self) {
     }
 
     return found;
-}
+}*/
 
 static zv_task_t * __zv_scheduler_priority_aging(zv_kernel_t *self) {
     zv_task_t *found = NULL;
@@ -110,19 +110,7 @@ static zv_task_t * __zv_scheduler_priority_aging(zv_kernel_t *self) {
 }
 
 zv_task_t * __zv_scheduler_find_task(zv_kernel_t *self) {
-    switch (self->scheduler) {
-        case ZV_SCHEDULER_BASIC:
-            return __zv_scheduler_basic(self);
-
-        case ZV_SCHEDULER_PRIORITY_STRICT:
-            return __zv_scheduler_priority_strict(self);
-
-        case ZV_SCHEDULER_PRIORITY_AGING:
-            return __zv_scheduler_priority_aging(self);
-
-        default:
-            return NULL;
-    }
+    return __zv_scheduler_priority_aging(self);
 }
 
 void __zv_scheduler_run_task(zv_kernel_t *self, zv_task_t *target) {