QNX时钟调研

news2025/8/15 10:41:32

SYSPAGE_ENTRY()的使用，SYSPAGE_ENTRY

测试QNX下printf(“poo\n”);的耗时

#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() 和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);
}

输出
在这里插入图片描述

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

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]);
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1281633.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

P7 链表 链表头前方插入新节点

P7 链表 链表头前方插入新节点

目录 前言 01 链表头插入数据 示例代码 02 指定节点前方插入新节点 测试代码 前言 &#x1f3ac; 个人主页&#xff1a;ChenPi &#x1f43b;推荐专栏1: 《C》✨✨✨ &#x1f525; 推荐专栏2: 《 Linux C应用编程&#xff08;概念类&#xff09;_ChenPi的博客-CSDN博客》✨…
阅读更多...
Linux系统配置深度学习环境之cudnn安装

Linux系统配置深度学习环境之cudnn安装

前言 一个针对深度学习应用优化的 GPU 加速库。它提供了高性能、高可靠性的加速算法&#xff0c;旨在加速深度神经网络模型的训练和推理过程。 cuDNN 提供了一系列优化的基本算法和函数&#xff0c;包括卷积、池化、规范化、激活函数等&#xff0c;以及针对深度学习任务的高级功…
阅读更多...
【MySQL的DQL查询语句】

【MySQL的DQL查询语句】

MySQL的DQL查询语句-----在Navicat下 将学生表导入Navicat中查询语句查询一整张表查询年龄大于22年龄大于22的女生查找文科的学生查找六班的学生计算学生的总分 &#xff08;group by&#xff09;合并两表 &#xff08;join on xxxx&#xff09;合并两张表 并求总分先合并在聚合…
阅读更多...
一站式自动化：Ansible Playbook的全面学习之旅

一站式自动化：Ansible Playbook的全面学习之旅

1 Playbook介绍 1.1 Playbook介绍 playbook 是由一个或多个play组成的列表 Playbook 文件使用YAML来写的 1.2 YAML 1.2.1 介绍 是一种表达资料序列的格式&#xff0c;类似XML Yet Another Markup Language 2001年首次发表 www.yaml.org 1.2.2 特点 可读性好 和脚本语言交…
阅读更多...
机器学习笔记 - 什么是模型量化压缩技术？

机器学习笔记 - 什么是模型量化压缩技术？

一、简述 我们都知道现实世界是连续的状态，而计算机世界是离散的状态，这是什么意思呢？我们看一下下图，最右边的马力欧（高清）的状态，可以想象现实世界是连续的状态，而电脑世界在图像上呈现的是一格一格子的状态（左图）是离散的状态。 所以在计算机世界如果想要…
阅读更多...
医疗器械设备模组的具体应用

医疗器械设备模组的具体应用

直线模组是一种高精度、高速度的精密传动元件&#xff0c;目前被广泛应用在各种工业自动化领域&#xff1b;尤其是在激光加工、电子制造、医疗设备、物流设备和机器人等行业中&#xff0c;都发挥着重要作用&#xff0c;接下来我们看看医疗器械设备模组的具体应用吧&#xff01;…
阅读更多...
智慧灯杆系统平台架构设计需要考虑的几个要点

智慧灯杆系统平台架构设计需要考虑的几个要点

智慧灯杆是一种集成了各种先进技术的道路照明设施。它不仅提供照明服务&#xff0c;还可以具有物联网技术、视频监控、环境监测、广播通讯、无线网络覆盖等多种功能。这些智能功能可以通过互联网进行控制和管理&#xff0c;从而实现智慧城市的建设。智慧灯杆能够提升城市的智能…
阅读更多...
Webgis学习总结

Webgis学习总结

前言&#xff1a; 作者跟随视频学习了webgis内容进行如下学习复习总结 参考&#xff1a;新中地学习笔记 WebGIS第一课&#xff1a;测试高德API并通过&#xff1a; 注册申请高德API成为开发者&#xff0c;创建自己的项目和key进行项目初始化&#xff0c;可以使用JS API官方文…
阅读更多...
PyQt6 QComboBox下拉组合框控件

PyQt6 QComboBox下拉组合框控件

​锋哥原创的PyQt6视频教程&#xff1a; 2024版 PyQt6 Python桌面开发 视频教程(无废话版) 玩命更新中~_哔哩哔哩_bilibili2024版 PyQt6 Python桌面开发 视频教程(无废话版) 玩命更新中~共计34条视频&#xff0c;包括&#xff1a;2024版 PyQt6 Python桌面开发 视频教程(无废话…
阅读更多...
算法基础--双指针

算法基础--双指针

前面已经写了两篇关于算法方面的文章&#xff0c;这几天想了下&#xff0c;决定把这个算法整理成一个系列&#xff0c;除了是帮助自己巩固算法知识外&#xff0c;还能够把自己总结的每种算法的套路保存下来并分享给大家&#xff0c;这样以后即使是哪天想要重拾起来&#xff0c;…
阅读更多...
Apache Doris 详细教程（三）

Apache Doris 详细教程（三）

7、监控和报警 Doris 可以使用 Prometheus 和 Grafana 进行监控和采集&#xff0c;官网下载最新版即可。 Prometheus 官网下载&#xff1a;https://prometheus.io/download/ Grafana 官网下载&#xff1a;https://grafana.com/grafana/download Doris 的监控数据通过 FE 和…
阅读更多...
排序算法介绍（四）快速排序

排序算法介绍（四）快速排序

0. 简介 快速排序&#xff08;Quick Sort&#xff09;是一种高效的排序算法&#xff0c;采用了分治的思想。它选择一个基准元素&#xff0c;通过一趟排序将待排序序列分割成独立的两部分&#xff0c;其中一部分的所有元素都比基准元素小&#xff0c;另一部分的所有元素都比基准…
阅读更多...
C++-类和对象

C++-类和对象

目录 一.C语言和C的区别 二.类的引入 三.类的定义 1.类的定义 2.类的成员方法的两种定义方式&#xff1a; 3.类的成员变量的定义 四.类的访问限定符及封装 1.访问限定符 五.面向对象的三大特征 1.面向对象的三大特征分别是什么 2.封装 六.类的作用域 七.创建类对象 1.类…
阅读更多...
【csdn默认使用操作详解】

【csdn默认使用操作详解】

这里写自定义目录标题 欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题&#xff0c;有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants 创建一个自定义列表如何创建一个…
阅读更多...
国际语音通知系统有哪些优点？国际语音通知系统有哪些应用场景?

国际语音通知系统有哪些优点？国际语音通知系统有哪些应用场景?

国际语音通知是一种全球性的通信工具&#xff0c;它通过语音方式向用户发送各种重要信息和提示。无论是快递到货的取件提醒、机场航班的延误通知&#xff0c;还是银行账户的余额提醒&#xff0c;国际语音通知都能准确、迅速地将信息传达给用户。 三、国际语音通知系统有哪些优…
阅读更多...
qnx修改tcp和udp缓冲区默认大小

qnx修改tcp和udp缓冲区默认大小

拷贝/home/test/qnx/qos223/target/qnx7/aarch64le/sbin/sysctl进系统中 https://www.qnx.com/developers/docs/7.1/#com.qnx.doc.neutrino.utilities/topic/s/sysctl.html kern.sbmax 默认262144&#xff0c;这个限制住了发送、接收缓冲器大小 ./sysctl -w kern.sbmax10000…
阅读更多...
51单片机应用从零开始（十）·指针

51单片机应用从零开始（十）·指针

指针 C语言指针是一种保存变量地址的数据类型。它可以让程序直接访问内存中的数据&#xff0c;而不需要通过变量名来访问。指针变量存储的是一个地址&#xff0c;这个地址指向内存中的某个位置&#xff0c;该位置存储了一个值。 在C语言中&#xff0c;可以使用&运算符取得一…
阅读更多...
Siemens-NXUG二次开发-Java开发环境配置[20231203]

Siemens-NXUG二次开发-Java开发环境配置[20231203]

Siemens-NXUG二次开发-Java开发环境配置[20231203] 1.NX/UG Java API官方开发文档2.安装Java83.安装jetbrain idea3.windows系统环境变量配置4.使用idea创建项目5.NXOpen Java代码生效流程6.API体系简述6.代码示例 1.NX/UG Java API官方开发文档 西门子NX/UG Java api开发文档…
阅读更多...
严蔚敏数据结构题集 p18（2.25——2.30）（c语言代码实现）

严蔚敏数据结构题集 p18（2.25——2.30）（c语言代码实现）

目录 2.25假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合(即同一表中的元素值各不相同),现要求另辟空间构成一个线性表C,其元素为A和B中元素的交集,且表C中的元素也依值递增有序排列。试对顺序表编写求C的算法。 2.26要求同2.25题。是对单链表编写求C的算法 2.…
阅读更多...
03-IDEA集成Git,初始化本地库,添加远程仓库,提交,拉取,推送,分支的快捷操作

03-IDEA集成Git,初始化本地库,添加远程仓库,提交,拉取,推送,分支的快捷操作

IDEA集成Git 创建Git忽略文件 不同的IDE开发工具有不同的特点文件,这些文件与项目的实际功能无关且不参与服务器上的部署运行, 把它们忽略掉能够屏蔽之间的差异 局部忽略配置文件: 在本地仓库的根目录即项目根目录下直接创建.gitignore文件, 以文件后缀或目录名的方式忽略指定…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023