5 rt-smart用户态线程实时性差的问题

发布于 2025-03-30 13:38:40 浏览：98 订阅该版

我在树莓派4B上使用v5.2.0 开启smart的rt-thread 并启用SMP多核（4核）内核时，在用户态和内核态运行同样的代码测试：

```c

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <stdbool.h>
#include <rtthread.h>

#define MAX_PRIO 0

rt_thread_t base_rate_thread;
int simulationFinished = 0;
void busy_delay(struct timespec *next)
{

struct timespec now;
  do
  {
    clock_gettime(CLOCK_MONOTONIC, &now);
  } while (now.tv_sec < next->tv_sec || (now.tv_sec == next->tv_sec &&
                                         now.tv_nsec <= next->tv_nsec));
}

void base_rate(void *param_unused)
{
  printf("Base rate thread started\n");
  struct timespec now, next, start;
  struct timespec period = {0U, 50000U}; /* 5.0E-5 seconds */

int step_sem_value;
  int i;
  (void)param_unused;

uint32_t overrun_time = 0;
  uint32_t num = 0;
  uint32_t max = 0;
  uint32_t min = 1000000000;
  uint32_t sum = 0;
  while (!simulationFinished)
  {
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    next.tv_sec = start.tv_sec + period.tv_sec;
    next.tv_nsec = start.tv_nsec + period.tv_nsec;

if (next.tv_nsec >= 1000000000)
    {
      next.tv_sec++;
      next.tv_nsec -= 1000000000;
    }

busy_delay(&next);

clock_gettime(CLOCK_MONOTONIC, &now);
    uint32_t usec = (now.tv_sec - start.tv_sec) * 1000000 + (now.tv_nsec - start.tv_nsec) / 1000;
    
    sum += usec;
    num++;
    if (usec > max)
    {
      max = usec;
    }
    if (usec < min)
    {
      min = usec;
    }
  }
  printf("sum:%ld num:%ld avg:%ld min:%ld max:%ld over: %ld\n", sum, num, sum/num, min, max, overrun_time);
}

int main()
{
  printf("APP STARTED\n");
  const char *errStatus;
  int i;

simulationFinished = 0;

rt_thread_t baseRateTask, extModeTask;

baseRateTask = rt_thread_create("baseRateTask", base_rate, RT_NULL, 16834, MAX_PRIO + 9, 1);

rt_thread_startup(baseRateTask);

for (int i = 0; i < 100; i++)
  {
    rt_thread_mdelay(100);
  }
  simulationFinished = 1;
  rt_thread_mdelay(1000);

printf("model finish\n");
  return 0;
}

```
即使用忙等待的方式测量50us定时性能，发现在内核态时代码平均周期为50us,最小周期为50us,最大周期为57us,性能十分优异，而在用户态运行同样代码，性能劣化为平均周期70多us,最大周期甚至超过100us,实时性大幅下降；
想请教这种现象是用户态使用系统调用的必然结果，还是有什么地方使用的方式不对，又或者是忙等这种延时方式在用户态极大影响性能？