QNX 时钟：测量代码执行时间和网络通信时间戳

已于 2024-06-01 22:03:19 修改
阅读量911 收藏 18
点赞数 27
文章标签： qnx
于 2023-12-03 15:13:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stallion5632/article/details/134765223
版权

文章目录

简介

QNX 作为一款实时操作系统，在嵌入式系统开发中扮演着重要的角色。 了解 QNX 中如何测量代码执行时间和网络通信时间戳对于开发人员优化性能至关重要。 本文将介绍两种方法来实现这些功能：

1. 测量QNX代码执行时间 SYSPAGE_ENTRY

SYSPAGE_ENTRY()的使用如下

#include <sys/neutrino.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/syspage.h>

int main( void )
{
    uint64_t cps, cycle1, cycle2, ncycles;
    float sec;

    /* snap the time */
    cycle1=ClockCycles( );

    /* do something */
    printf("poo\n");

    /* snap the time again */
    cycle2=ClockCycles( );
    ncycles=cycle2-cycle1;
    printf("%lld cycles elapsed \n", ncycles);
    
    /* find out how many cycles per second */
    cps = SYSPAGE_ENTRY(qtime)->cycles_per_sec;
    printf( "This system has %lld cycles/sec.\n",cps );
    sec=(float)ncycles/cps;
    printf("The cycles in seconds is %f \n",sec);

    return EXIT_SUCCESS;
}

输出

在这里插入图片描述
解释：

  • ClockCycles() 函数获取系统时钟周期数。
  • 通过记录函数执行前后时钟周期数的差值，可以计算出函数的执行时间。
  • 需要注意的是，ClockCycles() 的精度取决于系统时钟频率，可能存在波动。

ClockCycles() 和TIMESTAMP的使用

测试代码

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <inttypes.h>
#include <time.h>
#include <sys/select.h>
#include <sys/ioctl.h>
#ifdef __QNX__
#include <sys/neutrino.h>
#include <sys/syspage.h>
#endif

#define log(fmt, ...) printf(fmt "\n", ##__VA_ARGS__);

int create_server_socket() {
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        log("cannot create socket");
        return -1;
    }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);

    int ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
    if (ret < 0) {
        log("cannot bind socket");
        return -1;
    }

    int optval = 1;
    ret = setsockopt(sock, SOL_SOCKET, SO_TIMESTAMP, &optval, sizeof(optval));
    if (ret < 0) {
        log("cannot setsockopt SO_TIMESTAMP");
        return -1;
    }

    return sock;
}

int destroy_socket(int sock) {
    if (sock < 0) {
        log("invalid socket");
        return -1;
    }

    int ret = close(sock);
    if (ret < 0) {
        log("cannot close socket");
        return -1;
    }

    return 0;
}

int64_t get_so_timestampns(int sock) {
    struct msghdr msg;
    struct iovec iov;
    char cmsgbuf[4096];
    char buf[1024];
    struct cmsghdr *cmsg;
    struct timeval *tv;
    int ret;

    memset(buf, 0, sizeof(buf));
    memset(&msg, 0, sizeof(msg));
    memset(&iov, 0, sizeof(iov));
    memset(cmsgbuf, 0, sizeof(cmsgbuf));

    iov.iov_base = buf;
    iov.iov_len = sizeof(buf);
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;
    msg.msg_control = cmsgbuf;
    msg.msg_controllen = sizeof(cmsgbuf);

    ret = recvmsg(sock, &msg, 0);
    if (ret < 0) {
        log("cannot recvmsg %s", strerror(errno));
        return -1;
    }
    write(sock, buf, strlen(buf));

    for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
#ifdef _QNX_
        if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_TIMESTAMP) {
#else
        if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SO_TIMESTAMP) {
#endif
            tv = (struct timeval *)CMSG_DATA(cmsg);
            return tv->tv_sec * 1000000000 + tv->tv_usec * 1000;
        }
    }

    log("cannot find SO_TIMESTAMP");
    return -1;
}

int send_to_sock(int sock, const char* buf, int len) {
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    // localhost
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

    int ret = sendto(sock, buf, len, 0, (struct sockaddr *)&addr, sizeof(addr));
    if (ret < 0) {
        log("cannot sendto");
        return -1;
    }

    return 0;
}

int main() {
#ifdef __QNX__
    uint64_t cntpclk = SYSPAGE_ENTRY(qtime)->cycles_per_sec;
#endif

    int sock = create_server_socket();
    if (sock < 0) {
        return -1;
    }

    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(sock, &rfds);

    const char* buf = "hello world";
    int64_t sec, msec, usec, nsec;
    int64_t ns = -1;
    int ret = -1;
    for (;;) {
        struct timespec start, end;

#ifdef __QNX__
        if (clock_gettime(CLOCK_REALTIME, &start) == -1) {
#else
        if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) {
#endif
            log("cannot get start time");
            return -1;
        }

        ret = send_to_sock(sock, buf, strlen(buf));
        if (ret < 0) {
            return -1;
        }

        ret = select(sock + 1, &rfds, NULL, NULL, NULL);
        if (ret < 0) {
            log("cannot select");
            return -1;
        }

        ns = get_so_timestampns(sock);
        if (ns < 0) {
            return -1;
        }

#ifdef __QNX__
        uint64_t cycles = ClockCycles();
        sec = cycles / cntpclk;
        nsec = ((cycles % cntpclk) * 1000000000) / cntpclk;
#else
        sec = ns / 1000000000;
        nsec = ns % 1000000000;
#endif
        msec = (ns % 1000000000) / 1000000;
        usec = (ns % 1000000) / 1000;
        log("ts: %ld.%03ld.%03ld.%03ld", sec, msec, usec, nsec);

#ifdef __QNX__
        if (clock_gettime(CLOCK_REALTIME, &end) == -1) {
#else
        if (clock_gettime(CLOCK_MONOTONIC, &end) == -1) {
#endif
            log("cannot get end time");
            return -1;
        }

#ifdef __QNX__
        uint64_t elapsed = (end.tv_sec - start.tv_sec) * cntpclk + (end.tv_nsec - start.tv_nsec) * cntpclk / 1000000000;
#else
        uint64_t elapsed = (end.tv_sec - start.tv_sec) * 1000000000 + (end.tv_nsec - start.tv_nsec);
#endif
        log("Elapsed time: %lu ns", elapsed);
    }

    destroy_socket(sock);
}

输出
在这里插入图片描述
解释：

  • 使用 clock_gettime() 函数获取当前时间戳。
  • 利用 recvmsg() 函数接收数据时，设置 SO_TIMESTAMP 选项，可以获取接收时间戳。
  • 将接收时间戳与系统时间戳相结合，可以得到高精度的网络通信时间戳。

3. QNX 与 x86 编译性能比较

  • 分别编译为 QNX 和 x86 版本，并在相同硬件平台上运行。
  • 通过比较两者的执行时间，可以评估 QNX 编译与 x86 编译的性能差异。

3.1 QNX编译server, client在x86

./so_times_client2server
-1688469126.732655764,-1688469126.728909969,-1688469126.732655764,9223372036.854776382,-1688469126.728909969,9223372036.854776382
-1688469126.732184887,-1688469126.728912115,-1688469126.732184887,9223372036.854776382,-1688469126.728909969,-1688469126.728912115
-1688469126.732127190,-1688469126.728909254,-1688469126.732127190,9223372036.854776382,-1688469126.728909254,-1688469126.728912115
-1688469126.731760502,-1688469126.728905678,-1688469126.731760502,9223372036.854776382,-1688469126.728905678,-1688469126.728912115
-1688469126.731424093,-1688469126.728862762,-1688469126.731424093,9223372036.854776382,-1688469126.728862762,-1688469126.728912115
-1688469126.731297493,-1688469126.728890896,-1688469126.731297493,9223372036.854776382,-1688469126.728862762,-1688469126.728912115
-1688469126.731182575,-1688469126.728879690,-1688469126.731182575,9223372036.854776382,-1688469126.728862762,-1688469126.728912115
-1688469126.731026411,-1688469126.728876829,-1688469126.731026411,9223372036.854776382,-1688469126.728862762,-1688469126.728912115
-1688469126.730824709,-1688469126.728859663,-1688469126.730824709,9223372036.854776382,-1688469126.728859663,-1688469126.728912115
-1688469126.730739594,-1688469126.728857994,-1688469126.730739594,9223372036.854776382,-1688469126.728857994,-1688469126.728912115
-1688469126.730360746,-1688469126.728832722,-1688469126.730360746,9223372036.854776382,-1688469126.728832722,-1688469126.728912115
-1688469126.730060339,-1688469126.728815556,-1688469126.730060339,9223372036.854776382,-1688469126.728815556,-1688469126.728912115

3.2 x86 编译server, client在x86

./so_times_client2server_x86
0.000026974,0.000043670,0.000026974,9223372036.854776382,0.000043670,9223372036.854776382
0.000017392,0.000033999,0.000026974,0.000017392,0.000043670,0.000033999
0.000016327,0.000031998,0.000026974,0.000016327,0.000043670,0.000031998
0.000023419,0.000041275,0.000026974,0.000016327,0.000043670,0.000031998
0.000022748,0.000040941,0.000026974,0.000016327,0.000043670,0.000031998
0.000023593,0.000042021,0.000026974,0.000016327,0.000043670,0.000031998
0.000041016,0.000059082,0.000041016,0.000016327,0.000059082,0.000031998
0.000022167,0.000040225,0.000041016,0.000016327,0.000059082,0.000031998
0.000029824,0.000047739,0.000041016,0.000016327,0.000059082,0.000031998
0.000021904,0.000039896,0.000041016,0.000016327,0.000059082,0.000031998
0.000024818,0.000043094,0.000041016,0.000016327,0.000059082,0.000031998
0.000022284,0.000040727,0.000041016,0.000016327,0.000059082,0.000031998
0.000024739,0.000064953,0.000041016,0.000016327,0.000064953,0.000031998
0.000021680,0.000038507,0.000041016,0.000016327,0.000064953,0.000031998
0.000039627,0.000069057,0.000041016,0.000016327,0.000069057,0.000031998

so_times_client2server.c 源码

#include <arpa/inet.h>
#include <errno.h>
#include <inttypes.h>
#include <netinet/if_ether.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#ifdef _QNX_
#include <sys/neutrino.h>
#include <sys/siginfo.h>
#else
#include <pthread.h>
#endif
#define PORT 23333
#define log(fmt, ...) printf(fmt "\n", ##__VA_ARGS__);
int create_server_socket() {
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        log("cannot create socket");
        return -1;
    }
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = PORT;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    int ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
    if (ret < 0) {
        log("cannot bind socket");
        return -1;
    }
    int optval = 1;
    ret = setsockopt(sock, SOL_SOCKET, SO_TIMESTAMP, &optval, sizeof(optval));
    if (ret < 0) {
        log("cannot setsockopt SO_TIMESTAMP");
        return -1;
    }
    return sock;
}
int create_client_socket(const char *ip) {
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        log("cannot create socket");
        return -1;
    }
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = PORT;
    if (ip == NULL) {
        addr.sin_addr.s_addr = inet_addr("224.0.1.129");
    } else {
        addr.sin_addr.s_addr = inet_addr(ip);
    }
    int ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
    if (ret < 0) {
        log("cannot connect socket");
        return -1;
    }
    int optval = 1;
    ret = setsockopt(sock, SOL_SOCKET, SO_TIMESTAMP, &optval, sizeof(optval));
    if (ret < 0) {
        log("cannot setsockopt SO_TIMESTAMP");
        return -1;
    }
    return sock;
}
int destroy_socket(int sock) {
    if (sock < 0) {
        log("invalid socket");
        return -1;
    }
    int ret = close(sock);
    if (ret < 0) {
        log("cannot close socket");
        return -1;
    }
    return 0;
}
void show_so_timestamp(int sock, int use_cmsg) {
    struct timespec inner_ts;
    clock_gettime(CLOCK_REALTIME, &inner_ts);
    struct msghdr msg;
    struct iovec iov;
    char cmsgbuf[4096];
    char buf[1024];
    struct cmsghdr *cmsg;
    struct timeval *tv;
    int ret;
    memset(buf, 0, sizeof(buf));
    memset(&msg, 0, sizeof(msg));
    memset(&iov, 0, sizeof(iov));
    memset(cmsgbuf, 0, sizeof(cmsgbuf));
    iov.iov_base = buf;
    iov.iov_len = sizeof(buf);
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;
    msg.msg_control = cmsgbuf;
    msg.msg_controllen = sizeof(cmsgbuf);
    ret = recvmsg(sock, &msg, 0);
    if (ret < 0) {
        return;
    }
    int64_t inner_ns = inner_ts.tv_sec * 1000000000 + inner_ts.tv_nsec;
    int64_t recv_ns = -1;
    int64_t tag_ns = -1;
    struct timespec *ts = (struct timespec *)buf;
    tag_ns = ts->tv_sec * 1000000000 + ts->tv_nsec;
    for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
#ifdef _QNX_
        if (cmsg->cmsg_level == SOL_SOCKET &&
            cmsg->cmsg_type == SCM_TIMESTAMP) {
#else
        if (cmsg->cmsg_level == SOL_SOCKET &&
            cmsg->cmsg_type == SO_TIMESTAMP) {
#endif
            tv = (struct timeval *)CMSG_DATA(cmsg);
            recv_ns = tv->tv_sec * 1000000000 + tv->tv_usec * 1000;
        }
    }
    if (recv_ns < 0 || tag_ns < 0) {
        log("recv_ns %ld, tag_ns %ld", recv_ns, tag_ns);
        return;
    }
    int64_t diff_ns = recv_ns - tag_ns;
    int64_t diff_inner_ns = inner_ns - tag_ns;
    static int64_t diff_ns_max = INT64_MIN;
    static int64_t diff_ns_min = INT64_MAX;
    if (diff_ns > diff_ns_max) {
        diff_ns_max = diff_ns;
    } else if (diff_ns < diff_ns_min) {
        diff_ns_min = diff_ns;
    }
    static int64_t diff_inner_ns_max = INT64_MIN;
    static int64_t diff_inner_ns_min = INT64_MAX;
    if (diff_inner_ns > diff_inner_ns_max) {
        diff_inner_ns_max = diff_inner_ns;
    } else if (diff_inner_ns < diff_inner_ns_min) {
        diff_inner_ns_min = diff_inner_ns;
    }
    log("%.9lf,%.9lf,%.9lf,%.9lf,%.9lf,%.9lf",
        diff_ns / 1000000000.0, diff_inner_ns / 1000000000.0,
        diff_ns_max / 1000000000.0, diff_ns_min / 1000000000.0,
        diff_inner_ns_max / 1000000000.0, diff_inner_ns_min / 1000000000.0);
}
int64_t send_to_sock(int sock) {
    struct timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    int ret = sendto(sock, &ts, sizeof(ts), 0, NULL, 0);
    if (ret < 0) {
        return -1;
    }
    return ts.tv_sec * 1000000000 + ts.tv_nsec;
}
void wait_recv(int sock, int use_cmsg) {
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(sock, &rfds);
    struct timeval timeOut = {0, 0};
    int ret = -1;
    for (;;) {
        ret = select(sock + 1, &rfds, NULL, NULL, NULL);
        if (ret < 0) {
            log("cannot select");
            return;
        }
        show_so_timestamp(sock, use_cmsg);
    }
}
void server_loop() {
    int sock = create_server_socket();
    if (sock < 0) {
        return;
    }
    wait_recv(sock, 1);
    destroy_socket(sock);
}
static const int64_t interval_us = 100 * 1000;
static int client_sock = -1;
#ifdef _QNX_
void client_notify_function() {
    send_to_sock(client_sock);
#else
void *client_notify_function(void *arg) {
    for (;;) {
        send_to_sock(client_sock);
        usleep(interval_us);
    }
    return NULL;
#endif
}
void client_loop(const char *ip) {
    client_sock = create_client_socket(ip);
    if (client_sock < 0) {
        return;
    }
#ifdef _QNX_
    timer_t timer_id;
    struct sigevent event;
    memset(&event, 0, sizeof(event));
    event.sigev_value.sival_ptr = &timer_id;
    event.sigev_notify = SIGEV_THREAD;
    event.sigev_notify_function = client_notify_function;
    timer_create(CLOCK_REALTIME, &event, &timer_id);
    struct itimerspec itime;
    memset(&itime, 0, sizeof(itime));
    itime.it_value.tv_nsec = interval_us * 1000;
    itime.it_interval.tv_nsec = interval_us * 1000;
    timer_settime(timer_id, 0, &itime, NULL);
#else
    pthread_t thread;
    pthread_create(&thread, NULL, client_notify_function, NULL);
#endif
    wait_recv(client_sock, 0);
    destroy_socket(client_sock);
}
int main(int argc, char *argv[]) {
#ifdef _QNX_
    struct _clockperiod period;
    period.nsec = 10000;
    period.fract = 0;
    ClockPeriod(CLOCK_REALTIME, &period, NULL, 0);
#endif
    if (argc < 2) {
        server_loop();
    } else {
        client_loop(argv[1]);
    }
}
橘色的喵
关注
  • 27
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
QNX 官方完全源代码 供学习参考 展开200M
02-21
4. 先进的网络功能：QNX内建了强大的网络协议栈，支持TCP/IP和其他多种网络协议，能够高效地处理网络通信任务，适应各种网络环境。 学习QNX源代码，开发者可以从以下几个方面入手： - 学习微内核设计思想，理解如何...
QNX Neutrino 微内核
wwq_wu_hxd的专栏
03-11 1715
QNX Neutrino 微内核   微内核实现了POSIX特性，连同基本的QNX中微子消息传递服务，用于嵌入式realtime 操作系统。   在procnto微内核中（file and device I/O, for example）没有被实现的POSIX特性，是由可选进程和共享库提供的。   Note:要确定系统上内核的发布版本，请使用uname -a命令   从QNX软件系统的后续微内核已...
爱测未来移动-QNX性能监控方案
爱测未来团队博客
05-16 3760
1、背景介绍 目前各平台通过各自的脚本获取数据，然后通过其他工具对数据进行展示，方案已能够满足当前的项目需求，但跨平台数据统计项和数据展示方式不一致，可对比性较差。 当前的监控方案是通过shell脚本，定期执行top命令收集cpu使用信息，执行showmem命令收集内存使用信息，然后保存到日志文件中。最后将日志文件下载到PC并导入Excel对数据进行筛选和分析，展示出cpu和内存的使用情况
[转]QNX_startup程序分析内容讲解
xjhhjx的专栏
06-02 1435
如果你认为本系列文章对你有所帮助，请大家有钱的捧个钱场，点击此处赞助，赞助额0.1元起步，多少随意 声明：本文只用于个人学习交流，若不慎造成侵权，请及时联系我，立即予以改正 锋影 email:174176320@qq.com 这篇文章主要描述QNX的startup程序功能及组成，分析了system page结构，以及该结构中跟硬件相关性较大的hwinfo段与callout段。...
Linux时间函数
lawliet_wy的专栏
12-29 391
系统环境：ubuntu10.04 简介 本文旨在为了解Linux各种时间类型与时间函数提供技术文档。 1、Linux下常用时间类型 Linux下常用时间类型有四种：time_t、struct tm、struct timeval、struct timespec 1.1 time_t时间类型 time_t类型在time.h中定义： [cpp] view p
【qnx】统计时间消耗
静谧、淡雅
06-03 241
QNX系统统计某一操作的时间消耗👇 #include <sys/syspage.h> #include <sys/neutrino.h> #include <inttypes.h> uint64_t start = ClockCycles(); 操作； uint64_t finish = ClockCycles(); double time = (double)(finish - start) / (SYSPAGE_ENTRY(qtime)->cycles_p.
QNX 源代码，用于学习
04-03
6. 网络编程：了解QNX如何实现网络通信，包括套接字编程和网络协议的处理。 7. 安全性和稳定性：查看QNX如何实现其高可靠性，例如错误处理和恢复机制。 通过仔细研究QNX源代码，你不仅能提升对实时操作系统的理解...
QNX netrino源代码
05-19
2. 进程管理（Process Management）：QNX支持多任务并行执行，其进程管理机制确保了高效的任务切换和资源分配。 3. 内存管理（Memory Management）：内存管理系统负责内存的分配、回收和保护，确保内存的高效使用和...
OpenSSH QNX4:OpenSSH QNX4 端口-开源
06-29
OpenSSH QNX4 端口
Open Watcom QNX4:打开 Watcom QNX4 端口-开源
07-09
打开 Watcom QNX4 Port C、C++ 编译器和工具
QNX----第2章 QNX Neutrino 线程 进程与调度策略（2部分）
u011996698的博客
01-16 2173
同步服务 QNX中微子RTOS提供了posix标准的线程级同步原语，其中一些在不同进程的线程之间是有用的。 同步服务至少包括以下内容:     互斥:互斥锁 互斥锁或互斥锁是最简单的同步服务。互斥用于确保对线程间共享的数据的独占访问。 互斥对象通常被获取(pthread_mutex_lock()或pthread_mutex_timedlock())，并在访问共享数据(通常是关键部分)...
[QNX Hypervisor 2.2用户手册]7.2.1 Hypervisor跟踪事件
从0到1，突破自己
07-12 260
大多数qvm跟踪事件都是10级事件（Class 10 event）。但是，一些qvm线程也可能会对Hypervisor微内核进行内核调用。这些将会引起响应的内核调用事件。
QNX-定时器编程
weixin_43824344的博客
06-18 1425
在QNX中使用定时器编程，步骤大致如下： 1.1 创建定时器对象 在QNX中，使用timer_create()来创建定时器对象 clock_id表示使用的定时器时钟源，共有三种 CLOCK_REALTIM：标准POSIX定义的时钟，如果它处于省电模式，基于这个时钟的定时器可以唤醒处理器。 CLOCK_SOFTTIME CLOCK_MONOTONIC：这个时钟总是固定定时增加，无法调整 一般使用第一种 :这个参数表示定时器触发时使用什么应该传递什么事件，共有三种 信号，signal 脉冲：plu
QNX_startup程序分析内容讲解
I15902020106的博客
06-15 2024
声明：本文只用于个人学习交流，若不慎造成侵权，请及时联系我，立即予以改正 锋影 email:174176320@qq.com     这篇文章主要描述QNX的startup程序功能及组成，分析了system page结构，以及该结构中跟硬件相关性较大的hwinfo段与callout段。 1. startup介绍 在一个可启动的QNX镜像中，startup是第一个启动...
交叉编译后，应用程序无法在QNX系统上执行的问题的排查记录
最新发布
liuxunwei1的博客
04-19 1625
这个问题给我的一个提示是：交叉编译中，在编译环境中如果通过，而在运行环境中无法运行，说明：编译环境与运行环境存在不一致的情况，这个就需要验证环境的一致性或者。
c语言设置qnx系统时间
qinqin150的专栏
05-22 1932
#include #include #include #include int main( void )   {     struct timespec stime;     struct tm *ptm;     time_t tvtmp, tvsec;     ptm=localtime(&tvtmp);     ptm->tm_hour = 14;
QNX系列：三、时钟与定时器
擦擦擦大侠的博客
12-11 4771
文章目录@[toc]时钟，计时器和踢脚时钟和计时器定期运行时钟中断源基本时序分辨率获得更高的精度定时抖动计时器类型通知方案如何填写 `struct sigevent`脉冲通知信号通知线程通知通知的一般技巧脉冲通知信号通知 Signal notification使用计时器创建一个计时器Signal, pulse, or thread?什么样的计时器？What kind of timer?具有周期性脉冲的服务器服务器维护的超时声明书*主要（）**setupPulseAndTimer（）**gotAPulse（）
发送调节器 PacedSender代码走读
好记性不如写博客！
10-31 1603
一、简介 1.1、PacedSender（步长发送器） 无线网络最害怕的一个是干扰，一个是突然的大数据量冲击。视频编码后分关键帧I帧和非关键帧P帧，I帧一般是P帧的几十倍大小，比如一个I帧200k，一个p帧10k。如果不加处理的有视频帧就发，就会造成很多瞬间的传输峰值，对网络造成冲击。pacedsender的作用就是平缓突发的数据流，让发送数据流整体平坦，避免对无线网络造成冲击。...
计算机组成学习笔记1.1
wake_alone
07-05 739
Elapsed time 总得反应时间CPU time CPU时间=CPU Clock Cycles （CPU时钟周期=数CPU时钟循环次数）*Clock Cycle Time（时钟周期） =CPU Clock Cycles （CPU时钟周期数）/Clock Rate（时钟频率）Instruction Count 指令数Average cycles per instruction (CPI)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

橘色的喵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值