Don't use mthread for the moment, use to much cpu

inc/lektor/thread.h

 #pragma once
 
 #include <lektor/define.h>
-#include <mthread/mthread.h>
+#include <pthread.h>
 #include <sys/types.h>
 
 struct poller_thread {
@@ -9,16 +9,16 @@ struct poller_thread {
     volatile unsigned int input_len;
     volatile unsigned int input_size;
     volatile void *volatile *volatile input_cells;
-    mthread_mutex_t input_lock;
+    pthread_mutex_t input_lock;
 
-    mthread_t th;
+    pthread_t th;
     unsigned int initial_size;
 
     /* The output pool. */
     volatile unsigned int output_len;
     volatile unsigned int output_size;
     volatile void *volatile *volatile output_cells;
-    mthread_mutex_t output_lock;
+    pthread_mutex_t output_lock;
 };
 
 struct poller_thread_arg {

src/main/server.c

@@ -57,7 +57,7 @@ main(int argc, char *argv[])
 
 normal_launch:
     LOG_INFO("Lektor launched by user %s (shell: %s, home: %s)", pw->pw_name, pw->pw_shell, pw->pw_dir);
-    mthread_init();
+    // mthread_init();
 
     return lkt_listen();
 }

src/repo/async.c

@@ -13,7 +13,7 @@
 
 static struct poller_thread repo_thread;
 
-static mthread_mutex_t mtx = MTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
 static volatile int init = 0;
 static volatile int stop = 0;
 static volatile int all_json = 0;
@@ -22,14 +22,14 @@ int
 repo_join_thread(void)
 {
     int ret = 1;
-    RETURN_IF(mthread_mutex_lock(&mtx), "Failed to lock mutex", 3);
+    RETURN_IF(pthread_mutex_lock(&mtx), "Failed to lock mutex", 3);
     GOTO_UNLESS(init, "Repo thread no launched, can't join", error);
     stop = 1;
-    GOTO_IF(mthread_join(repo_thread.th, NULL), "Failed to join repo thread", error);
+    GOTO_IF(pthread_join(repo_thread.th, NULL), "Failed to join repo thread", error);
     LOG_INFO("%s", "repo thread joined");
     ret = 0;
 error:
-    RETURN_IF(mthread_mutex_unlock(&mtx), "Failed to unlock mutex", 3);
+    RETURN_IF(pthread_mutex_unlock(&mtx), "Failed to unlock mutex", 3);
     return ret;
 }
 
@@ -113,7 +113,7 @@ __repo_thread_function(struct poller_thread_arg *arg)
     LOG_INFO("%s", "Starting the repo thread");
 
     for (;;) {
-        GOTO_IF(mthread_mutex_lock(&mtx), "Failed to lock mutex", end_loop);
+        GOTO_IF(pthread_mutex_lock(&mtx), "Failed to lock mutex", end_loop);
 
         if (all_json) {
             repo_get_alljson_sync(repo, &json);
@@ -122,7 +122,7 @@ __repo_thread_function(struct poller_thread_arg *arg)
         }
 
         if (stop) {
-            if (mthread_mutex_unlock(&mtx))
+            if (pthread_mutex_unlock(&mtx))
                 LOG_ERROR("Failed to unlock mutex: %s", strerror(errno));
             break;
         }
@@ -178,7 +178,7 @@ try_later:
             LOG_ERROR("%s", "Failed to get the head of the input list");
 
 end_loop:
-        mthread_yield();
+        sched_yield();
         sleep(1);
     }
 
@@ -226,8 +226,8 @@ err:
 inline int
 repo_get_allid_async(void)
 {
-    RETURN_IF(mthread_mutex_lock(&mtx), "Failed to lock mutex", 3);
+    RETURN_IF(pthread_mutex_lock(&mtx), "Failed to lock mutex", 3);
     all_json = 1;
-    RETURN_IF(mthread_mutex_unlock(&mtx), "Failed to lock mutex", 3);
+    RETURN_IF(pthread_mutex_unlock(&mtx), "Failed to lock mutex", 3);
     return 0;
 }

src/thread.c

@@ -2,7 +2,7 @@
 
 #include <common/common.h>
 #include <lektor/thread.h>
-#include <mthread/mthread.h>
+#include <pthread.h>
 #include <sys/types.h>
 #include <stdlib.h>
 #include <errno.h>
@@ -29,8 +29,8 @@ int
 lkt_th_new(struct poller_thread *th, unsigned int init_sizes,
            void *(*func)(struct poller_thread_arg *), void *args)
 {
-    mthread_mutex_t mtx1 = MTHREAD_MUTEX_INITIALIZER;
-    mthread_mutex_t mtx2 = MTHREAD_MUTEX_INITIALIZER;
+    pthread_mutex_t mtx1 = PTHREAD_MUTEX_INITIALIZER;
+    pthread_mutex_t mtx2 = PTHREAD_MUTEX_INITIALIZER;
     struct poller_thread th_ = {
         .initial_size   = init_sizes,
         .input_lock     = mtx1,
@@ -52,7 +52,7 @@ lkt_th_new(struct poller_thread *th, unsigned int init_sizes,
     __args->arg = args;
     __args->arg->self = th;
 
-    if(!mthread_create(&(th->th), NULL, __start, __args)) {
+    if(!pthread_create(&(th->th), NULL, __start, __args)) {
         LOG_INFO_SCT("THREAD", "%s", "Create a new poller thread");
         return 0;
     }
@@ -75,7 +75,7 @@ out_of_memory:
 int
 lkt_th_join(struct poller_thread *th, void **ret)
 {
-    int sta = mthread_join(th->th, ret);
+    int sta = pthread_join(th->th, ret);
 
     if (sta)
         LOG_ERROR("%s", "Failed to join thread");
@@ -94,12 +94,12 @@ lkt_th_join(struct poller_thread *th, void **ret)
 
 static inline int
 th_append(unsigned int *len, unsigned int *size, void ***cells,
-          mthread_mutex_t *lock, void *ptr)
+          pthread_mutex_t *lock, void *ptr)
 {
     void *new;
     int ret = 0;
 
-    GOTO_IF(mthread_mutex_lock(lock), "Failed to lock", end);
+    GOTO_IF(pthread_mutex_lock(lock), "Failed to lock", end);
 
     if (*len == *size) {
         new = realloc((void *) *cells, (*len + *size) * sizeof(void *));
@@ -117,16 +117,16 @@ th_append(unsigned int *len, unsigned int *size, void ***cells,
     (*cells)[(*len)++] = ptr;
     ret = 0;
 end:
-    RETURN_IF(mthread_mutex_unlock(lock), "Failed to lock", 1);
+    RETURN_IF(pthread_mutex_unlock(lock), "Failed to lock", 1);
     return ret;
 }
 
 static inline int
-th_pop(unsigned int *len, void **cells, mthread_mutex_t *lock, void **ptr)
+th_pop(unsigned int *len, void **cells, pthread_mutex_t *lock, void **ptr)
 {
     int ret = 1;
 
-    GOTO_IF(mthread_mutex_lock(lock), "Failed to lock", end);
+    GOTO_IF(pthread_mutex_lock(lock), "Failed to lock", end);
 
     if (*len > 0)
         *ptr = cells[--(*len)];
@@ -135,15 +135,15 @@ th_pop(unsigned int *len, void **cells, mthread_mutex_t *lock, void **ptr)
 
     ret = 0;
 end:
-    RETURN_IF(mthread_mutex_unlock(lock), "Failed to lock", 1);
+    RETURN_IF(pthread_mutex_unlock(lock), "Failed to lock", 1);
     return ret;
 }
 
 static inline int
-th_head(unsigned int len, void **cells, mthread_mutex_t *lock, void **ptr)
+th_head(unsigned int len, void **cells, pthread_mutex_t *lock, void **ptr)
 {
     int ret = 1;
-    GOTO_IF(mthread_mutex_lock(lock), "Failed to lock", end);
+    GOTO_IF(pthread_mutex_lock(lock), "Failed to lock", end);
 
     if (len > 0)
         *ptr = cells[len - 1];
@@ -152,7 +152,7 @@ th_head(unsigned int len, void **cells, mthread_mutex_t *lock, void **ptr)
 
     ret = 0;
 end:
-    RETURN_IF(mthread_mutex_unlock(lock), "Failed to lock", 1);
+    RETURN_IF(pthread_mutex_unlock(lock), "Failed to lock", 1);
     return ret;
 }