关于Linux Preempt RT补丁的实时编程问题?

两种方法：
方法1：
如果你能正常访问github，那么直接运行：
$ git clone git://git.kernel.org/pub/scm/utils/rt-tests/rt-tests.git
$ git checkout origin/stable/v1.0

如果不能，使用方法2：
$ wget https://mirrors.edge.kernel.org/pub/linux/utils/rt-tests/rt-tests-1.10.tar.gz
$ gzip -d rt-tests-1.10.tar.gz
$ tar -xf rt-tests-1.10.tar.gz

CC = arm-none-linux-gnueabi-gcc -static
AR = arm-none-linux-gnueabi-ar

    报错：
        src/cyclictest/rt_numa.h:29:18: fatal error: numa.h: 没有那个文件或目录
    解决：
        1）安装apt-file 来找到依赖库
            apt-get install apt-file
            apt-file update #更新源
        2）寻找 numa.h
            apt-file install numa.h
        3) 安装相应的库
            apt-get install libnuma-dev 
            
    测试：
    $ file cyclictest 
    cyclictest: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, for GNU/Linux 4.9.0, with debug_info, not stripped

最后，通过tftp/adb push等方式将bin文件传到board上即可。

 #运行5个线程，线程优先级80，无限循环
sudo cyclictest -t 5 -p 80 -n  
#clock_nanosleep 线程优先级80，间隔10000微秒，10000次循环，无负载
cyclictest -t1 -p 80 -n -i 10000 -l 10000  
#POSIX间隔计时器 线程优先级80，间隔10000微秒，10000次循环，无负载
cyclictest -t1 -p 80 -i 10000 -l 10000

$ sudo cyclictest -t5 -p 80 -n -i 10000 -l 10000
# /dev/cpu_dma_latency set to 0us
policy: fifo: loadavg: 0.04 0.03 0.07 3/757 6676          

T: 0 ( 6672) P:80 I:10000 C:    830 Min:     30 Act:   96 Avg:  626 Max:    6198
T: 1 ( 6673) P:80 I:10500 C:    791 Min:     13 Act:  428 Avg:  508 Max:    9664
T: 2 ( 6674) P:80 I:11000 C:    755 Min:     14 Act:  807 Avg:  558 Max:    9003
T: 3 ( 6675) P:80 I:11500 C:    722 Min:     13 Act:  758 Avg:  536 Max:    2933
T: 4 ( 6676) P:80 I:12000 C:    692 Min:     31 Act:  717 Avg:  485 Max:    1882

int main(int argc, char **argv)
{ ...
    for (i = 0; i < num_threads; i++) {
        if (histogram)print_hist(parameters, num_threads)
        stat->min = 1000000;
        stat->max = 0;
        stat->avg = 0.0;
        stat->threadstarted = 1;
        status = pthread_create(&stat->thread, &attr, timerthread, par);
 ...
    }
    while (!shutdown) {
        for (i = 0; i < num_threads; i++) 
            print_stat((stats[i]), i))
        usleep(10000)
    } 
 ...
}

     void *timerthread(void *param)
        { ...
        interval.tv_sec = par->interval  // 首先将参数中的间隔数赋给函数中的间隔数
        interval.tv_nsec = (par->interval % USEC_PER_SEC) * 1000; 
     ...
        /* Get current time  */
        clock_gettime(par->clock, &now); // 获取当前时间，存在 now 中
        next = now;    //\
        next.tv_sec += interval.tv_sec; // = 这三行是将当前时间（now 的值）加上间隔数(interval)算出下次间隔的时间,存在next     
        next.tv_nsec += interval.tv_nsec; ///
        tsnorm(&next);
     ...
     /* Wait for next period */ 等到下次循环
      ... 
     if ((ret = clock_gettime(par->clock, &now))) { //下次循环中记录循环时的时间到now 中，此时now 值中存的数是真实的下次循环的值，而上面存在next 的值是上次循环加上间隔值所以是理论上的下个循环的值。
                if (ret != EINTR)
                    warn("clock_getttime() failed. errno: %d\n", errno);
                goto out;
            }   
       if (use_nsecs)
            diff = calcdiff_ns(now, next);         // 上面已经说过了，now 中是下次循环的真值，而next是理论的值，所以两者的差就是延时！延时赋值给diff
        else
            diff = calcdiff(now, next);
        if (diff < stat->min)   // 假如延时比min 小，将min 改为这个更小的延时值diff
            stat->min = diff;
        if (diff > stat->max) {   // 假如延时比max 大，将max 改为这个更大的延时值diff
            stat->max = diff;
            if (refresh_on_max)
                pthread_cond_signal(&refresh_on_max_cond);
        }
        stat->avg += (double) diff;  // 计算新的平均延时
     ...
        /* Update the histogram */  // 更新histogram中存的延时统计数据
        if (histogram) {
            if (diff >= histogram) { // 假如延时比histogram大，添加一次溢出
                stat->hist_overflow++; 
                                if (stat->num_outliers < histogram)
                    stat->outliers[stat->num_outliers++] = stat->cycles;
            }
            else      // 如果没有溢出，将histogram 中的相应值加1
                stat->hist_array[diff]++;
        }
         stat->cycles++;     // 循环加1
        next.tv_sec += interval.tv_sec; // 继续计算下次循环的值 ...
        next.tv_nsec += interval.tv_nsec;
     ...
    }

clock_gettime((&now))
next = now + par->interval
while (!shutdown) {
    clock_nanosleep((&next))
    clock_gettime((&now))       //获取指定类型时钟的时间，例如CLOCK_MONOTONIC
    diff = calcdiff(now, next)  //计算此次延时
    # update stat-> min, max, total latency, cycles
    # update the histogram data
    next += interval
}