threadX gnu 版本如何安全的使用 C 库？

luguan1997

我现在有很多线程要记录浮点数据，会用到sprintf转换到字符串的形式。网上看到不少讨论说 newlibc（arm-none-eabi-gcc 所采用的） 的 vsprintf 之类的函数，多线程使用浮点会有问题。
自己也尝试拿代码测试了一下，创建三个优先级不同，可以抢占的线程，每个线程都是执行一千次到一万次 sprintf 然后休眠几个 tick，很容易会导致异常。
单步调试常常会死在 _dtoa 或者 _Balloc 这些内部的函数里。
而如果给它们互斥锁上,就没有问题：#define TRYS 2000
void thread_test_entry(ULONG thread_input)
{
    int try;
    double a = 1.1111;
    char str[20];
    while (1)
    {
        tx_thread_sleep(2);

        try = TRYS;

        tx_mutex_get(&mutex333, TX_WAIT_FOREVER);
        while(try--)
            sprintf(str, "%lf\n", a);
        tx_mutex_put(&mutex333);
    }
}

看到一个解决办法是 Freertos的 newlib and FreeRTOS (nadler.com)，但应该所有 RTOS 是互通的。
所以想问一下，使用 threadX 如何能安全使用 arm-none-eabi-gcc 编译器提供的库函数？有没有人做过好用的方案？

eric2013

其实这个牵扯到一个很重要的问题，效率。

比如我们仅仅是想简单的调用下sprintf，非常的不划算。

像MDK里面的C库是一个专门的封装层

eric2013

其实这个牵扯到一个很重要的问题，效率。

比如我们仅仅是想简单的调用下sprintf，非常的不划算。

像MDK里面的C库是一个专门的封装层

1. #if ( !defined(RTX_NO_MULTITHREAD_CLIB) && \
   
2.      ( defined(__CC_ARM) || \
   
3.       (defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050))) && \
   
4.       !defined(__MICROLIB))
   
5. 
   
6. #define LIBSPACE_SIZE 96
   
7. 
   
8. //lint -esym(714,__user_perthread_libspace,_mutex_*) "Referenced by C library"
   
9. //lint -esym(765,__user_perthread_libspace,_mutex_*) "Global scope"
   
10. //lint -esym(9003, os_libspace*) "variables 'os_libspace*' defined at module scope"
    
11. 
    
12. // Memory for libspace
    
13. static uint32_t os_libspace[OS_THREAD_LIBSPACE_NUM+1][LIBSPACE_SIZE/4] \
    
14. __attribute__((section(".bss.os.libspace")));
    
15. 
    
16. // Thread IDs for libspace
    
17. static osThreadId_t os_libspace_id[OS_THREAD_LIBSPACE_NUM] \
    
18. __attribute__((section(".bss.os.libspace")));
    
19. 
    
20. // Check if Kernel has been started
    
21. static uint32_t os_kernel_is_active (void) {
    
22.   static uint8_t os_kernel_active = 0U;
    
23. 
    
24.   if (os_kernel_active == 0U) {
    
25.     if (osKernelGetState() > osKernelReady) {
    
26.       os_kernel_active = 1U;
    
27.     }
    
28.   }
    
29.   return (uint32_t)os_kernel_active;
    
30. }
    
31. 
    
32. // Provide libspace for current thread
    
33. void *__user_perthread_libspace (void);
    
34. void *__user_perthread_libspace (void) {
    
35.   osThreadId_t id;
    
36.   uint32_t     n;
    
37. 
    
38.   if (os_kernel_is_active() != 0U) {
    
39.     id = osThreadGetId();
    
40.     for (n = 0U; n < (uint32_t)OS_THREAD_LIBSPACE_NUM; n++) {
    
41.       if (os_libspace_id[n] == NULL) {
    
42.         os_libspace_id[n] = id;
    
43.       }
    
44.       if (os_libspace_id[n] == id) {
    
45.         break;
    
46.       }
    
47.     }
    
48.     if (n == (uint32_t)OS_THREAD_LIBSPACE_NUM) {
    
49.       (void)osRtxKernelErrorNotify(osRtxErrorClibSpace, id);
    
50.     }
    
51.   } else {
    
52.     n = OS_THREAD_LIBSPACE_NUM;
    
53.   }
    
54. 
    
55.   //lint -e{9087} "cast between pointers to different object types"
    
56.   return (void *)&os_libspace[n][0];
    
57. }
    
58. 
    
59. // Mutex identifier
    
60. typedef void *mutex;
    
61. 
    
62. //lint -save "Function prototypes defined in C library"
    
63. //lint -e970 "Use of 'int' outside of a typedef"
    
64. //lint -e818 "Pointer 'm' could be declared as pointing to const"
    
65. 
    
66. // Initialize mutex
    
67. __USED
    
68. int _mutex_initialize(mutex *m);
    
69. int _mutex_initialize(mutex *m) {
    
70.   int result;
    
71. 
    
72.   *m = osMutexNew(NULL);
    
73.   if (*m != NULL) {
    
74.     result = 1;
    
75.   } else {
    
76.     result = 0;
    
77.     (void)osRtxKernelErrorNotify(osRtxErrorClibMutex, m);
    
78.   }
    
79.   return result;
    
80. }
    
81. 
    
82. // Acquire mutex
    
83. __USED
    
84. void _mutex_acquire(mutex *m);
    
85. void _mutex_acquire(mutex *m) {
    
86.   if (os_kernel_is_active() != 0U) {
    
87.     (void)osMutexAcquire(*m, osWaitForever);
    
88.   }
    
89. }
    
90. 
    
91. // Release mutex
    
92. __USED
    
93. void _mutex_release(mutex *m);
    
94. void _mutex_release(mutex *m) {
    
95.   if (os_kernel_is_active() != 0U) {
    
96.     (void)osMutexRelease(*m);
    
97.   }
    
98. }
    
99. 
    
100. // Free mutex
     
101. __USED
     
102. void _mutex_free(mutex *m);
     
103. void _mutex_free(mutex *m) {
     
104.   (void)osMutexDelete(*m);
     
105. }
     

复制代码

luguan1997

eric2013 发表于 2022-2-14 17:08
其实这个牵扯到一个很重要的问题，效率。

比如我们仅仅是想简单的调用下sprintf，非常的不划算。

keil 的听说多线程是安全的，但公司不让用
arm-none-eabi-gcc 的就想问问有没有人做过类似的 wrap 层给 threadX
要不是最近网上看到，都没想过库函数会有这种安全问题

eric2013

luguan1997 发表于 2022-2-14 17:28
keil 的听说多线程是安全的，但公司不让用
arm-none-eabi-gcc 的就想问问有没有人做过类似的 wrap 层给  ...

IAR也有这个封装层。对应文件在iar的安装目录里面。

GCC的话，如果是embedded studio的话，好像也有，

eric2013

luguan1997 发表于 2022-2-14 17:28
keil 的听说多线程是安全的，但公司不让用
arm-none-eabi-gcc 的就想问问有没有人做过类似的 wrap 层给  ...

IAR也有这个封装层。对应文件在iar的安装目录里面。

GCC的话，如果是embedded studio的话，好像也有，

regbbs

后来C库增加了snprintf,snprintf_s等之类的函数, 你试试这两个

glory

看newlib文档吧，里面也有讲解，关键字：桩函数。

eric2013

regbbs 发表于 2022-2-15 10:58
后来C库增加了snprintf,snprintf_s等之类的函数, 你试试这两个

可以，就是限制个数，不太方便。

不能吃辣

printf，sprintf都是不可重入函数吧，不是线程安全的

alexyzhov

楼上回答都挺好，首先这俩函数本来就不是可重入的，其次可以通过实现桩函数(__malloc_lock(), __malloc_unlock() stubs)往newlib里插桩加上互斥锁，最后newlib的源码其实很好集成进工程，构建选项里加上重入开关直接编译就好了

附件这篇文档感觉比较符合主题，希望能帮到你。