import RT-Thread@9217865c without bsp, libcpu and components/net
This commit is contained in:
Zihao Yu
commit
e2376a3709
1414 changed files with 390370 additions and 0 deletions
15
components/libc/cplusplus/Kconfig
Normal file
15
components/libc/cplusplus/Kconfig
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
menuconfig RT_USING_CPLUSPLUS
|
||||
bool "Enable C++ features"
|
||||
default n
|
||||
|
||||
if RT_USING_CPLUSPLUS
|
||||
|
||||
config RT_USING_CPLUSPLUS11
|
||||
bool "Enable c++11 threading feature support"
|
||||
default n
|
||||
select RT_USING_POSIX_FS
|
||||
select RT_USING_POSIX_STDIO
|
||||
select RT_USING_PTHREADS
|
||||
select RT_USING_RTC
|
||||
|
||||
endif
|
||||
52
components/libc/cplusplus/README.md
Normal file
52
components/libc/cplusplus/README.md
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
# C++ support for RT-Thread #
|
||||
|
||||
This is the C++ component in RT-Thread RTOS. In order to support C++ language, this component
|
||||
implement a basic environment, such as new/delete operators.
|
||||
|
||||
Because RT-Thread RTOS is used in embedded system mostly, there are some rules for C++ applications:
|
||||
|
||||
1. DOES NOT use exception.
|
||||
2. DOES NOT use Run-Time Type Information (RTTI).
|
||||
3. Template is discouraged and it easily causes code text large.
|
||||
4. Static class variables are discouraged. The time and place to call their constructor function could not be precisely controlled and make multi-threaded programming a nightmare.
|
||||
5. Multiple inheritance is strongly discouraged, as it can cause intolerable confusion.
|
||||
|
||||
About GNU GCC compiler
|
||||
|
||||
please add following string in your ld link script:
|
||||
|
||||
// in your .text section
|
||||
PROVIDE(__ctors_start__ = .);
|
||||
/* old GCC version uses .ctors */
|
||||
KEEP(*(SORT(.ctors.*)))
|
||||
KEEP(*(.ctors))
|
||||
/* new GCC version uses .init_array */
|
||||
KEEP (*(SORT(.init_array.*)))
|
||||
KEEP (*(.init_array))
|
||||
PROVIDE(__ctors_end__ = .);
|
||||
|
||||
. = ALIGN(4);
|
||||
|
||||
// as a standalone section if you use ARM target.
|
||||
|
||||
/* The .ARM.exidx section is used for C++ exception handling. */
|
||||
/* .ARM.exidx is sorted, so has to go in its own output section. */
|
||||
__exidx_start = .;
|
||||
ARM.exidx :
|
||||
{
|
||||
*(.ARM.exidx* .gnu.linkonce.armexidx.*)
|
||||
|
||||
/* This is used by the startup in order to initialize the .data secion */
|
||||
_sidata = .;
|
||||
} > CODE
|
||||
__exidx_end = .;
|
||||
|
||||
/* .data section which is used for initialized data */
|
||||
|
||||
// in your .data section
|
||||
PROVIDE(__dtors_start__ = .);
|
||||
KEEP(*(SORT(.dtors.*)))
|
||||
KEEP(*(.dtors))
|
||||
PROVIDE(__dtors_end__ = .);
|
||||
|
||||
. = ALIGN(4);
|
||||
21
components/libc/cplusplus/SConscript
Normal file
21
components/libc/cplusplus/SConscript
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
# RT-Thread building script for component
|
||||
|
||||
from building import *
|
||||
Import('rtconfig')
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Glob('*.cpp') + Glob('*.c')
|
||||
CPPPATH = [cwd]
|
||||
|
||||
if GetDepend('RT_USING_CPLUSPLUS11'):
|
||||
src += Glob('cpp11/*.cpp') + Glob('cpp11/*.c')
|
||||
if rtconfig.PLATFORM in ['armclang']:
|
||||
src += Glob('cpp11/armclang/*.cpp') + Glob('cpp11/armclang/*.c')
|
||||
CPPPATH += [cwd + '/cpp11/armclang']
|
||||
elif rtconfig.PLATFORM in ['gcc']:
|
||||
src += Glob('cpp11/gcc/*.cpp') + Glob('cpp11/gcc/*.c')
|
||||
CPPPATH += [cwd + '/cpp11/gcc']
|
||||
|
||||
group = DefineGroup('CPlusPlus', src, depend = ['RT_USING_CPLUSPLUS'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
49
components/libc/cplusplus/cpp11/README.md
Normal file
49
components/libc/cplusplus/cpp11/README.md
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
# C++ 11 support for RT-Thread
|
||||
|
||||
## Features
|
||||
|
||||
Here are some features about rt-thread c++11 threading futures.
|
||||
|
||||
- Atomic.
|
||||
- Conditional variables.
|
||||
- Clocks.
|
||||
- Future.
|
||||
- Mutexes.
|
||||
- Threads.
|
||||
- TLS.
|
||||
|
||||
## How To Use
|
||||
|
||||
Note that using C++ 11 in rt-thread requires modifying some of the files in the toolchain. Before modifying the tool, back up the tool chain.
|
||||
|
||||
1. Enable c++11 support
|
||||
|
||||
|
||||
|
||||
2. Download toolchain GCC 10.2.1:
|
||||
|
||||
```shell
|
||||
gcc version 10.2.1 20201103 (release) (GNU Arm Embedded Toolchain 10-2020-q4-major)
|
||||
```
|
||||
|
||||
3. Delete the following files:
|
||||
|
||||
```shell
|
||||
rm -f toolchain/arm-none-eabi/include/c++/10.2.1/thread
|
||||
rm -f toolchain/arm-none-eabi/include/c++/10.2.1/mutex
|
||||
rm -f toolchain/arm-none-eabi/include/c++/10.2.1/condition_variable
|
||||
rm -f toolchain/arm-none-eabi/include/c++/10.2.1/future
|
||||
rm -f toolchain/arm-none-eabi/include/pthread.h
|
||||
```
|
||||
|
||||
4. Clear the contents of the following files and keep them to prevent compilation failures:
|
||||
|
||||
```shell
|
||||
toolchain/arm-none-eabi/include/sys/_pthreadtypes.h
|
||||
```
|
||||
|
||||
5. Update `rtconfig.py` file. add compilation parameters:
|
||||
|
||||
```shell
|
||||
CXXFLAGS = CFLAGS + ' -std=c++11 -fabi-version=0 -MMD -MP -MF'
|
||||
```
|
||||
48
components/libc/cplusplus/cpp11/README_ZH.md
Normal file
48
components/libc/cplusplus/cpp11/README_ZH.md
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
# cpp 11 support for rt-thread
|
||||
|
||||
## 特性
|
||||
|
||||
下面是 RT-Thread 支持的 C++ 11 线程特性。
|
||||
|
||||
- Atomic.
|
||||
- Conditional variables.
|
||||
- Clocks.
|
||||
- Future.
|
||||
- Mutexes.
|
||||
- Threads.
|
||||
- TLS.
|
||||
|
||||
## 如何使用
|
||||
|
||||
请注意，在 RT-Thread 中使用 C++ 11，需要修改工具链中的部分文件。请在修改之前，备份好工具链。
|
||||
|
||||
1. 使能 c++11
|
||||
|
||||
|
||||
2. 下载 GCC 工具链
|
||||
|
||||
```shell
|
||||
gcc version 10.2.1 20201103 (release) (GNU Arm Embedded Toolchain 10-2020-q4-major)
|
||||
```
|
||||
|
||||
3. 删除下面的文件
|
||||
|
||||
```shell
|
||||
rm -f toolchain/arm-none-eabi/include/c++/10.2.1/thread
|
||||
rm -f toolchain/arm-none-eabi/include/c++/10.2.1/mutex
|
||||
rm -f toolchain/arm-none-eabi/include/c++/10.2.1/condition_variable
|
||||
rm -f toolchain/arm-none-eabi/include/c++/10.2.1/future
|
||||
rm -f toolchain/arm-none-eabi/include/pthread.h
|
||||
```
|
||||
|
||||
4. 请清除下面文件的内容，保留文件避免编译失败
|
||||
|
||||
```shell
|
||||
toolchain/arm-none-eabi/include/sys/_pthreadtypes.h
|
||||
```
|
||||
|
||||
5. 更新 `rtconfig.py` 文件，添加 c++ 编译参数:
|
||||
|
||||
```shell
|
||||
CXXFLAGS = CFLAGS + ' -std=c++11 -fabi-version=0 -MMD -MP -MF'
|
||||
```
|
||||
29
components/libc/cplusplus/cpp11/armclang/clock.cpp
Normal file
29
components/libc/cplusplus/cpp11/armclang/clock.cpp
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include <arm-tpl.h>
|
||||
#include <sys/time.h>
|
||||
#include <rtthread.h>
|
||||
|
||||
extern "C" int __ARM_TPL_clock_realtime(__ARM_TPL_timespec_t* __ts)
|
||||
{
|
||||
unsigned int t = std::time(nullptr);
|
||||
__ts->tv_sec = t;
|
||||
__ts->tv_nsec = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_clock_monotonic(__ARM_TPL_timespec_t* __ts)
|
||||
{
|
||||
unsigned int t = rt_tick_get();
|
||||
__ts->tv_sec = t / RT_TICK_PER_SECOND;
|
||||
__ts->tv_nsec = (t %RT_TICK_PER_SECOND) * NANOSECOND_PER_TICK ;
|
||||
return 0;
|
||||
}
|
||||
178
components/libc/cplusplus/cpp11/armclang/condvar.cpp
Normal file
178
components/libc/cplusplus/cpp11/armclang/condvar.cpp
Normal file
|
|
@ -0,0 +1,178 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include <arm-tpl.h>
|
||||
#include "tpl.h"
|
||||
#include <new>
|
||||
#include <cstdint>
|
||||
#include <stdatomic.h>
|
||||
|
||||
arm_tpl_cv::arm_tpl_cv()
|
||||
{
|
||||
s = rt_sem_create("semxs", 0, RT_IPC_FLAG_PRIO);
|
||||
if (s == nullptr)
|
||||
RT_ASSERT(0);
|
||||
h = rt_sem_create("semxh", 0, RT_IPC_FLAG_PRIO);
|
||||
if (h == nullptr)
|
||||
{
|
||||
rt_sem_delete(s);
|
||||
RT_ASSERT(0);
|
||||
}
|
||||
x = rt_mutex_create("mutx", RT_IPC_FLAG_PRIO);
|
||||
if (x == nullptr)
|
||||
{
|
||||
rt_sem_delete(s);
|
||||
rt_sem_delete(h);
|
||||
RT_ASSERT(0);
|
||||
}
|
||||
}
|
||||
|
||||
arm_tpl_cv::~arm_tpl_cv()
|
||||
{
|
||||
rt_mutex_delete(x);
|
||||
rt_sem_delete(h);
|
||||
rt_sem_delete(s);
|
||||
}
|
||||
|
||||
void arm_tpl_cv::wait(rt_mutex_t lock, bool recursive)
|
||||
{
|
||||
while (rt_mutex_take(x, ARM_TPL_MAX_DELAY) != 0);
|
||||
rt_sem_release(s);
|
||||
rt_mutex_release(x);
|
||||
if (recursive)
|
||||
rt_mutex_release(lock);
|
||||
else
|
||||
rt_mutex_release(lock);
|
||||
while (rt_sem_take(h, ARM_TPL_MAX_DELAY) != 0);
|
||||
if (recursive)
|
||||
while (rt_mutex_take(lock, ARM_TPL_MAX_DELAY) != 0);
|
||||
else
|
||||
while (rt_mutex_take(lock, ARM_TPL_MAX_DELAY) != 0);
|
||||
}
|
||||
|
||||
int arm_tpl_cv::timedwait(rt_mutex_t lock, bool recursive, unsigned int timeout_ms)
|
||||
{
|
||||
int result = 0;
|
||||
while (rt_mutex_take(x, ARM_TPL_MAX_DELAY) != 0);
|
||||
rt_sem_release(s);
|
||||
rt_mutex_release(x);
|
||||
if (recursive)
|
||||
rt_mutex_release(lock);
|
||||
else
|
||||
rt_mutex_release(lock);
|
||||
if (rt_sem_take(h, rt_tick_from_millisecond(timeout_ms)) != 0)
|
||||
{
|
||||
while (rt_mutex_take(x, ARM_TPL_MAX_DELAY) != 0);
|
||||
if (rt_sem_take(h, 0) != 0)
|
||||
{
|
||||
if (rt_sem_take(s, 0) != 0)
|
||||
result = -1;
|
||||
else
|
||||
result = 1;
|
||||
}
|
||||
rt_mutex_release(x);
|
||||
}
|
||||
if (recursive)
|
||||
while (rt_mutex_take(lock, ARM_TPL_MAX_DELAY) != 0);
|
||||
else
|
||||
while (rt_mutex_take(lock, ARM_TPL_MAX_DELAY) != 0);
|
||||
return result;
|
||||
}
|
||||
|
||||
void arm_tpl_cv::signal()
|
||||
{
|
||||
while (rt_mutex_take(x, ARM_TPL_MAX_DELAY) != 0);
|
||||
if (rt_sem_take(s, 0) == 0)
|
||||
rt_sem_release(h);
|
||||
rt_mutex_release(x);
|
||||
}
|
||||
|
||||
void arm_tpl_cv::broadcast()
|
||||
{
|
||||
while (rt_mutex_take(x, ARM_TPL_MAX_DELAY) != 0);
|
||||
auto count = s->value;
|
||||
for (auto i = 0; i < count; i++)
|
||||
{
|
||||
while (rt_sem_take(s, ARM_TPL_MAX_DELAY) != 0);
|
||||
rt_sem_release(h);
|
||||
}
|
||||
rt_mutex_release(x);
|
||||
}
|
||||
|
||||
static int check_create(volatile __ARM_TPL_condvar_t *__vcv)
|
||||
{
|
||||
if (__vcv->data == 0)
|
||||
{
|
||||
uintptr_t cv_new;
|
||||
cv_new = reinterpret_cast<uintptr_t>(new arm_tpl_cv());
|
||||
if (cv_new == 0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
uintptr_t cv_null = 0;
|
||||
if (!atomic_compare_exchange_strong(&__vcv->data, &cv_null, cv_new))
|
||||
delete reinterpret_cast<arm_tpl_cv *>(cv_new);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_condvar_wait(__ARM_TPL_condvar_t *__cv, __ARM_TPL_mutex_t *__m)
|
||||
{
|
||||
volatile __ARM_TPL_condvar_t *__vcv = __cv;
|
||||
if (check_create(__vcv) != 0)
|
||||
return -1;
|
||||
struct arm_tpl_mutex_struct *tmutex = (struct arm_tpl_mutex_struct *)(__m->data);
|
||||
((arm_tpl_cv *) __vcv->data)->wait(tmutex->mutex, tmutex->type == RECURSIVE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_condvar_timedwait(__ARM_TPL_condvar_t *__cv,
|
||||
__ARM_TPL_mutex_t *__m,
|
||||
__ARM_TPL_timespec_t *__ts)
|
||||
{
|
||||
volatile __ARM_TPL_condvar_t *__vcv = __cv;
|
||||
if (check_create(__vcv) != 0)
|
||||
return -1;
|
||||
__ARM_TPL_timespec_t now;
|
||||
if (__ARM_TPL_clock_realtime(&now) != 0)
|
||||
return -1;
|
||||
struct arm_tpl_mutex_struct *tmutex = (struct arm_tpl_mutex_struct *)(__m->data);
|
||||
unsigned int timeout_ms = (__ts->tv_sec - now.tv_sec) * 1000 + (__ts->tv_nsec - now.tv_nsec) / 1000000;
|
||||
if (((arm_tpl_cv *) __vcv->data)->timedwait(tmutex->mutex, tmutex->type == RECURSIVE, timeout_ms) < 0)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_condvar_signal(__ARM_TPL_condvar_t *__cv)
|
||||
{
|
||||
volatile __ARM_TPL_condvar_t *__vcv = __cv;
|
||||
if (__vcv->data != 0)
|
||||
((arm_tpl_cv *) __vcv->data)->signal();
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_condvar_broadcast(__ARM_TPL_condvar_t *__cv)
|
||||
{
|
||||
volatile __ARM_TPL_condvar_t *__vcv = __cv;
|
||||
if (__vcv->data != 0)
|
||||
((arm_tpl_cv *) __vcv->data)->broadcast();
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_condvar_destroy(__ARM_TPL_condvar_t *__cv)
|
||||
{
|
||||
volatile __ARM_TPL_condvar_t *__vcv = __cv;
|
||||
if (__vcv->data != 0)
|
||||
{
|
||||
delete (arm_tpl_cv *) __vcv->data;
|
||||
__vcv->data = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
22
components/libc/cplusplus/cpp11/armclang/miscellaneous.cpp
Normal file
22
components/libc/cplusplus/cpp11/armclang/miscellaneous.cpp
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include <arm-tpl.h>
|
||||
|
||||
extern "C" int __ARM_TPL_execute_once(__ARM_TPL_exec_once_flag *__flag,
|
||||
void (*__init_routine)(void))
|
||||
{
|
||||
if (*__flag == 0)
|
||||
{
|
||||
__init_routine();
|
||||
*__flag = 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
108
components/libc/cplusplus/cpp11/armclang/mutex.cpp
Normal file
108
components/libc/cplusplus/cpp11/armclang/mutex.cpp
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include <arm-tpl.h>
|
||||
#include <cstdint>
|
||||
#include <stdatomic.h>
|
||||
#include "tpl.h"
|
||||
|
||||
static int check_create(volatile __ARM_TPL_mutex_t *__vm, bool recursive = false)
|
||||
{
|
||||
if (__vm->data == 0)
|
||||
{
|
||||
uintptr_t mut_null = 0;
|
||||
arm_tpl_mutex_struct *mutex_p = (arm_tpl_mutex_struct *)rt_malloc(sizeof(arm_tpl_mutex_struct));
|
||||
if (mutex_p == nullptr) return -1;
|
||||
|
||||
if (recursive)
|
||||
mutex_p->mutex = rt_mutex_create("mutexx", RT_IPC_FLAG_PRIO);
|
||||
else
|
||||
mutex_p->mutex = rt_mutex_create("mutexx", RT_IPC_FLAG_PRIO);
|
||||
|
||||
if (mutex_p->mutex == nullptr)
|
||||
{
|
||||
rt_free(mutex_p);
|
||||
return -1;
|
||||
}
|
||||
mutex_p->type = recursive ? RECURSIVE : NORMAL;
|
||||
uintptr_t mut_new = reinterpret_cast<uintptr_t>(mutex_p);
|
||||
if (!atomic_compare_exchange_strong(&__vm->data, &mut_null, mut_new))
|
||||
{
|
||||
rt_mutex_delete(mutex_p->mutex);
|
||||
rt_free(mutex_p);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mutexLock(arm_tpl_mutex_struct *mutex_p, rt_tick_t timeOut)
|
||||
{
|
||||
if (mutex_p->type == RECURSIVE)
|
||||
{
|
||||
if (rt_mutex_take(mutex_p->mutex, timeOut) == 0)
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (rt_mutex_take(mutex_p->mutex, timeOut) == 0)
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int mutexUnlock(arm_tpl_mutex_struct *mutex_p)
|
||||
{
|
||||
if (mutex_p->type == RECURSIVE)
|
||||
rt_mutex_release(mutex_p->mutex);
|
||||
else
|
||||
rt_mutex_release(mutex_p->mutex);
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_recursive_mutex_init(__ARM_TPL_mutex_t *__m)
|
||||
{
|
||||
volatile __ARM_TPL_mutex_t *__vm = __m;
|
||||
return check_create(__vm, true);
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_mutex_lock(__ARM_TPL_mutex_t *__m)
|
||||
{
|
||||
volatile __ARM_TPL_mutex_t *__vm = __m;
|
||||
if (check_create(__vm))
|
||||
return -1;
|
||||
while (mutexLock((arm_tpl_mutex_struct *)(__vm->data), ARM_TPL_MAX_DELAY) != 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_mutex_trylock(__ARM_TPL_mutex_t *__m)
|
||||
{
|
||||
volatile __ARM_TPL_mutex_t *__vm = __m;
|
||||
if (check_create(__vm))
|
||||
return -1;
|
||||
return mutexLock((arm_tpl_mutex_struct *)(__vm->data), 0);
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_mutex_unlock(__ARM_TPL_mutex_t *__m)
|
||||
{
|
||||
volatile __ARM_TPL_mutex_t *__vm = __m;
|
||||
return mutexUnlock((arm_tpl_mutex_struct *)(__vm->data));
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_mutex_destroy(__ARM_TPL_mutex_t *__m)
|
||||
{
|
||||
volatile __ARM_TPL_mutex_t *__vm = __m;
|
||||
if (__vm->data != 0)
|
||||
{
|
||||
rt_mutex_delete(((arm_tpl_mutex_struct *)(__vm->data))->mutex);
|
||||
rt_free((void *)(__vm->data));
|
||||
__vm->data = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
120
components/libc/cplusplus/cpp11/armclang/thread.cpp
Normal file
120
components/libc/cplusplus/cpp11/armclang/thread.cpp
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include <arm-tpl.h>
|
||||
#include "tpl.h"
|
||||
#include <cstdio>
|
||||
#include <pthread.h>
|
||||
|
||||
#define CPP11_DEFAULT_ID_OFFSET 1
|
||||
|
||||
extern "C" int __ARM_TPL_thread_create(__ARM_TPL_thread_t *__t,
|
||||
void *(*__func)(void *),
|
||||
void *__arg)
|
||||
{
|
||||
int ret = 0;
|
||||
pthread_t pid;
|
||||
ret = pthread_create(&pid, RT_NULL, __func, __arg);
|
||||
if (ret == 0)
|
||||
{
|
||||
__t->data = (std::uintptr_t)pid + CPP11_DEFAULT_ID_OFFSET;
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_thread_id_compare(__ARM_TPL_thread_id __tid1,
|
||||
__ARM_TPL_thread_id __tid2)
|
||||
{
|
||||
if (__tid1 > __tid2)
|
||||
return 1;
|
||||
else if (__tid1 < __tid2)
|
||||
return -1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" __ARM_TPL_thread_id __ARM_TPL_thread_get_current_id()
|
||||
{
|
||||
return (__ARM_TPL_thread_id)pthread_self();
|
||||
}
|
||||
|
||||
extern "C" __ARM_TPL_thread_id __ARM_TPL_thread_get_id(
|
||||
const __ARM_TPL_thread_t *__t)
|
||||
{
|
||||
return (__ARM_TPL_thread_id)(((pthread_t)__t->data - CPP11_DEFAULT_ID_OFFSET));
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_thread_join(__ARM_TPL_thread_t *__t)
|
||||
{
|
||||
pthread_join(((pthread_t)__t->data - CPP11_DEFAULT_ID_OFFSET), RT_NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_thread_detach(__ARM_TPL_thread_t *__t)
|
||||
{
|
||||
pthread_detach(((pthread_t)__t->data - CPP11_DEFAULT_ID_OFFSET));
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" void __ARM_TPL_thread_yield()
|
||||
{
|
||||
rt_thread_yield();
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_thread_nanosleep(const __ARM_TPL_timespec_t *__req,
|
||||
__ARM_TPL_timespec_t *__rem)
|
||||
{
|
||||
rt_tick_t tick;
|
||||
|
||||
tick = __req->tv_sec * RT_TICK_PER_SECOND + (__req->tv_nsec * RT_TICK_PER_SECOND)/ 1000000000;
|
||||
rt_thread_delay(tick);
|
||||
|
||||
if (__rem)
|
||||
{
|
||||
tick = rt_tick_get() - tick;
|
||||
/* get the passed time */
|
||||
__rem->tv_sec = tick/RT_TICK_PER_SECOND;
|
||||
__rem->tv_nsec = (tick%RT_TICK_PER_SECOND) * (1000000000/RT_TICK_PER_SECOND);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" unsigned __ARM_TPL_thread_hw_concurrency()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_tls_create(__ARM_TPL_tls_key *__key,
|
||||
void (*__at_exit)(void *))
|
||||
{
|
||||
pthread_key_t key;
|
||||
|
||||
if (pthread_key_create(&key, __at_exit) == 0)
|
||||
{
|
||||
*__key = key;
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
extern "C" void *__ARM_TPL_tls_get(__ARM_TPL_tls_key __key)
|
||||
{
|
||||
return pthread_getspecific(__key);
|
||||
}
|
||||
|
||||
extern "C" int __ARM_TPL_tls_set(__ARM_TPL_tls_key __key, void *__p)
|
||||
{
|
||||
if (pthread_setspecific(__key, (void*)__p) != 0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
56
components/libc/cplusplus/cpp11/armclang/tpl.h
Normal file
56
components/libc/cplusplus/cpp11/armclang/tpl.h
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#ifndef __cplusplus
|
||||
void ARMTPLInit();
|
||||
#else
|
||||
#include <rtthread.h>
|
||||
|
||||
#define ARM_TPL_MAX_DELAY 1000
|
||||
#define ARM_TPL_THREAD_STACK_SIZE 4096
|
||||
|
||||
enum arm_tpl_mutex_type
|
||||
{
|
||||
NORMAL,
|
||||
RECURSIVE,
|
||||
};
|
||||
|
||||
struct arm_tpl_mutex_struct
|
||||
{
|
||||
rt_mutex_t mutex;
|
||||
arm_tpl_mutex_type type;
|
||||
};
|
||||
|
||||
struct arm_tpl_thread_struct
|
||||
{
|
||||
rt_thread_t task;
|
||||
void *(*func)(void *);
|
||||
void *arg;
|
||||
rt_sem_t join_sem;
|
||||
rt_sem_t detach_sem;
|
||||
};
|
||||
|
||||
class arm_tpl_cv
|
||||
{
|
||||
public:
|
||||
arm_tpl_cv();
|
||||
~arm_tpl_cv();
|
||||
void wait(rt_mutex_t lock, bool recursive);
|
||||
int timedwait(rt_mutex_t lock, bool recursive, unsigned int timeout_ms);
|
||||
void signal();
|
||||
void broadcast();
|
||||
private:
|
||||
rt_sem_t s;
|
||||
rt_sem_t h;
|
||||
rt_mutex_t x;
|
||||
};
|
||||
|
||||
#endif
|
||||
88
components/libc/cplusplus/cpp11/atomic_8.c
Normal file
88
components/libc/cplusplus/cpp11/atomic_8.c
Normal file
|
|
@ -0,0 +1,88 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 peterfan Add copyright header.
|
||||
*/
|
||||
|
||||
#include <rthw.h>
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
/*
|
||||
* override gcc builtin atomic function for std::atomic<int64_t>, std::atomic<uint64_t>
|
||||
* @see https://gcc.gnu.org/onlinedocs/gcc/_005f_005fatomic-Builtins.html
|
||||
*/
|
||||
uint64_t __atomic_load_8(volatile void *ptr, int memorder)
|
||||
{
|
||||
volatile uint64_t *val_ptr = (volatile uint64_t *)ptr;
|
||||
rt_base_t level;
|
||||
uint64_t tmp;
|
||||
level = rt_hw_interrupt_disable();
|
||||
tmp = *val_ptr;
|
||||
rt_hw_interrupt_enable(level);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
void __atomic_store_8(volatile void *ptr, uint64_t val, int memorder)
|
||||
{
|
||||
volatile uint64_t *val_ptr = (volatile uint64_t *)ptr;
|
||||
rt_base_t level;
|
||||
level = rt_hw_interrupt_disable();
|
||||
*val_ptr = val;
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
|
||||
uint64_t __atomic_exchange_8(volatile void *ptr, uint64_t val, int memorder)
|
||||
{
|
||||
volatile uint64_t *val_ptr = (volatile uint64_t *)ptr;
|
||||
rt_base_t level;
|
||||
uint64_t tmp;
|
||||
level = rt_hw_interrupt_disable();
|
||||
tmp = *val_ptr;
|
||||
*val_ptr = val;
|
||||
rt_hw_interrupt_enable(level);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
bool __atomic_compare_exchange_8(volatile void *ptr, volatile void *expected, uint64_t desired, bool weak, int success_memorder, int failure_memorder)
|
||||
{
|
||||
volatile uint64_t *val_ptr = (volatile uint64_t *)ptr;
|
||||
volatile uint64_t *expected_ptr = (volatile uint64_t *)expected;
|
||||
rt_base_t level;
|
||||
bool exchanged;
|
||||
level = rt_hw_interrupt_disable();
|
||||
if (*val_ptr == *expected_ptr)
|
||||
{
|
||||
*val_ptr = desired;
|
||||
exchanged = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
*expected_ptr = *val_ptr;
|
||||
exchanged = false;
|
||||
}
|
||||
rt_hw_interrupt_enable(level);
|
||||
return exchanged;
|
||||
}
|
||||
|
||||
#define __atomic_fetch_op_8(OPNAME, OP) \
|
||||
uint64_t __atomic_fetch_##OPNAME##_8(volatile void *ptr, uint64_t val, int memorder) {\
|
||||
volatile uint64_t* val_ptr = (volatile uint64_t*)ptr;\
|
||||
rt_base_t level;\
|
||||
uint64_t tmp;\
|
||||
level = rt_hw_interrupt_disable();\
|
||||
tmp = *val_ptr;\
|
||||
*val_ptr OP##= val;\
|
||||
rt_hw_interrupt_enable(level);\
|
||||
return tmp;\
|
||||
}
|
||||
|
||||
__atomic_fetch_op_8(add, +)
|
||||
__atomic_fetch_op_8(sub, -)
|
||||
__atomic_fetch_op_8( and, &)
|
||||
__atomic_fetch_op_8( or, |)
|
||||
__atomic_fetch_op_8(xor, ^)
|
||||
208
components/libc/cplusplus/cpp11/emutls.c
Normal file
208
components/libc/cplusplus/cpp11/emutls.c
Normal file
|
|
@ -0,0 +1,208 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 peterfan Add copyright header.
|
||||
*/
|
||||
|
||||
/* ===---------- emutls.c - Implements __emutls_get_address ---------------===
|
||||
*
|
||||
* The LLVM Compiler Infrastructure
|
||||
*
|
||||
* This file is dual licensed under the MIT and the University of Illinois Open
|
||||
* Source Licenses. See LICENSE.TXT for details.
|
||||
*
|
||||
* ===----------------------------------------------------------------------===
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
extern int pthread_key_create(pthread_key_t *key, void (*destructor)(void *));
|
||||
extern int pthread_key_delete(pthread_key_t key);
|
||||
extern void *pthread_getspecific(pthread_key_t key);
|
||||
extern int pthread_setspecific(pthread_key_t key, const void *value);
|
||||
|
||||
/* Default is not to use posix_memalign, so systems like Android
|
||||
* can use thread local data without heavier POSIX memory allocators.
|
||||
*/
|
||||
#ifndef EMUTLS_USE_POSIX_MEMALIGN
|
||||
#define EMUTLS_USE_POSIX_MEMALIGN 0
|
||||
#endif
|
||||
|
||||
/* For every TLS variable xyz,
|
||||
* there is one __emutls_control variable named __emutls_v.xyz.
|
||||
* If xyz has non-zero initial value, __emutls_v.xyz's "value"
|
||||
* will point to __emutls_t.xyz, which has the initial value.
|
||||
*/
|
||||
typedef struct __emutls_control
|
||||
{
|
||||
size_t size; /* size of the object in bytes */
|
||||
size_t align; /* alignment of the object in bytes */
|
||||
union
|
||||
{
|
||||
uintptr_t index; /* data[index-1] is the object address */
|
||||
void *address; /* object address, when in single thread env */
|
||||
} object;
|
||||
void *value; /* null or non-zero initial value for the object */
|
||||
} __emutls_control;
|
||||
|
||||
static __inline void *emutls_memalign_alloc(size_t align, size_t size)
|
||||
{
|
||||
void *base;
|
||||
#if EMUTLS_USE_POSIX_MEMALIGN
|
||||
if (posix_memalign(&base, align, size) != 0)
|
||||
abort();
|
||||
#else
|
||||
#define EXTRA_ALIGN_PTR_BYTES (align - 1 + sizeof(void *))
|
||||
char *object;
|
||||
if ((object = (char *)malloc(EXTRA_ALIGN_PTR_BYTES + size)) == NULL)
|
||||
abort();
|
||||
base = (void *)(((uintptr_t)(object + EXTRA_ALIGN_PTR_BYTES)) & ~(uintptr_t)(align - 1));
|
||||
|
||||
((void **)base)[-1] = object;
|
||||
#endif
|
||||
return base;
|
||||
}
|
||||
|
||||
static __inline void emutls_memalign_free(void *base)
|
||||
{
|
||||
#if EMUTLS_USE_POSIX_MEMALIGN
|
||||
free(base);
|
||||
#else
|
||||
/* The mallocated address is in ((void**)base)[-1] */
|
||||
free(((void **)base)[-1]);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Emulated TLS objects are always allocated at run-time. */
|
||||
static __inline void *emutls_allocate_object(__emutls_control *control)
|
||||
{
|
||||
size_t size = control->size;
|
||||
size_t align = control->align;
|
||||
if (align < sizeof(void *))
|
||||
align = sizeof(void *);
|
||||
/* Make sure that align is power of 2. */
|
||||
if ((align & (align - 1)) != 0)
|
||||
abort();
|
||||
|
||||
void *base = emutls_memalign_alloc(align, size);
|
||||
if (control->value)
|
||||
memcpy(base, control->value, size);
|
||||
else
|
||||
memset(base, 0, size);
|
||||
return base;
|
||||
}
|
||||
|
||||
static pthread_mutex_t emutls_mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
static size_t emutls_num_object = 0; /* number of allocated TLS objects */
|
||||
|
||||
typedef struct emutls_address_array
|
||||
{
|
||||
uintptr_t size; /* number of elements in the 'data' array */
|
||||
void *data[];
|
||||
} emutls_address_array;
|
||||
|
||||
static pthread_key_t emutls_pthread_key;
|
||||
|
||||
static void emutls_key_destructor(void *ptr)
|
||||
{
|
||||
emutls_address_array *array = (emutls_address_array *)ptr;
|
||||
uintptr_t i;
|
||||
for (i = 0; i < array->size; ++i)
|
||||
{
|
||||
if (array->data[i])
|
||||
emutls_memalign_free(array->data[i]);
|
||||
}
|
||||
free(ptr);
|
||||
}
|
||||
|
||||
static void emutls_init(void)
|
||||
{
|
||||
if (pthread_key_create(&emutls_pthread_key, emutls_key_destructor) != 0)
|
||||
abort();
|
||||
}
|
||||
|
||||
/* Returns control->object.index; set index if not allocated yet. */
|
||||
static __inline uintptr_t emutls_get_index(__emutls_control *control)
|
||||
{
|
||||
uintptr_t index = __atomic_load_n(&control->object.index, __ATOMIC_ACQUIRE);
|
||||
if (!index)
|
||||
{
|
||||
static pthread_once_t once = PTHREAD_ONCE_INIT;
|
||||
pthread_once(&once, emutls_init);
|
||||
pthread_mutex_lock(&emutls_mutex);
|
||||
index = control->object.index;
|
||||
if (!index)
|
||||
{
|
||||
index = ++emutls_num_object;
|
||||
__atomic_store_n(&control->object.index, index, __ATOMIC_RELEASE);
|
||||
}
|
||||
pthread_mutex_unlock(&emutls_mutex);
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
/* Updates newly allocated thread local emutls_address_array. */
|
||||
static __inline void emutls_check_array_set_size(emutls_address_array *array,
|
||||
uintptr_t size)
|
||||
{
|
||||
if (array == NULL)
|
||||
abort();
|
||||
array->size = size;
|
||||
pthread_setspecific(emutls_pthread_key, (void *)array);
|
||||
}
|
||||
|
||||
/* Returns the new 'data' array size, number of elements,
|
||||
* which must be no smaller than the given index.
|
||||
*/
|
||||
static __inline uintptr_t emutls_new_data_array_size(uintptr_t index)
|
||||
{
|
||||
/* Need to allocate emutls_address_array with one extra slot
|
||||
* to store the data array size.
|
||||
* Round up the emutls_address_array size to multiple of 16.
|
||||
*/
|
||||
return ((index + 1 + 15) & ~((uintptr_t)15)) - 1;
|
||||
}
|
||||
|
||||
/* Returns the thread local emutls_address_array.
|
||||
* Extends its size if necessary to hold address at index.
|
||||
*/
|
||||
static __inline emutls_address_array *
|
||||
emutls_get_address_array(uintptr_t index)
|
||||
{
|
||||
emutls_address_array *array = pthread_getspecific(emutls_pthread_key);
|
||||
if (array == NULL)
|
||||
{
|
||||
uintptr_t new_size = emutls_new_data_array_size(index);
|
||||
array = (emutls_address_array *)calloc(new_size + 1, sizeof(void *));
|
||||
emutls_check_array_set_size(array, new_size);
|
||||
}
|
||||
else if (index > array->size)
|
||||
{
|
||||
uintptr_t orig_size = array->size;
|
||||
uintptr_t new_size = emutls_new_data_array_size(index);
|
||||
array = (emutls_address_array *)realloc(array, (new_size + 1) * sizeof(void *));
|
||||
|
||||
if (array)
|
||||
memset(array->data + orig_size, 0,
|
||||
(new_size - orig_size) * sizeof(void *));
|
||||
emutls_check_array_set_size(array, new_size);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
void *__emutls_get_address(void *control)
|
||||
{
|
||||
uintptr_t index = emutls_get_index((__emutls_control *)control);
|
||||
emutls_address_array *array = emutls_get_address_array(index);
|
||||
if (array->data[index - 1] == NULL)
|
||||
array->data[index - 1] = emutls_allocate_object((__emutls_control *)control);
|
||||
return array->data[index - 1];
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 24 KiB |
59
components/libc/cplusplus/cpp11/gcc/__utils.h
Normal file
59
components/libc/cplusplus/cpp11/gcc/__utils.h
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <cstdlib>
|
||||
#include <system_error>
|
||||
#include <chrono>
|
||||
#include <ratio>
|
||||
|
||||
#include <rtthread.h>
|
||||
|
||||
#define RT_USING_CPP_EXCEPTION
|
||||
|
||||
inline void throw_system_error(int err, const char *what_msg)
|
||||
{
|
||||
#ifdef RT_USING_CPP_EXCEPTION
|
||||
throw std::system_error(std::error_code(err, std::system_category()), what_msg);
|
||||
#else
|
||||
(void)err;
|
||||
(void)what_msg;
|
||||
::abort();
|
||||
#endif
|
||||
}
|
||||
|
||||
class tick_clock
|
||||
{
|
||||
public:
|
||||
typedef clock_t rep;
|
||||
typedef std::ratio<1, RT_TICK_PER_SECOND> period;
|
||||
|
||||
typedef std::chrono::duration<tick_clock::rep, tick_clock::period> duration;
|
||||
typedef std::chrono::time_point<tick_clock> time_point;
|
||||
|
||||
constexpr static bool is_ready = true;
|
||||
|
||||
static time_point now();
|
||||
};
|
||||
|
||||
class real_time_clock
|
||||
{
|
||||
public:
|
||||
typedef std::chrono::nanoseconds duration;
|
||||
typedef duration::rep rep;
|
||||
typedef duration::period period;
|
||||
typedef std::chrono::time_point<real_time_clock, duration> time_point;
|
||||
|
||||
static constexpr bool is_steady = true;
|
||||
|
||||
static time_point
|
||||
now() noexcept;
|
||||
};
|
||||
222
components/libc/cplusplus/cpp11/gcc/condition_variable
Normal file
222
components/libc/cplusplus/cpp11/gcc/condition_variable
Normal file
|
|
@ -0,0 +1,222 @@
|
|||
#pragma once
|
||||
|
||||
#if __cplusplus < 201103L
|
||||
#error "C++ version lower than C++11"
|
||||
#endif
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include <system_error>
|
||||
#include <chrono>
|
||||
#include <utility>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
|
||||
#include "__utils.h"
|
||||
#include "mutex"
|
||||
|
||||
#define rt_cpp_cond_var pthread_cond_t
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
enum class cv_status
|
||||
{
|
||||
no_timeout,
|
||||
timeout
|
||||
};
|
||||
|
||||
class condition_variable
|
||||
{
|
||||
public:
|
||||
typedef rt_cpp_cond_var *native_handle_type;
|
||||
|
||||
condition_variable(const condition_variable &) = delete;
|
||||
condition_variable &operator=(const condition_variable &) = delete;
|
||||
|
||||
condition_variable() = default;
|
||||
|
||||
~condition_variable()
|
||||
{
|
||||
pthread_cond_destroy(&_m_cond);
|
||||
}
|
||||
|
||||
void wait(unique_lock<mutex> &lock);
|
||||
|
||||
void notify_one() noexcept
|
||||
{
|
||||
pthread_cond_signal(&_m_cond);
|
||||
}
|
||||
|
||||
void notify_all() noexcept
|
||||
{
|
||||
pthread_cond_broadcast(&_m_cond);
|
||||
}
|
||||
|
||||
template <class Predicate>
|
||||
void wait(unique_lock<mutex> &lock, Predicate pred)
|
||||
{
|
||||
while (!pred())
|
||||
wait(lock);
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
cv_status wait_until(unique_lock<mutex> &lock,
|
||||
const chrono::time_point<Clock, Duration> &abs_time)
|
||||
{
|
||||
if (!lock.owns_lock())
|
||||
throw_system_error((int)errc::operation_not_permitted,
|
||||
"condition_variable::wailt_until: waiting on unlocked lock");
|
||||
auto secs = chrono::time_point_cast<chrono::seconds>(abs_time);
|
||||
auto nano_secs = chrono::duration_cast<chrono::nanoseconds>(abs_time - secs);
|
||||
|
||||
struct timespec c_abs_time = {static_cast<time_t>(secs.time_since_epoch().count()),
|
||||
static_cast<long>(nano_secs.count())};
|
||||
|
||||
pthread_cond_timedwait(&_m_cond, lock.mutex()->native_handle(), &c_abs_time);
|
||||
|
||||
return (Clock::now() < abs_time) ? cv_status::no_timeout : cv_status::timeout;
|
||||
}
|
||||
|
||||
template <class Clock, class Duration, class Predicate>
|
||||
bool wait_until(unique_lock<mutex> &lock,
|
||||
const chrono::time_point<Clock, Duration> &abs_time,
|
||||
Predicate pred)
|
||||
{
|
||||
while (!pred())
|
||||
if (wait_until(lock, abs_time) == cv_status::timeout)
|
||||
return pred();
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class Rep, class Period>
|
||||
cv_status wait_for(unique_lock<mutex> &lock,
|
||||
const chrono::duration<Rep, Period> &rel_time)
|
||||
{
|
||||
return wait_until(lock, real_time_clock::now() + rel_time);
|
||||
}
|
||||
|
||||
template <class Rep, class Period, class Predicate>
|
||||
bool wait_for(unique_lock<mutex> &lock,
|
||||
const chrono::duration<Rep, Period> &rel_time,
|
||||
Predicate pred)
|
||||
{
|
||||
return wait_until(lock, real_time_clock::now() + rel_time, std::move(pred));
|
||||
}
|
||||
|
||||
native_handle_type native_handle()
|
||||
{
|
||||
return &_m_cond;
|
||||
}
|
||||
|
||||
private:
|
||||
rt_cpp_cond_var _m_cond = PTHREAD_COND_INITIALIZER;
|
||||
};
|
||||
|
||||
// Lockable is only required to have `lock()` and `unlock()`
|
||||
class condition_variable_any
|
||||
{
|
||||
private:
|
||||
condition_variable _m_cond;
|
||||
shared_ptr<mutex> _m_mtx;
|
||||
|
||||
// so that Lockable automatically unlocks when waiting and locks after waiting
|
||||
template <class Lockable>
|
||||
struct unlocker
|
||||
{
|
||||
Lockable &_m_lock;
|
||||
|
||||
explicit unlocker(Lockable &lk)
|
||||
: _m_lock(lk)
|
||||
{
|
||||
_m_lock.unlock();
|
||||
}
|
||||
|
||||
~unlocker()
|
||||
{
|
||||
_m_lock.lock();
|
||||
}
|
||||
|
||||
unlocker(const unlocker &) = delete;
|
||||
unlocker &operator=(const unlocker &) = delete;
|
||||
};
|
||||
|
||||
public:
|
||||
condition_variable_any() : _m_mtx(std::make_shared<mutex>()) {}
|
||||
~condition_variable_any() = default;
|
||||
|
||||
condition_variable_any(const condition_variable_any &) = delete;
|
||||
condition_variable_any &operator=(const condition_variable_any &) = delete;
|
||||
|
||||
void notify_one() noexcept
|
||||
{
|
||||
lock_guard<mutex> lk(*_m_mtx);
|
||||
_m_cond.notify_one();
|
||||
}
|
||||
|
||||
void notify_all() noexcept
|
||||
{
|
||||
lock_guard<mutex> lk(*_m_mtx);
|
||||
_m_cond.notify_all();
|
||||
}
|
||||
|
||||
template <class Lock>
|
||||
void wait(Lock &lock)
|
||||
{
|
||||
shared_ptr<mutex> mut = _m_mtx;
|
||||
unique_lock<mutex> lk(*mut);
|
||||
unlocker<Lock> auto_lk(lock); // unlock here
|
||||
|
||||
unique_lock<mutex> lk2(std::move(lk));
|
||||
_m_cond.wait(lk2);
|
||||
} // mut.unlock(); lock.lock();
|
||||
|
||||
template <class Lock, class Predicate>
|
||||
void wait(Lock &lock, Predicate pred)
|
||||
{
|
||||
while (!pred())
|
||||
wait(lock);
|
||||
}
|
||||
|
||||
template <class Lock, class Clock, class Duration>
|
||||
cv_status wait_until(Lock &lock,
|
||||
const chrono::time_point<Clock, Duration> &abs_time)
|
||||
{
|
||||
shared_ptr<mutex> mut = _m_mtx;
|
||||
unique_lock<mutex> lk(*mut);
|
||||
unlocker<Lock> auto_lk(lock); // unlock here
|
||||
|
||||
unique_lock<mutex> lk2(std::move(lk));
|
||||
return _m_cond.wait_until(lk2, abs_time);
|
||||
}
|
||||
|
||||
template <class Lock, class Clock, class Duration, class Predicate>
|
||||
bool wait_until(Lock &lock,
|
||||
const chrono::time_point<Clock, Duration> &abs_time,
|
||||
Predicate pred)
|
||||
{
|
||||
while (!pred())
|
||||
if (wait_until(lock, abs_time) == cv_status::timeout)
|
||||
return pred();
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class Lock, class Rep, class Period>
|
||||
cv_status wait_for(Lock &lock,
|
||||
const chrono::duration<Rep, Period> &rel_time)
|
||||
{
|
||||
return wait_until(lock, real_time_clock::now() + rel_time);
|
||||
}
|
||||
|
||||
template <class Lock, class Rep, class Period, class Predicate>
|
||||
bool wait_for(Lock &lock,
|
||||
const chrono::duration<Rep, Period> &rel_time,
|
||||
Predicate pred)
|
||||
{
|
||||
return wait_until(lock, real_time_clock::now() + rel_time, std::move(pred));
|
||||
}
|
||||
};
|
||||
|
||||
void notify_all_at_thread_exit(condition_variable &cond, unique_lock<mutex> lk);
|
||||
|
||||
} // namespace std
|
||||
34
components/libc/cplusplus/cpp11/gcc/condition_variable.cpp
Normal file
34
components/libc/cplusplus/cpp11/gcc/condition_variable.cpp
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include "condition_variable"
|
||||
|
||||
namespace std
|
||||
{
|
||||
void condition_variable::wait(unique_lock<mutex>& lock)
|
||||
{
|
||||
int err = pthread_cond_wait(&_m_cond, lock.mutex()->native_handle());
|
||||
|
||||
if (err)
|
||||
{
|
||||
throw_system_error(err, "condition_variable::wait: failed to wait on a condition");
|
||||
}
|
||||
}
|
||||
|
||||
void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
|
||||
{
|
||||
// TLS currently not available
|
||||
mutex* mut = lk.release();
|
||||
mut->unlock();
|
||||
cond.notify_all();
|
||||
}
|
||||
|
||||
|
||||
} // namespace std
|
||||
336
components/libc/cplusplus/cpp11/gcc/future
Normal file
336
components/libc/cplusplus/cpp11/gcc/future
Normal file
|
|
@ -0,0 +1,336 @@
|
|||
#pragma once
|
||||
|
||||
#if __cplusplus < 201103L
|
||||
#error "C++ version lower than C++11"
|
||||
#endif
|
||||
|
||||
#include <mutex>
|
||||
#include <condition_variable>
|
||||
#include <memory>
|
||||
#include <chrono>
|
||||
#include <cassert>
|
||||
|
||||
namespace std {
|
||||
|
||||
enum class future_status {
|
||||
ready,
|
||||
timeout,
|
||||
deferred
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
class shared_state_base {
|
||||
protected:
|
||||
typedef void (*deleter_fn)(void *v);
|
||||
|
||||
using scoped_lock = std::lock_guard<std::mutex>;
|
||||
using unique_lock = std::unique_lock<std::mutex>;
|
||||
public:
|
||||
explicit shared_state_base(deleter_fn d) : v_(nullptr), d_(d), valid_(true) {}
|
||||
|
||||
~shared_state_base() { d_(v_); }
|
||||
|
||||
shared_state_base(shared_state_base &&other) = delete;
|
||||
|
||||
shared_state_base(const shared_state_base &other) = delete;
|
||||
|
||||
shared_state_base &operator=(shared_state_base &&other) = delete;
|
||||
|
||||
shared_state_base &operator=(const shared_state_base &other) = delete;
|
||||
|
||||
void wait() {
|
||||
unique_lock lock(m_);
|
||||
c_.wait(lock, [this] { return has_value(); });
|
||||
}
|
||||
|
||||
template <class Rep, class Period>
|
||||
std::future_status
|
||||
wait_for(const std::chrono::duration<Rep, Period> &rel_time) {
|
||||
unique_lock lock(m_);
|
||||
if (c_.wait_for(lock, rel_time, [this] { return has_value(); })) {
|
||||
return std::future_status::ready;
|
||||
}
|
||||
return std::future_status::timeout;
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
std::future_status
|
||||
wait_until(const std::chrono::time_point<Clock, Duration> &abs_time) {
|
||||
unique_lock lock(m_);
|
||||
if (c_.wait_until(lock, abs_time, [this] { return has_value(); })) {
|
||||
return std::future_status::ready;
|
||||
}
|
||||
return std::future_status::timeout;
|
||||
}
|
||||
|
||||
protected:
|
||||
bool has_value() { return v_ != nullptr; }
|
||||
|
||||
protected:
|
||||
std::mutex m_;
|
||||
std::condition_variable c_;
|
||||
void *v_;
|
||||
deleter_fn d_;
|
||||
bool valid_;
|
||||
};
|
||||
|
||||
|
||||
template <typename R>
|
||||
class shared_state: public shared_state_base {
|
||||
public:
|
||||
shared_state() :shared_state_base(default_deleter_) {}
|
||||
|
||||
~shared_state() {}
|
||||
|
||||
R &get() {
|
||||
wait();
|
||||
scoped_lock lock(m_);
|
||||
assert(valid_);
|
||||
valid_ = false;
|
||||
return *(static_cast<R *>(v_));
|
||||
}
|
||||
|
||||
void set(const R &v) {
|
||||
scoped_lock lock(m_);
|
||||
assert(!has_value());
|
||||
v_ = new R(v);
|
||||
valid_ = true;
|
||||
c_.notify_one();
|
||||
}
|
||||
|
||||
void set(R &&v) {
|
||||
scoped_lock lock(m_);
|
||||
assert(!has_value());
|
||||
v_ = new R(std::move(v));
|
||||
valid_ = true;
|
||||
c_.notify_one();
|
||||
}
|
||||
|
||||
bool valid() {
|
||||
scoped_lock lock(m_);
|
||||
return valid_;
|
||||
}
|
||||
|
||||
private:
|
||||
static void default_deleter_(void *v) { delete static_cast<R *>(v); }
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename R>
|
||||
class shared_future {
|
||||
};
|
||||
|
||||
|
||||
template <typename R>
|
||||
class future {
|
||||
using state_type = std::shared_ptr<detail::shared_state<R>>;
|
||||
public:
|
||||
future() {}
|
||||
|
||||
explicit future(const state_type &state) : state_(state) {}
|
||||
|
||||
future(future &&other) noexcept: state_(std::move(other.state_)) {
|
||||
other.state_.reset();
|
||||
}
|
||||
|
||||
future(const future &other) = delete;
|
||||
|
||||
~future() {}
|
||||
|
||||
future &operator=(future &&other) noexcept {
|
||||
if (&other != this) {
|
||||
state_ = std::move(other.state_);
|
||||
other.state_.reset();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
future &operator=(const future &other) = delete;
|
||||
|
||||
void swap(future &other) noexcept {
|
||||
std::swap(state_, other.state_);
|
||||
}
|
||||
|
||||
std::shared_future<R> share() noexcept { return std::shared_future<R>(); }
|
||||
|
||||
R get() { return state_->get(); }
|
||||
|
||||
bool valid() const noexcept { return state_->valid(); }
|
||||
|
||||
void wait() const { state_->wait(); }
|
||||
|
||||
template <class Rep, class Period>
|
||||
std::future_status
|
||||
wait_for(const std::chrono::duration<Rep, Period> &rel_time) const {
|
||||
return state_->wait_for(rel_time);
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
std::future_status
|
||||
wait_until(const std::chrono::time_point<Clock, Duration> &abs_time) const {
|
||||
return state_->wait_until(abs_time);
|
||||
}
|
||||
|
||||
private:
|
||||
state_type state_;
|
||||
};
|
||||
|
||||
|
||||
template <>
|
||||
class future<void> {
|
||||
using state_type = std::shared_ptr<detail::shared_state<int>>;
|
||||
public:
|
||||
future() {}
|
||||
|
||||
explicit future(const state_type &state) : state_(state) {}
|
||||
|
||||
future(future &&other) noexcept: state_(std::move(other.state_)) {
|
||||
other.state_.reset();
|
||||
}
|
||||
|
||||
future(const future &other) = delete;
|
||||
|
||||
~future() {}
|
||||
|
||||
future &operator=(future &&other) noexcept {
|
||||
if (&other != this) {
|
||||
state_ = std::move(other.state_);
|
||||
other.state_.reset();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
future &operator=(const future &other) = delete;
|
||||
|
||||
void swap(future &other) noexcept {
|
||||
std::swap(state_, other.state_);
|
||||
}
|
||||
|
||||
std::shared_future<void> share() noexcept { return std::shared_future<void>(); }
|
||||
|
||||
void get() { state_->get(); }
|
||||
|
||||
bool valid() const noexcept { return state_->valid(); }
|
||||
|
||||
void wait() const { state_->wait(); }
|
||||
|
||||
template <class Rep, class Period>
|
||||
std::future_status
|
||||
wait_for(const std::chrono::duration<Rep, Period> &rel_time) const {
|
||||
return state_->wait_for(rel_time);
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
std::future_status
|
||||
wait_until(const std::chrono::time_point<Clock, Duration> &abs_time) const {
|
||||
return state_->wait_until(abs_time);
|
||||
}
|
||||
|
||||
private:
|
||||
state_type state_;
|
||||
};
|
||||
|
||||
|
||||
template <typename R>
|
||||
class promise {
|
||||
using state_type = std::shared_ptr<detail::shared_state<R>>;
|
||||
public:
|
||||
promise() : state_(new detail::shared_state<R>()) {}
|
||||
|
||||
promise(promise &&other) noexcept: state_(std::move(other.state_)) {
|
||||
other.state_.reset();
|
||||
}
|
||||
|
||||
promise(const promise &other) = delete;
|
||||
|
||||
~promise() {}
|
||||
|
||||
promise &operator=(promise &&other) noexcept {
|
||||
if (&other != this) {
|
||||
state_ = std::move(other.state_);
|
||||
other.state_.reset();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
promise &operator=(const promise &other) = delete;
|
||||
|
||||
void swap(promise &other) noexcept {
|
||||
std::swap(state_, other.state_);
|
||||
}
|
||||
|
||||
std::future<R> get_future() { return std::future<R>(state_); }
|
||||
|
||||
void set_value(const R &value) { state_->set(value); }
|
||||
|
||||
void set_value(R &&value) { state_->set(std::move(value)); }
|
||||
|
||||
void set_value_at_thread_exit(const R &value);
|
||||
|
||||
void set_value_at_thread_exit(R &&value);
|
||||
|
||||
void set_exception(std::exception_ptr p);
|
||||
|
||||
void set_exception_at_thread_exit(std::exception_ptr p);
|
||||
|
||||
private:
|
||||
state_type state_;
|
||||
};
|
||||
|
||||
|
||||
template <>
|
||||
class promise<void> {
|
||||
using state_type = std::shared_ptr<detail::shared_state<int>>;
|
||||
public:
|
||||
promise() : state_(new detail::shared_state<int>()) {}
|
||||
|
||||
promise(promise &&other) noexcept: state_(std::move(other.state_)) {
|
||||
other.state_.reset();
|
||||
}
|
||||
|
||||
promise(const promise &other) = delete;
|
||||
|
||||
~promise() {}
|
||||
|
||||
promise &operator=(promise &&other) noexcept {
|
||||
if (&other != this) {
|
||||
state_ = std::move(other.state_);
|
||||
other.state_.reset();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
promise &operator=(const promise &other) = delete;
|
||||
|
||||
void swap(promise &other) noexcept {
|
||||
std::swap(state_, other.state_);
|
||||
}
|
||||
|
||||
std::future<void> get_future() { return std::future<void>(state_); }
|
||||
|
||||
void set_value() { state_->set(0); }
|
||||
|
||||
void set_value_at_thread_exit();
|
||||
|
||||
void set_exception(std::exception_ptr p);
|
||||
|
||||
void set_exception_at_thread_exit(std::exception_ptr p);
|
||||
|
||||
private:
|
||||
state_type state_;
|
||||
};
|
||||
|
||||
|
||||
template <class R>
|
||||
void swap(std::future<R> &lhs, std::future<R> &rhs) noexcept {
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
||||
template <class R>
|
||||
void swap(std::promise<R> &lhs, std::promise<R> &rhs) noexcept {
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
512
components/libc/cplusplus/cpp11/gcc/mutex
Normal file
512
components/libc/cplusplus/cpp11/gcc/mutex
Normal file
|
|
@ -0,0 +1,512 @@
|
|||
#pragma once
|
||||
|
||||
#if __cplusplus < 201103L
|
||||
#error "C++ version lower than C++11"
|
||||
#endif
|
||||
|
||||
//#if defined(RT_USING_PTHREADS)
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include <system_error>
|
||||
#include <chrono>
|
||||
#include <utility>
|
||||
#include <functional>
|
||||
|
||||
#include "__utils.h"
|
||||
|
||||
#define rt_cpp_mutex_t pthread_mutex_t
|
||||
|
||||
namespace std
|
||||
{
|
||||
// Base class on which to build std::mutex and std::timed_mutex
|
||||
class __mutex_base
|
||||
{
|
||||
protected:
|
||||
typedef rt_cpp_mutex_t __native_type;
|
||||
|
||||
__native_type _m_mutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
constexpr __mutex_base() noexcept = default;
|
||||
__mutex_base(const __mutex_base&) = delete;
|
||||
__mutex_base& operator=(const __mutex_base&) = delete;
|
||||
};
|
||||
|
||||
|
||||
class mutex : private __mutex_base
|
||||
{
|
||||
public:
|
||||
constexpr mutex() = default;
|
||||
~mutex() = default;
|
||||
|
||||
mutex(const mutex&) = delete;
|
||||
mutex& operator=(const mutex&) = delete;
|
||||
|
||||
void lock()
|
||||
{
|
||||
int err = pthread_mutex_lock(&_m_mutex);
|
||||
|
||||
if (err)
|
||||
{
|
||||
throw_system_error(err, "mutex:lock failed.");
|
||||
}
|
||||
}
|
||||
|
||||
bool try_lock() noexcept
|
||||
{
|
||||
return !pthread_mutex_trylock(&_m_mutex);
|
||||
}
|
||||
|
||||
void unlock() noexcept
|
||||
{
|
||||
pthread_mutex_unlock(&_m_mutex);
|
||||
}
|
||||
|
||||
typedef __native_type* native_handle_type;
|
||||
|
||||
native_handle_type native_handle()
|
||||
{
|
||||
return &_m_mutex;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
inline int __rt_cpp_recursive_mutex_init(rt_cpp_mutex_t* m)
|
||||
{
|
||||
pthread_mutexattr_t attr;
|
||||
int res;
|
||||
|
||||
res = pthread_mutexattr_init(&attr);
|
||||
if (res)
|
||||
return res;
|
||||
res = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
||||
if (res)
|
||||
goto attr_cleanup;
|
||||
res = pthread_mutex_init(m, &attr);
|
||||
|
||||
attr_cleanup:
|
||||
int err = pthread_mutexattr_destroy(&attr);
|
||||
return res ? res : err;
|
||||
}
|
||||
|
||||
class __recursive_mutex_base
|
||||
{
|
||||
protected:
|
||||
typedef rt_cpp_mutex_t __native_type;
|
||||
|
||||
__native_type _m_recursive_mutex;
|
||||
|
||||
__recursive_mutex_base(const __recursive_mutex_base&) = delete;
|
||||
__recursive_mutex_base& operator=(const __recursive_mutex_base&) = delete;
|
||||
|
||||
__recursive_mutex_base()
|
||||
{
|
||||
int err = __rt_cpp_recursive_mutex_init(&_m_recursive_mutex);
|
||||
if (err)
|
||||
throw_system_error(err, "Recursive mutex failed to construct");
|
||||
}
|
||||
|
||||
~__recursive_mutex_base()
|
||||
{
|
||||
pthread_mutex_destroy(&_m_recursive_mutex);
|
||||
}
|
||||
};
|
||||
|
||||
class recursive_mutex : private __recursive_mutex_base
|
||||
{
|
||||
public:
|
||||
typedef __native_type* native_handle_type;
|
||||
recursive_mutex() = default;
|
||||
~recursive_mutex() = default;
|
||||
|
||||
recursive_mutex(const recursive_mutex&) = delete;
|
||||
recursive_mutex& operator=(const recursive_mutex&) = delete;
|
||||
void lock()
|
||||
{
|
||||
int err = pthread_mutex_lock(&_m_recursive_mutex);
|
||||
|
||||
if (err)
|
||||
throw_system_error(err, "recursive_mutex::lock failed");
|
||||
}
|
||||
|
||||
bool try_lock() noexcept
|
||||
{
|
||||
return !pthread_mutex_trylock(&_m_recursive_mutex);
|
||||
}
|
||||
|
||||
void unlock() noexcept
|
||||
{
|
||||
pthread_mutex_unlock(&_m_recursive_mutex);
|
||||
}
|
||||
|
||||
native_handle_type native_handle()
|
||||
{ return &_m_recursive_mutex; }
|
||||
};
|
||||
|
||||
#ifdef RT_PTHREAD_TIMED_MUTEX
|
||||
|
||||
class timed_mutex;
|
||||
|
||||
class recursive_timed_mutex;
|
||||
|
||||
#endif // RT_PTHREAD_TIMED_MUTEX
|
||||
|
||||
|
||||
struct defer_lock_t {};
|
||||
struct try_to_lock_t {};
|
||||
struct adopt_lock_t {}; // take ownership of a locked mtuex
|
||||
|
||||
constexpr defer_lock_t defer_lock { };
|
||||
constexpr try_to_lock_t try_to_lock { };
|
||||
constexpr adopt_lock_t adopt_lock { };
|
||||
|
||||
template <class Mutex>
|
||||
class lock_guard
|
||||
{
|
||||
public:
|
||||
typedef Mutex mutex_type;
|
||||
|
||||
explicit lock_guard(mutex_type& m) : pm(m) { pm.lock(); }
|
||||
lock_guard(mutex_type& m, adopt_lock_t) noexcept : pm(m)
|
||||
{ }
|
||||
~lock_guard()
|
||||
{ pm.unlock(); }
|
||||
|
||||
lock_guard(lock_guard const&) = delete;
|
||||
lock_guard& operator=(lock_guard const&) = delete;
|
||||
|
||||
private:
|
||||
mutex_type& pm;
|
||||
|
||||
};
|
||||
|
||||
template <class Mutex>
|
||||
class unique_lock
|
||||
{
|
||||
public:
|
||||
typedef Mutex mutex_type;
|
||||
|
||||
unique_lock() noexcept : pm(nullptr), owns(false) { }
|
||||
|
||||
explicit unique_lock(mutex_type& m)
|
||||
: pm(std::addressof(m)), owns(false)
|
||||
{
|
||||
lock();
|
||||
owns = true;
|
||||
}
|
||||
|
||||
unique_lock(mutex_type& m, defer_lock_t) noexcept
|
||||
: pm(std::addressof(m)), owns(false)
|
||||
{ }
|
||||
|
||||
unique_lock(mutex_type& m, try_to_lock_t) noexcept
|
||||
: pm(std::addressof(m)), owns(pm->try_lock())
|
||||
{ }
|
||||
|
||||
unique_lock(mutex_type& m, adopt_lock_t) noexcept
|
||||
: pm(std::addressof(m)), owns(true)
|
||||
{ }
|
||||
|
||||
// any lock-involving timed mutex API is currently only for custom implementations
|
||||
// the standard ones are not available
|
||||
template <class Clock, class Duration>
|
||||
unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time) noexcept
|
||||
: pm(std::addressof(m)), owns(pm->try_lock_until(abs_time))
|
||||
{ }
|
||||
|
||||
template <class Rep, class Period>
|
||||
unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time) noexcept
|
||||
: pm(std::addressof(m)), owns(pm->try_lock_for(rel_time))
|
||||
{ }
|
||||
|
||||
~unique_lock()
|
||||
{
|
||||
if (owns)
|
||||
unlock();
|
||||
}
|
||||
|
||||
unique_lock(unique_lock const&) = delete;
|
||||
unique_lock& operator=(unique_lock const&) = delete;
|
||||
|
||||
unique_lock(unique_lock&& u) noexcept
|
||||
: pm(u.pm), owns(u.owns)
|
||||
{
|
||||
u.pm = nullptr;
|
||||
u.owns = false;
|
||||
}
|
||||
|
||||
unique_lock& operator=(unique_lock&& u) noexcept
|
||||
{
|
||||
if (owns)
|
||||
unlock();
|
||||
|
||||
unique_lock(std::move(u)).swap(*this);
|
||||
|
||||
u.pm = nullptr;
|
||||
u.owns = false;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
void lock()
|
||||
{
|
||||
if (!pm)
|
||||
throw_system_error(int(errc::operation_not_permitted),
|
||||
"unique_lock::lock: references null mutex");
|
||||
else if (owns)
|
||||
throw_system_error(int(errc::resource_deadlock_would_occur),
|
||||
"unique_lock::lock: already locked" );
|
||||
else {
|
||||
pm->lock();
|
||||
owns = true;
|
||||
}
|
||||
}
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
if (!pm)
|
||||
throw_system_error(int(errc::operation_not_permitted),
|
||||
"unique_lock::try_lock: references null mutex");
|
||||
else if (owns)
|
||||
throw_system_error(int(errc::resource_deadlock_would_occur),
|
||||
"unique_lock::try_lock: already locked" );
|
||||
else {
|
||||
owns = pm->try_lock();
|
||||
}
|
||||
return owns;
|
||||
}
|
||||
|
||||
template <class Rep, class Period>
|
||||
bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
|
||||
{
|
||||
if (!pm)
|
||||
throw_system_error(int(errc::operation_not_permitted),
|
||||
"unique_lock::try_lock_for: references null mutex");
|
||||
else if (owns)
|
||||
throw_system_error(int(errc::resource_deadlock_would_occur),
|
||||
"unique_lock::try_lock_for: already locked");
|
||||
else {
|
||||
owns = pm->try_lock_for(rel_time);
|
||||
}
|
||||
return owns;
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
|
||||
{
|
||||
if (!pm)
|
||||
throw_system_error(int(errc::operation_not_permitted),
|
||||
"unique_lock::try_lock_until: references null mutex");
|
||||
else if (owns)
|
||||
throw_system_error(int(errc::resource_deadlock_would_occur),
|
||||
"unique_lock::try_lock_until: already locked");
|
||||
else {
|
||||
owns = pm->try_lock_until(abs_time);
|
||||
}
|
||||
return owns;
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
if (!owns)
|
||||
throw_system_error(int(errc::operation_not_permitted),
|
||||
"unique_lock::unlock: not locked");
|
||||
else {
|
||||
pm->unlock();
|
||||
owns = false;
|
||||
}
|
||||
}
|
||||
|
||||
void swap(unique_lock& u) noexcept
|
||||
{
|
||||
std::swap(pm, u.pm);
|
||||
std::swap(owns, u.owns);
|
||||
}
|
||||
|
||||
mutex_type *release() noexcept
|
||||
{
|
||||
mutex_type* ret_mutex = pm;
|
||||
pm = nullptr;
|
||||
owns = false;
|
||||
|
||||
return ret_mutex;
|
||||
}
|
||||
|
||||
bool owns_lock() const noexcept
|
||||
{ return owns; }
|
||||
|
||||
explicit operator bool() const noexcept
|
||||
{ return owns_lock(); }
|
||||
|
||||
mutex_type* mutex() const noexcept
|
||||
{ return pm; }
|
||||
|
||||
|
||||
private:
|
||||
mutex_type *pm;
|
||||
bool owns;
|
||||
};
|
||||
|
||||
template <class Mutex>
|
||||
void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y)
|
||||
{
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
template <class L0, class L1>
|
||||
int try_lock(L0& l0, L1& l1)
|
||||
{
|
||||
unique_lock<L0> u0(l0, try_to_lock); // try to lock the first Lockable
|
||||
// using unique_lock since we don't want to unlock l0 manually if l1 fails to lock
|
||||
if (u0.owns_lock())
|
||||
{
|
||||
if (l1.try_lock()) // lock the second one
|
||||
{
|
||||
u0.release(); // do not let RAII of a unique_lock unlock l0
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
template <class L0, class L1, class L2, class... L3>
|
||||
int try_lock(L0& l0, L1& l1, L2& l2, L3&... l3)
|
||||
{
|
||||
int r = 0;
|
||||
unique_lock<L0> u0(l0, try_to_lock);
|
||||
// automatically unlock is done through RAII of unique_lock
|
||||
if (u0.owns_lock())
|
||||
{
|
||||
r = try_lock(l1, l2, l3...);
|
||||
if (r == -1)
|
||||
u0.release();
|
||||
else
|
||||
++r;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
template <class L0, class L1, class L2, class ...L3>
|
||||
void
|
||||
__lock_first(int i, L0& l0, L1& l1, L2& l2, L3&... l3)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
// we first lock the one that is the most difficult to lock
|
||||
switch (i)
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
unique_lock<L0> u0(l0);
|
||||
i = try_lock(l1, l2, l3...);
|
||||
if (i == -1)
|
||||
{
|
||||
u0.release();
|
||||
return;
|
||||
}
|
||||
}
|
||||
++i;
|
||||
sched_yield();
|
||||
break;
|
||||
case 1:
|
||||
{
|
||||
unique_lock<L1> u1(l1);
|
||||
i = try_lock(l2, l3..., l0);
|
||||
if (i == -1)
|
||||
{
|
||||
u1.release();
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (i == sizeof...(L3) + 1) // all except l0 are locked
|
||||
i = 0;
|
||||
else
|
||||
i += 2; // since i was two-based above
|
||||
sched_yield();
|
||||
break;
|
||||
default:
|
||||
__lock_first(i - 2, l2, l3..., l0, l1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <class L0, class L1>
|
||||
void lock(L0& l0, L1& l1)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
{
|
||||
unique_lock<L0> u0(l0);
|
||||
if (l1.try_lock())
|
||||
{
|
||||
u0.release();
|
||||
break;
|
||||
}
|
||||
}
|
||||
sched_yield();
|
||||
// wait and try the other way
|
||||
{
|
||||
unique_lock<L1> u1(l1);
|
||||
if (l0.try_lock())
|
||||
{
|
||||
u1.release();
|
||||
break;
|
||||
}
|
||||
}
|
||||
sched_yield();
|
||||
}
|
||||
}
|
||||
|
||||
template <class L0, class L1, class... L2>
|
||||
void lock(L0& l0, L1& l1, L2&... l2)
|
||||
{
|
||||
__lock_first(0, l0, l1, l2...);
|
||||
}
|
||||
|
||||
struct once_flag
|
||||
{
|
||||
constexpr once_flag() noexcept = default;
|
||||
|
||||
once_flag(const once_flag&) = delete;
|
||||
once_flag& operator=(const once_flag&) = delete;
|
||||
|
||||
template <class Callable, class... Args>
|
||||
friend void call_once(once_flag& flag, Callable&& func, Args&&... args);
|
||||
|
||||
private:
|
||||
pthread_once_t _m_once = PTHREAD_ONCE_INIT;
|
||||
};
|
||||
|
||||
mutex& get_once_mutex();
|
||||
extern function<void()> once_functor;
|
||||
extern void set_once_functor_lock_ptr(unique_lock<mutex>*);
|
||||
|
||||
extern "C" void once_proxy(); // passed into pthread_once
|
||||
|
||||
template <class Callable, class... Args>
|
||||
void call_once(once_flag& flag, Callable&& func, Args&&... args)
|
||||
{
|
||||
// use a lock to ensure the call to the functor
|
||||
// is exclusive to only the first calling thread
|
||||
unique_lock<mutex> functor_lock(get_once_mutex());
|
||||
|
||||
auto call_wrapper = std::bind(std::forward<Callable>(func), std::forward<Args>(args)...);
|
||||
once_functor = [&]() { call_wrapper(); };
|
||||
|
||||
set_once_functor_lock_ptr(&functor_lock); // so as to unlock when actually calling
|
||||
|
||||
int err = pthread_once(&flag._m_once, &once_proxy);
|
||||
|
||||
if (functor_lock)
|
||||
set_once_functor_lock_ptr(nullptr);
|
||||
if (err)
|
||||
throw_system_error(err, "call_once failed");
|
||||
}
|
||||
}
|
||||
|
||||
//#endif //(RT_USING_PTHREADS)
|
||||
52
components/libc/cplusplus/cpp11/gcc/mutex.cpp
Normal file
52
components/libc/cplusplus/cpp11/gcc/mutex.cpp
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include "mutex"
|
||||
|
||||
namespace std
|
||||
{
|
||||
// use a set of global and static objects
|
||||
// a proxy function to pthread_once
|
||||
|
||||
function<void()> once_functor;
|
||||
|
||||
mutex& get_once_mutex()
|
||||
{
|
||||
static mutex once_mutex;
|
||||
return once_mutex;
|
||||
}
|
||||
|
||||
inline unique_lock<mutex>*& get_once_functor_lock_ptr()
|
||||
{
|
||||
static unique_lock<mutex>* once_functor_mutex_ptr = nullptr;
|
||||
return once_functor_mutex_ptr;
|
||||
}
|
||||
|
||||
void set_once_functor_lock_ptr(unique_lock<mutex>* m_ptr)
|
||||
{
|
||||
get_once_functor_lock_ptr() = m_ptr;
|
||||
}
|
||||
|
||||
extern "C"
|
||||
{
|
||||
void once_proxy()
|
||||
{
|
||||
// need to first transfer the functor's ownership so as to call it
|
||||
function<void()> once_call = std::move(once_functor);
|
||||
|
||||
// no need to hold the lock anymore
|
||||
unique_lock<mutex>* lock_ptr = get_once_functor_lock_ptr();
|
||||
get_once_functor_lock_ptr() = nullptr;
|
||||
lock_ptr->unlock();
|
||||
|
||||
once_call();
|
||||
}
|
||||
}
|
||||
}
|
||||
239
components/libc/cplusplus/cpp11/gcc/thread
Normal file
239
components/libc/cplusplus/cpp11/gcc/thread
Normal file
|
|
@ -0,0 +1,239 @@
|
|||
#pragma once
|
||||
|
||||
#if __cplusplus < 201103L
|
||||
#error "C++ version lower than C++11"
|
||||
#endif
|
||||
|
||||
//#if defined(RT_USING_PTHREADS)
|
||||
|
||||
#include <unistd.h>
|
||||
#include <pthread.h>
|
||||
#include <sched.h>
|
||||
#include <rtthread.h>
|
||||
|
||||
#include <cstddef>
|
||||
#include <cerrno>
|
||||
#include <ostream>
|
||||
#include <functional>
|
||||
#include <utility>
|
||||
#include <chrono>
|
||||
#include <memory>
|
||||
|
||||
#define rt_cpp_thread_t pthread_t
|
||||
#ifndef PTHREAD_NUM_MAX
|
||||
#define PTHREAD_NUM_MAX 32
|
||||
#endif
|
||||
#define CPP_UNJOINABLE_THREAD PTHREAD_NUM_MAX
|
||||
|
||||
namespace std
|
||||
{
|
||||
#define __STDCPP_THREADS__ __cplusplus
|
||||
|
||||
|
||||
|
||||
class thread
|
||||
{
|
||||
public:
|
||||
typedef rt_cpp_thread_t native_handle_type;
|
||||
|
||||
struct invoker_base;
|
||||
typedef shared_ptr<invoker_base> invoker_base_ptr;
|
||||
|
||||
class id
|
||||
{
|
||||
// basically a wrapper around native_handle_type
|
||||
native_handle_type __cpp_thread_t;
|
||||
|
||||
public:
|
||||
id() noexcept : __cpp_thread_t(CPP_UNJOINABLE_THREAD) {}
|
||||
|
||||
explicit id(native_handle_type hid)
|
||||
: __cpp_thread_t(hid) {}
|
||||
private:
|
||||
friend class thread;
|
||||
friend class hash<thread::id>;
|
||||
|
||||
friend bool operator==(thread::id x, thread::id y) noexcept;
|
||||
|
||||
friend bool operator<(thread::id x, thread::id y) noexcept;
|
||||
|
||||
template <class charT, class traits>
|
||||
friend basic_ostream<charT, traits>&
|
||||
operator<<(basic_ostream<charT, traits>& out, thread::id id);
|
||||
};
|
||||
|
||||
thread() noexcept = default;
|
||||
thread(const thread&) = delete;
|
||||
thread& operator=(const thread&) = delete;
|
||||
~thread();
|
||||
|
||||
template <class F, class ...Args>
|
||||
explicit thread(F&& f, Args&&... args)
|
||||
{
|
||||
start_thread(make_invoker_ptr(std::bind(
|
||||
std::forward<F>(f),
|
||||
std::forward<Args>(args)...
|
||||
)));
|
||||
}
|
||||
|
||||
thread(thread&& t) noexcept
|
||||
{
|
||||
swap(t);
|
||||
}
|
||||
|
||||
thread& operator=(thread&& t) noexcept
|
||||
{
|
||||
if (joinable())
|
||||
terminate();
|
||||
swap(t);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// member functions
|
||||
void swap(thread& t) noexcept
|
||||
{
|
||||
std::swap(_m_thr, t._m_thr);
|
||||
}
|
||||
|
||||
bool joinable() const noexcept
|
||||
{
|
||||
return (_m_thr.__cpp_thread_t < PTHREAD_NUM_MAX);
|
||||
}
|
||||
|
||||
void join();
|
||||
|
||||
void detach();
|
||||
|
||||
id get_id() const noexcept { return _m_thr; }
|
||||
|
||||
native_handle_type native_handle() { return _m_thr.__cpp_thread_t; }
|
||||
|
||||
// static members
|
||||
static unsigned hardware_concurrency() noexcept;
|
||||
|
||||
private:
|
||||
id _m_thr;
|
||||
|
||||
void start_thread(invoker_base_ptr b);
|
||||
public:
|
||||
struct invoker_base
|
||||
{
|
||||
invoker_base_ptr this_ptr;
|
||||
|
||||
virtual ~invoker_base() = default;
|
||||
|
||||
virtual void invoke() = 0;
|
||||
};
|
||||
|
||||
|
||||
template<typename Callable>
|
||||
struct invoker : public invoker_base
|
||||
{
|
||||
Callable func;
|
||||
|
||||
invoker(Callable&& F) : func(std::forward<Callable>(F)) { }
|
||||
|
||||
void invoke() { func(); }
|
||||
};
|
||||
|
||||
template <typename Callable>
|
||||
shared_ptr<invoker<Callable>> make_invoker_ptr(Callable&& F)
|
||||
{
|
||||
return std::make_shared<invoker<Callable>>(std::forward<Callable>(F));
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
inline void swap(thread& x, thread& y) noexcept
|
||||
{
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
|
||||
inline bool operator==(thread::id x, thread::id y) noexcept
|
||||
{
|
||||
// From POSIX for pthread_equal:
|
||||
//"If either t1 or t2 are not valid thread IDs, the behavior is undefined."
|
||||
return x.__cpp_thread_t == y.__cpp_thread_t;
|
||||
}
|
||||
|
||||
inline bool operator!=(thread::id x, thread::id y) noexcept
|
||||
{
|
||||
return !(x == y);
|
||||
}
|
||||
|
||||
inline bool operator<(thread::id x, thread::id y) noexcept
|
||||
{
|
||||
return x.__cpp_thread_t < y.__cpp_thread_t;
|
||||
}
|
||||
|
||||
inline bool operator<=(thread::id x, thread::id y) noexcept
|
||||
{
|
||||
return !(y < x);
|
||||
}
|
||||
|
||||
inline bool operator>(thread::id x, thread::id y) noexcept
|
||||
{
|
||||
return !(x <= y);
|
||||
}
|
||||
|
||||
inline bool operator>=(thread::id x, thread::id y) noexcept
|
||||
{
|
||||
return !(x < y);
|
||||
}
|
||||
|
||||
template <class charT, class traits>
|
||||
inline basic_ostream<charT, traits>&
|
||||
operator<<(basic_ostream<charT, traits>& out, thread::id id)
|
||||
{
|
||||
if (id == thread::id()) // id is invalid, representing no pthread
|
||||
out << "thread::id of a non-executing thread";
|
||||
else
|
||||
out << id.__cpp_thread_t;
|
||||
return out;
|
||||
}
|
||||
|
||||
template <>
|
||||
struct hash<thread::id>
|
||||
{
|
||||
typedef size_t result_type;
|
||||
typedef thread::id argument_type;
|
||||
size_t operator()(const thread::id& id) const noexcept
|
||||
{
|
||||
return hash<rt_cpp_thread_t>()(id.__cpp_thread_t);
|
||||
}
|
||||
};
|
||||
|
||||
namespace this_thread
|
||||
{
|
||||
inline thread::id get_id() noexcept
|
||||
{
|
||||
return thread::id(pthread_self());
|
||||
}
|
||||
|
||||
inline void yield() noexcept
|
||||
{
|
||||
sched_yield();
|
||||
}
|
||||
|
||||
template <class Rep, class Period>
|
||||
inline void sleep_for(const chrono::duration<Rep, Period>& rel_time)
|
||||
{
|
||||
if (rel_time <= rel_time.zero()) // less than zero, no need to sleep
|
||||
return;
|
||||
auto milli_secs = chrono::duration_cast<chrono::milliseconds>(rel_time);
|
||||
// the precision is limited by rt-thread thread API
|
||||
rt_thread_mdelay(milli_secs.count());
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
inline void sleep_until(const chrono::time_point<Clock, Duration>& abs_time)
|
||||
{
|
||||
auto now = Clock::now();
|
||||
if (abs_time > now)
|
||||
sleep_for(abs_time - now);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
94
components/libc/cplusplus/cpp11/gcc/thread.cpp
Normal file
94
components/libc/cplusplus/cpp11/gcc/thread.cpp
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include "thread"
|
||||
#include "__utils.h"
|
||||
|
||||
|
||||
#define _RT_NPROCS 0
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
extern "C"
|
||||
{
|
||||
static void* execute_native_thread_routine(void *p)
|
||||
{
|
||||
thread::invoker_base* t = static_cast<thread::invoker_base*>(p);
|
||||
thread::invoker_base_ptr local;
|
||||
local.swap(t->this_ptr); // tranfer the ownership of the invoker into the thread entry
|
||||
|
||||
local->invoke();
|
||||
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void thread::start_thread(invoker_base_ptr b)
|
||||
{
|
||||
auto raw_ptr = b.get();
|
||||
// transfer the ownership of the invoker to the new thread
|
||||
raw_ptr->this_ptr = std::move(b);
|
||||
int err = pthread_create(&_m_thr.__cpp_thread_t, NULL,
|
||||
&execute_native_thread_routine, raw_ptr);
|
||||
|
||||
if (err)
|
||||
{
|
||||
raw_ptr->this_ptr.reset();
|
||||
throw_system_error(err, "Failed to create a thread");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
thread::~thread()
|
||||
{
|
||||
if (joinable()) // when either not joined or not detached
|
||||
terminate();
|
||||
}
|
||||
|
||||
void thread::join()
|
||||
{
|
||||
int err = EINVAL;
|
||||
|
||||
if (joinable())
|
||||
err = pthread_join(native_handle(), NULL);
|
||||
|
||||
if (err)
|
||||
{
|
||||
throw_system_error(err, "thread::join failed");
|
||||
}
|
||||
|
||||
_m_thr = id();
|
||||
}
|
||||
|
||||
void thread::detach()
|
||||
{
|
||||
int err = EINVAL;
|
||||
|
||||
if (joinable())
|
||||
err = pthread_detach(native_handle());
|
||||
if (err)
|
||||
{
|
||||
throw_system_error(err, "thread::detach failed");
|
||||
}
|
||||
|
||||
_m_thr = id();
|
||||
}
|
||||
|
||||
// TODO: not yet actually implemented.
|
||||
// The standard states that the returned value should only be considered a hint.
|
||||
unsigned thread::hardware_concurrency() noexcept
|
||||
{
|
||||
int __n = _RT_NPROCS;
|
||||
if (__n < 0)
|
||||
__n = 0;
|
||||
return __n;
|
||||
}
|
||||
}
|
||||
29
components/libc/cplusplus/cpp11/gcc/utils.cpp
Normal file
29
components/libc/cplusplus/cpp11/gcc/utils.cpp
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include "__utils.h"
|
||||
#include <sys/time.h>
|
||||
|
||||
tick_clock::time_point tick_clock::now()
|
||||
{
|
||||
tick_clock::rep cur_tk = clock();
|
||||
tick_clock::duration cur_time(cur_tk);
|
||||
|
||||
return tick_clock::time_point(cur_time);
|
||||
}
|
||||
|
||||
real_time_clock::time_point real_time_clock::now() noexcept
|
||||
{
|
||||
timespec tp;
|
||||
clock_gettime(CLOCK_REALTIME, &tp);
|
||||
|
||||
return time_point(duration(std::chrono::seconds(tp.tv_sec))
|
||||
+ std::chrono::nanoseconds(tp.tv_nsec));
|
||||
}
|
||||
34
components/libc/cplusplus/cpp11/thread_local_impl.cpp
Normal file
34
components/libc/cplusplus/cpp11/thread_local_impl.cpp
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2021-04-27 flybreak the first version.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
#include <cstdlib>
|
||||
|
||||
typedef void (*destructor) (void *);
|
||||
|
||||
extern "C"
|
||||
int __cxa_thread_atexit_impl(destructor dtor, void* obj, void* dso_symbol)
|
||||
{
|
||||
pthread_key_t key_tmp;
|
||||
if (pthread_key_create(&key_tmp, dtor) != 0)
|
||||
abort();
|
||||
pthread_setspecific(key_tmp, obj);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if defined(__GNUC__) && !defined(__ARMCC_VERSION)/*GCC*/
|
||||
#include <cxxabi.h>
|
||||
|
||||
extern"C"
|
||||
int __cxxabiv1::__cxa_thread_atexit(destructor dtor, void *obj, void *dso_handle)
|
||||
{
|
||||
return __cxa_thread_atexit_impl(dtor, obj, dso_handle);
|
||||
}
|
||||
#endif
|
||||
44
components/libc/cplusplus/cxx_Mutex.cpp
Normal file
44
components/libc/cplusplus/cxx_Mutex.cpp
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#include "cxx_mutex.h"
|
||||
|
||||
using namespace rtthread;
|
||||
|
||||
Mutex::Mutex(const char *name)
|
||||
{
|
||||
rt_mutex_init(&mID, name, RT_IPC_FLAG_PRIO);
|
||||
}
|
||||
|
||||
bool Mutex::lock(int32_t millisec)
|
||||
{
|
||||
rt_int32_t tick;
|
||||
|
||||
if (millisec < 0)
|
||||
tick = -1;
|
||||
else
|
||||
tick = rt_tick_from_millisecond(millisec);
|
||||
|
||||
return rt_mutex_take(&mID, tick) == RT_EOK;
|
||||
}
|
||||
|
||||
bool Mutex::trylock()
|
||||
{
|
||||
return lock(0);
|
||||
}
|
||||
|
||||
void Mutex::unlock()
|
||||
{
|
||||
rt_mutex_release(&mID);
|
||||
}
|
||||
|
||||
Mutex::~Mutex()
|
||||
{
|
||||
rt_mutex_detach(&mID);
|
||||
}
|
||||
39
components/libc/cplusplus/cxx_Semaphore.cpp
Normal file
39
components/libc/cplusplus/cxx_Semaphore.cpp
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#include "cxx_semaphore.h"
|
||||
|
||||
using namespace rtthread;
|
||||
|
||||
Semaphore::Semaphore(const char *name, int32_t count)
|
||||
{
|
||||
rt_sem_init(&mID, name, count, RT_IPC_FLAG_FIFO);
|
||||
}
|
||||
|
||||
bool Semaphore::wait(int32_t millisec)
|
||||
{
|
||||
rt_int32_t tick;
|
||||
|
||||
if (millisec < 0)
|
||||
tick = -1;
|
||||
else
|
||||
tick = rt_tick_from_millisecond(millisec);
|
||||
|
||||
return rt_sem_take(&mID, tick) == RT_EOK;
|
||||
}
|
||||
|
||||
void Semaphore::release(void)
|
||||
{
|
||||
rt_sem_release(&mID);
|
||||
}
|
||||
|
||||
Semaphore::~Semaphore()
|
||||
{
|
||||
rt_sem_detach(&mID);
|
||||
}
|
||||
117
components/libc/cplusplus/cxx_Thread.cpp
Normal file
117
components/libc/cplusplus/cxx_Thread.cpp
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#include "cxx_thread.h"
|
||||
|
||||
using namespace rtthread;
|
||||
|
||||
Thread::Thread(rt_uint32_t stack_size,
|
||||
rt_uint8_t priority,
|
||||
rt_uint32_t tick,
|
||||
const char *name)
|
||||
: _entry(RT_NULL), _param(RT_NULL), started(false)
|
||||
{
|
||||
rt_event_init(&_event, name, 0);
|
||||
|
||||
_thread = rt_thread_create(name,
|
||||
(thread_func_t)func,
|
||||
this,
|
||||
stack_size,
|
||||
priority,
|
||||
tick);
|
||||
}
|
||||
|
||||
Thread::Thread(void (*entry)(void *p),
|
||||
void *p,
|
||||
rt_uint32_t stack_size,
|
||||
rt_uint8_t priority,
|
||||
rt_uint32_t tick,
|
||||
const char *name)
|
||||
: _entry(entry), _param(p), started(false)
|
||||
{
|
||||
rt_event_init(&_event, name, 0);
|
||||
|
||||
_thread = rt_thread_create(name,
|
||||
(thread_func_t)func,
|
||||
this,
|
||||
stack_size,
|
||||
priority,
|
||||
tick);
|
||||
}
|
||||
|
||||
Thread::~Thread()
|
||||
{
|
||||
rt_event_detach(&_event);
|
||||
rt_thread_delete(_thread);
|
||||
}
|
||||
|
||||
bool Thread::start()
|
||||
{
|
||||
if (rt_thread_startup(_thread) == RT_EOK)
|
||||
{
|
||||
started = true;
|
||||
}
|
||||
|
||||
return started;
|
||||
}
|
||||
|
||||
void Thread::sleep(int32_t millisec)
|
||||
{
|
||||
rt_int32_t tick;
|
||||
|
||||
if (millisec < 0)
|
||||
tick = 1;
|
||||
else
|
||||
tick = rt_tick_from_millisecond(millisec);
|
||||
|
||||
rt_thread_delay(tick);
|
||||
}
|
||||
|
||||
void Thread::func(Thread *pThis)
|
||||
{
|
||||
if (pThis->_entry != RT_NULL)
|
||||
{
|
||||
pThis->_entry(pThis->_param);
|
||||
}
|
||||
else
|
||||
{
|
||||
pThis->run(pThis->_param);
|
||||
}
|
||||
|
||||
rt_event_send(&pThis->_event, 1);
|
||||
}
|
||||
|
||||
void Thread::run(void *parameter)
|
||||
{
|
||||
/* please overload this method */
|
||||
}
|
||||
|
||||
rt_err_t Thread::wait(int32_t millisec)
|
||||
{
|
||||
return join(millisec);
|
||||
}
|
||||
|
||||
rt_err_t Thread::join(int32_t millisec)
|
||||
{
|
||||
if (started)
|
||||
{
|
||||
rt_int32_t tick;
|
||||
|
||||
if (millisec < 0)
|
||||
tick = -1;
|
||||
else
|
||||
tick = rt_tick_from_millisecond(millisec);
|
||||
|
||||
return rt_event_recv(&_event, 1, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, tick, RT_NULL);
|
||||
}
|
||||
else
|
||||
{
|
||||
return -RT_ENOSYS;
|
||||
}
|
||||
}
|
||||
37
components/libc/cplusplus/cxx_crt.cpp
Normal file
37
components/libc/cplusplus/cxx_crt.cpp
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2015-03-07 Bernard Add copyright header.
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include "cxx_crt.h"
|
||||
|
||||
void *operator new(size_t size)
|
||||
{
|
||||
return rt_malloc(size);
|
||||
}
|
||||
|
||||
void *operator new[](size_t size)
|
||||
{
|
||||
return rt_malloc(size);
|
||||
}
|
||||
|
||||
void operator delete(void *ptr)
|
||||
{
|
||||
rt_free(ptr);
|
||||
}
|
||||
|
||||
void operator delete[](void *ptr)
|
||||
{
|
||||
return rt_free(ptr);
|
||||
}
|
||||
|
||||
void __cxa_pure_virtual(void)
|
||||
{
|
||||
rt_kprintf("Illegal to call a pure virtual function.\n");
|
||||
}
|
||||
26
components/libc/cplusplus/cxx_crt.h
Normal file
26
components/libc/cplusplus/cxx_crt.h
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2015-03-07 Bernard Add copyright header.
|
||||
*/
|
||||
|
||||
#ifndef CRT_H_
|
||||
#define CRT_H_
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
void *operator new(size_t size);
|
||||
void *operator new[](size_t size);
|
||||
|
||||
void operator delete(void * ptr);
|
||||
void operator delete[](void *ptr);
|
||||
|
||||
extern "C" void __cxa_pure_virtual(void);
|
||||
extern "C" int cplusplus_system_init(void);
|
||||
|
||||
#endif
|
||||
68
components/libc/cplusplus/cxx_crt_init.c
Normal file
68
components/libc/cplusplus/cxx_crt_init.c
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2014-12-03 Bernard Add copyright header.
|
||||
* 2014-12-29 Bernard Add cplusplus initialization for ARMCC.
|
||||
* 2016-06-28 Bernard Add _init/_fini routines for GCC.
|
||||
* 2016-10-02 Bernard Add WEAK for cplusplus_system_init routine.
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
|
||||
#if defined(__ARMCC_VERSION)
|
||||
extern void $Super$$__cpp_initialize__aeabi_(void);
|
||||
/* we need to change the cpp_initialize order */
|
||||
rt_weak void $Sub$$__cpp_initialize__aeabi_(void)
|
||||
{
|
||||
/* empty */
|
||||
}
|
||||
#elif defined(__GNUC__) && !defined(__CS_SOURCERYGXX_MAJ__)
|
||||
/* The _init()/_fini() routines has been defined in codesourcery g++ lite */
|
||||
rt_weak void _init()
|
||||
{
|
||||
}
|
||||
|
||||
rt_weak void _fini()
|
||||
{
|
||||
}
|
||||
|
||||
rt_weak void *__dso_handle = 0;
|
||||
|
||||
#endif
|
||||
|
||||
rt_weak int cplusplus_system_init(void)
|
||||
{
|
||||
#if defined(__ARMCC_VERSION)
|
||||
/* If there is no SHT$$INIT_ARRAY, calling
|
||||
* $Super$$__cpp_initialize__aeabi_() will cause fault. At least until Keil5.12
|
||||
* the problem still exists. So we have to initialize the C++ runtime by ourself.
|
||||
*/
|
||||
typedef void PROC();
|
||||
extern const unsigned long SHT$$INIT_ARRAY$$Base[];
|
||||
extern const unsigned long SHT$$INIT_ARRAY$$Limit[];
|
||||
|
||||
const unsigned long *base = SHT$$INIT_ARRAY$$Base;
|
||||
const unsigned long *lim = SHT$$INIT_ARRAY$$Limit;
|
||||
|
||||
for (; base != lim; base++)
|
||||
{
|
||||
PROC *proc = (PROC *)((const char *)base + *base);
|
||||
(*proc)();
|
||||
}
|
||||
#elif defined(__GNUC__)
|
||||
typedef void(*pfunc)();
|
||||
extern pfunc __ctors_start__[];
|
||||
extern pfunc __ctors_end__[];
|
||||
pfunc *p;
|
||||
|
||||
for (p = __ctors_start__; p < __ctors_end__; p++)
|
||||
(*p)();
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
INIT_COMPONENT_EXPORT(cplusplus_system_init);
|
||||
28
components/libc/cplusplus/cxx_lock.h
Normal file
28
components/libc/cplusplus/cxx_lock.h
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2016/10/1 Bernard The first version
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
namespace rtthread {
|
||||
|
||||
class Lock
|
||||
{
|
||||
public:
|
||||
Lock(Mutex& mutex) : m(mutex) {m.lock();}
|
||||
~Lock() {m.unlock();}
|
||||
|
||||
protected:
|
||||
Mutex &m;
|
||||
};
|
||||
|
||||
}
|
||||
81
components/libc/cplusplus/cxx_mail.h
Normal file
81
components/libc/cplusplus/cxx_mail.h
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2016/10/1 Bernard The first version
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <rtthread.h>
|
||||
|
||||
namespace rtthread {
|
||||
|
||||
/**
|
||||
* The Mail class allow to control, send, receive, or wait for mail.
|
||||
* A mail is a memory block that is send to a thread or interrupt service routine.
|
||||
* @param T data type of a single message element.
|
||||
* @param queue_sz maximum number of messages in queue.
|
||||
*/
|
||||
|
||||
template<typename T, uint32_t queue_sz>
|
||||
class Mail {
|
||||
public:
|
||||
/** Create and Initialise Mail queue. */
|
||||
Mail(const char *name = "")
|
||||
{
|
||||
rt_mb_init(&mID, name, mPool, queue_sz, RT_IPC_FLAG_FIFO);
|
||||
}
|
||||
|
||||
~Mail()
|
||||
{
|
||||
rt_mb_detach(&mID);
|
||||
}
|
||||
|
||||
/** Put a mail in the queue.
|
||||
@param mptr memory block previously allocated with Mail::alloc or Mail::calloc.
|
||||
@return status code that indicates the execution status of the function.
|
||||
*/
|
||||
bool put(T *mptr, int32_t millisec = 0)
|
||||
{
|
||||
rt_int32_t tick;
|
||||
|
||||
if (millisec < 0)
|
||||
tick = -1;
|
||||
else
|
||||
tick = rt_tick_from_millisecond(millisec);
|
||||
|
||||
return rt_mb_send_wait(&mID, (rt_ubase_t)mptr, tick) == RT_EOK;
|
||||
}
|
||||
|
||||
/** Get a mail from a queue.
|
||||
@param millisec timeout value or 0 in case of no time-out. (default: osWaitForever).
|
||||
@return event that contains mail information or error code.
|
||||
*/
|
||||
T* get(int32_t millisec = -1)
|
||||
{
|
||||
T *t = NULL;
|
||||
rt_int32_t tick;
|
||||
|
||||
if (millisec < 0)
|
||||
tick = -1;
|
||||
else
|
||||
tick = rt_tick_from_millisecond(millisec);
|
||||
|
||||
rt_mb_recv(&mID, &t, tick);
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
private:
|
||||
struct rt_mailbox mID;
|
||||
T* mPool[queue_sz];
|
||||
};
|
||||
|
||||
}
|
||||
46
components/libc/cplusplus/cxx_mutex.h
Normal file
46
components/libc/cplusplus/cxx_mutex.h
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2016/10/1 Bernard The first version
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <rtthread.h>
|
||||
|
||||
namespace rtthread {
|
||||
|
||||
/** The Mutex class is used to synchronise the execution of threads.
|
||||
This is for example used to protect access to a shared resource.
|
||||
*/
|
||||
class Mutex {
|
||||
public:
|
||||
/** Create and Initialize a Mutex object */
|
||||
Mutex(const char *name = "mutex");
|
||||
~Mutex();
|
||||
|
||||
/** Wait until a Mutex becomes available.
|
||||
@param millisec timeout value or 0 in case of no time-out. (default: WaitForever)
|
||||
@return true if the mutex was acquired, false otherwise.
|
||||
*/
|
||||
bool lock(int32_t millisec = -1);
|
||||
|
||||
/** Try to lock the mutex, and return immediately
|
||||
@return true if the mutex was acquired, false otherwise.
|
||||
*/
|
||||
bool trylock();
|
||||
|
||||
/** Unlock the mutex that has previously been locked by the same thread
|
||||
*/
|
||||
void unlock();
|
||||
|
||||
private:
|
||||
struct rt_mutex mID;
|
||||
};
|
||||
|
||||
}
|
||||
74
components/libc/cplusplus/cxx_queue.h
Normal file
74
components/libc/cplusplus/cxx_queue.h
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2016/10/1 Bernard The first version
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <rtthread.h>
|
||||
|
||||
namespace rtthread {
|
||||
|
||||
/**
|
||||
* The Queue class allow to control, send, receive, or wait for messages.
|
||||
* A message can be a integer or pointer value to a certain type T that is send
|
||||
* to a thread or interrupt service routine.
|
||||
* @param T data type of a single message element.
|
||||
* @param queue_sz maximum number of messages in queue.
|
||||
*/
|
||||
template<typename T, uint32_t queue_sz>
|
||||
class Queue
|
||||
{
|
||||
public:
|
||||
/** Create and initialise a message Queue. */
|
||||
Queue()
|
||||
{
|
||||
rt_mq_init(&mID, "mq", mPool, sizeof(T), sizeof(mPool), RT_IPC_FLAG_FIFO);
|
||||
};
|
||||
|
||||
~Queue()
|
||||
{
|
||||
rt_mq_detach(&mID);
|
||||
};
|
||||
|
||||
/** Put a message in a Queue.
|
||||
@param data message pointer.
|
||||
@param millisec timeout value or 0 in case of no time-out. (default: 0)
|
||||
@return status code that indicates the execution status of the function.
|
||||
*/
|
||||
rt_err_t put(T& data, int32_t millisec = 0)
|
||||
{
|
||||
return rt_mq_send(&mID, &data, sizeof(data));
|
||||
}
|
||||
|
||||
/** Get a message or Wait for a message from a Queue.
|
||||
@param millisec timeout value or 0 in case of no time-out. (default: osWaitForever).
|
||||
@return bool .
|
||||
*/
|
||||
bool get(T& data, int32_t millisec = WAIT_FOREVER)
|
||||
{
|
||||
rt_int32_t tick;
|
||||
|
||||
if (millisec < 0)
|
||||
tick = -1;
|
||||
else
|
||||
tick = rt_tick_from_millisecond(millisec);
|
||||
|
||||
return rt_mq_recv(&mID, &data, sizeof(data), tick) == RT_EOK;
|
||||
}
|
||||
|
||||
private:
|
||||
struct rt_messagequeue mID;
|
||||
|
||||
char mPool[(sizeof(void *) + RT_ALIGN(sizeof(T), RT_ALIGN_SIZE)) * queue_sz];
|
||||
};
|
||||
|
||||
}
|
||||
42
components/libc/cplusplus/cxx_semaphore.h
Normal file
42
components/libc/cplusplus/cxx_semaphore.h
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2016/10/1 Bernard The first version
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <rtthread.h>
|
||||
|
||||
namespace rtthread {
|
||||
|
||||
/** The Semaphore class is used to manage and protect access to a set of shared resources. */
|
||||
class Semaphore
|
||||
{
|
||||
public:
|
||||
/** Create and Initialize a Semaphore object used for managing resources.
|
||||
@param number of available resources; maximum index value is (count-1).
|
||||
*/
|
||||
Semaphore(const char *name = "sem", int32_t count = 0);
|
||||
~Semaphore();
|
||||
|
||||
/** Wait until a Semaphore resource becomes available.
|
||||
@param millisec timeout value or 0 in case of no time-out.
|
||||
@return true on success.
|
||||
*/
|
||||
bool wait(int32_t millisec = -1);
|
||||
|
||||
/** Release a Semaphore resource that was obtain with Semaphore::wait.
|
||||
*/
|
||||
void release(void);
|
||||
|
||||
private:
|
||||
struct rt_semaphore mID;
|
||||
};
|
||||
|
||||
}
|
||||
67
components/libc/cplusplus/cxx_thread.h
Normal file
67
components/libc/cplusplus/cxx_thread.h
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2016/10/1 Bernard The first version
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <rtthread.h>
|
||||
|
||||
namespace rtthread
|
||||
{
|
||||
|
||||
/** The Thread class allow defining, creating, and controlling thread functions in the system. */
|
||||
class Thread
|
||||
{
|
||||
public:
|
||||
typedef void (*thread_func_t)(void *param);
|
||||
|
||||
/** Allocate a new thread without starting execution
|
||||
@param priority initial priority of the thread function. (default: osPriorityNormal).
|
||||
@param stack_size stack size (in bytes) requirements for the thread function. (default: DEFAULT_STACK_SIZE).
|
||||
@param stack_pointer pointer to the stack area to be used by this thread (default: NULL).
|
||||
*/
|
||||
Thread(rt_uint32_t stack_size = 2048,
|
||||
rt_uint8_t priority = (RT_THREAD_PRIORITY_MAX * 2) / 3,
|
||||
rt_uint32_t tick = 20,
|
||||
const char *name = "th");
|
||||
|
||||
Thread(void (*entry)(void *p),
|
||||
void *p = RT_NULL,
|
||||
rt_uint32_t stack_size = 2048,
|
||||
rt_uint8_t priority = (RT_THREAD_PRIORITY_MAX * 2) / 3,
|
||||
rt_uint32_t tick = 20,
|
||||
const char *name = "th");
|
||||
|
||||
virtual ~Thread();
|
||||
|
||||
bool start();
|
||||
|
||||
static void sleep(int32_t millisec);
|
||||
|
||||
rt_err_t wait(int32_t millisec);
|
||||
rt_err_t join(int32_t millisec = -1);
|
||||
|
||||
protected:
|
||||
virtual void run(void *parameter);
|
||||
|
||||
private:
|
||||
static void func(Thread *pThis);
|
||||
|
||||
rt_thread_t _thread;
|
||||
|
||||
thread_func_t _entry;
|
||||
void *_param;
|
||||
|
||||
/* event for thread join */
|
||||
struct rt_event _event;
|
||||
bool started;
|
||||
};
|
||||
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue