th_none.c

   1 /*
   2  * Copyright (C) 2024 Mikulas Patocka
   3  *
   4  * This file is part of Ajla.
   5  *
   6  * Ajla is free software: you can redistribute it and/or modify it under the
   7  * terms of the GNU General Public License as published by the Free Software
   8  * Foundation, either version 3 of the License, or (at your option) any later
   9  * version.
  10  *
  11  * Ajla is distributed in the hope that it will be useful, but WITHOUT ANY
  12  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  13  * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * Ajla. If not, see <https://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "ajla.h"
  20
  21 #include "obj_reg.h"
  22
  23 #include "thread.h"
  24
  25 #ifdef THREAD_NONE
  26
  27 #define MUTEX_INVALID           0
  28 #define MUTEX_UNLOCKED          1
  29 #define MUTEX_LOCKED            2
  30 #define MUTEX_LOCKED_WRITE      -1
  31
  32 #define do_mutex_init(m)                                                \
  33 do {                                                                    \
  34         (m)->state = MUTEX_UNLOCKED;                                    \
  35 } while (0)
  36
  37 #define do_mutex_done(m)                                                \
  38 do {                                                                    \
  39         if (unlikely((m)->state != MUTEX_UNLOCKED))                     \
  40                 internal(position_string(position_arg), "mutex_done: invalid mutex state %d", (m)->state);\
  41         (m)->state = MUTEX_INVALID;                                     \
  42 } while (0)
  43
  44 #define do_mutex_lock(m)                                                \
  45 do {                                                                    \
  46         if (unlikely((m)->state != MUTEX_UNLOCKED))                     \
  47                 internal(position_string(position_arg), "mutex_lock: invalid mutex state %d", (m)->state);\
  48         (m)->state = MUTEX_LOCKED;                                      \
  49 } while (0)
  50
  51 #define do_mutex_trylock(m)                                             \
  52 do {                                                                    \
  53         if (likely((m)->state == MUTEX_UNLOCKED)) {                     \
  54                 (m)->state = MUTEX_LOCKED;                              \
  55                 return true;                                            \
  56         }                                                               \
  57         if (unlikely((m)->state != MUTEX_LOCKED))                       \
  58                 internal(position_string(position_arg), "mutex_trylock: invalid mutex state %d", (m)->state);\
  59         return false;                                                   \
  60 } while (0)
  61
  62 #define do_mutex_unlock(m)                                              \
  63 do {                                                                    \
  64         if (unlikely((m)->state != MUTEX_LOCKED))                       \
  65                 internal(position_string(position_arg), "mutex_unlock: invalid mutex state %d", (m)->state);\
  66         (m)->state = MUTEX_UNLOCKED;                                    \
  67 } while (0)
  68
  69
  70 #define do_rwmutex_init(m)                                              \
  71 do {                                                                    \
  72         (m)->state = MUTEX_UNLOCKED;                                    \
  73 } while (0)
  74
  75 #define do_rwmutex_done(m)                                              \
  76 do {                                                                    \
  77         if (unlikely((m)->state != MUTEX_UNLOCKED))                     \
  78                 internal(position_string(position_arg), "rwmutex_done: invalid mutex state %d", (m)->state);\
  79         (m)->state = MUTEX_INVALID;                                     \
  80 } while (0)
  81
  82 #define do_rwmutex_lock_read(m)                                         \
  83 do {                                                                    \
  84         if (unlikely((m)->state < MUTEX_UNLOCKED))                      \
  85                 internal(position_string(position_arg), "rwmutex_lock_read: invalid mutex state %d", (m)->state);\
  86         (m)->state++;                                                   \
  87 } while (0)
  88
  89 #define do_rwmutex_unlock_read(m)                                       \
  90 do {                                                                    \
  91         if (unlikely((m)->state < MUTEX_LOCKED))                        \
  92                 internal(position_string(position_arg), "rwmutex_unlock_read: invalid mutex state %d", (m)->state);\
  93         (m)->state--;                                                   \
  94 } while (0)
  95
  96 #define do_rwmutex_lock_write(m)                                        \
  97 do {                                                                    \
  98         if (unlikely((m)->state != MUTEX_UNLOCKED))                     \
  99                 internal(position_string(position_arg), "rwmutex_lock_write: invalid mutex state %d", (m)->state);\
 100         (m)->state = MUTEX_LOCKED_WRITE;                                \
 101 } while (0)
 102
 103 #define do_rwmutex_unlock_write(m)                                      \
 104 do {                                                                    \
 105         if (unlikely((m)->state != MUTEX_LOCKED_WRITE))                 \
 106                 internal(position_string(position_arg), "rwmutex_unlock_write: invalid mutex state %d", (m)->state);\
 107         (m)->state = MUTEX_UNLOCKED;                                    \
 108 } while (0)
 109
 110
 111 #define do_cond_init(c)                                                 \
 112 do {                                                                    \
 113         mutex_init_position(&(c)->mutex pass_position);                 \
 114 } while (0)
 115
 116 #define do_cond_done(c)                                                 \
 117 do {                                                                    \
 118         mutex_done_position(&(c)->mutex pass_position);                 \
 119 } while (0)
 120
 121 #define do_cond_lock(c)                                                 \
 122 do {                                                                    \
 123         mutex_lock_position(&(c)->mutex pass_position);                 \
 124 } while (0)
 125
 126 #define do_cond_unlock(c)                                               \
 127 do {                                                                    \
 128         mutex_unlock_position(&(c)->mutex pass_position);               \
 129 } while (0)
 130
 131 #define do_cond_unlock_signal(c)                                        \
 132 do {                                                                    \
 133         mutex_unlock_position(&(c)->mutex pass_position);               \
 134 } while (0)
 135
 136 #define do_cond_unlock_broadcast(c)                                     \
 137 do {                                                                    \
 138         mutex_unlock_position(&(c)->mutex pass_position);               \
 139 } while (0)
 140
 141 #define do_cond_wait(c)                                                 \
 142 do {                                                                    \
 143         if (unlikely((c)->mutex.state != MUTEX_LOCKED))                 \
 144                 internal(position_string(position_arg), "cond_wait: invalid mutex state %d", (c)->mutex.state);\
 145 } while (0)
 146
 147 #define do_cond_wait_us(c, us)                                          \
 148 do {                                                                    \
 149         if (unlikely((c)->mutex.state != MUTEX_LOCKED))                 \
 150                 internal(position_string(position_arg), "do_cond_wait_us: invalid mutex state %d", (c)->mutex.state);\
 151         us = us + 1; /* avoid warning */                                \
 152         return false;                                                   \
 153 } while (0)
 154
 155
 156 #include "th_com.inc"
 157
 158 void thread_init(void)
 159 {
 160 }
 161
 162 void thread_done(void)
 163 {
 164 }
 165
 166 #endif