C++小白实习日记——Day 5 gitee怎么删文件，测试文件怎么写循环

昨晚一直内耗，一个程序写了三天写不出来，主要是耗时太多了，老板一直不满意。想在VScode上跑一下，昨晚一直报错。今天来公司重新搞了一下，

主要工作有：

1，读取当前时间用tscns

2，输出不用cout用fmt::print或者logi输出

3，ns到北京时间转换用fmtlog.h文件中的方式算出来

4，把昨天晚上上传gitee的文件删掉，重新上传

5，写一个100万次的循环，测试输出时间，给出最大最小值，中位数，标准差，统计各个时间阶段的百分比

如何缩短输出时间：

老板要求从获取时间到时间转化到输出时间，所有的时间在几百ns内，但是我只读取时间然后转化就几百ns，打印时间耗费时间更多，和老板沟通过后，老板说先传到git看看，并且封装成函数，输入0，1，2分别给出获取一次时间，转化为北京时间和总共时间，我今天改的代码：

#include <iostream>
#include <chrono>
#include "../fmtlog.h"
#include "../fmtlog-inl.h" // 假设 TSCNS 类定义在 fmtlog-inl.h 中

// 函数根据模式返回不同的时间统计结果
int get_time(int mode) {
    // 创建 TSCNS 实例并初始化
    fmtlog::TSCNS tscns;
    tscns.init();
    fmtlogDetailT<> fmtlog;

    int64_t tsc = tscns.rdns();
    int64_t tsc1 = tscns.rdns();

    // 调用 resetDate 获取午夜时间戳
    uint64_t midnightNs = fmtlog.midnightNs;

    // 测量输出北京时间的耗时
    int64_t tsc2 = tscns.rdns();
    uint64_t t = (static_cast<uint64_t>(tsc) > midnightNs)
                 ? (static_cast<uint64_t>(tsc) - midnightNs)
                 : 0;

    uint64_t nanoseconds = t % 1000000000;
    t /= 1000000000;
    uint64_t seconds = t % 60;
    t /= 60;
    uint64_t minutes = t % 60;
    t /= 60;
    uint32_t hours = t;

    if (hours > 23) {
        hours %= 24;
        fmtlog.resetDate();
    }
    int64_t tsc3 = tscns.rdns();

    // 输出格式化的北京时间
    fmt::print("Beijing Time: {:02}{:02}{:02}{:09} ns\n", hours, minutes, seconds, nanoseconds);
    int64_t tsc4 = tscns.rdns();
    // 计算获取时间和格式化所用的时间
    int64_t duration_get_ns = tsc1 - tsc;
    int64_t duration_format_ns = tsc3 - tsc2;
    int64_t duration_print_ns = tsc4 - tsc3;

    // 根据模式返回不同的结果
    if (mode == 0) {
        fmt::print("Time taken to retrieve time: {} ns\n", duration_get_ns);
        return int(duration_get_ns);
    } else if (mode == 1) {
        fmt::print("Time taken to format and output Beijing time: {} ns\n", duration_format_ns);
        return int(duration_format_ns);
    } else if (mode == 2) {
        int total_time = int(duration_print_ns+duration_format_ns);
        fmt::print("Total time: {} ns\n", total_time);
        return total_time;
    } else {
        fmt::print("Invalid mode. Please enter 0, 1, or 2.\n");
        return -1;
    }
}

int main() {
    int mode;
    std::cout << "Enter mode (0: Retrieve time, 1: Format time, 2: Total time): ";
    std::cin >> mode;

    int result = get_time(mode);
    if (result != -1) {
        fmt::print("Result: {} ns\n", result);
    }
    return 0;
}

 1,用TSCNS获取时间比直接用std::chrono::high_resolution_clock::now()快

我直接用了

int64_t timestamp_ns = tn.rdns();

2，用logi输出和用fmt::print

按道理logi比fmt::print快，但是fmtlog的logi有初始定义所以，我修改了logi的宏定义，但其实我觉得两中print方法差不多，都很慢，量级在几万ns，老板说我最早的时候用的

std::setw(2) << std::setfill('0')会更慢

用release跑比用 debug模式跑会快（这个我之前也了解过，但是Clion怎么设置release模式不太会，我自己设置了一下，但是不知道对不对，后面服务器满了我想着删掉点东西，结果误删了cmake-Debug,文件后面跑一直报错，然后我重新github上下载了一下-_-!)

如何写测试文件：

老板让我多测试测试，我昨天只设置了100次循环，他说太少了，所以我设置了100万次循环：

代码： 

/*
 * 测试文件获取当前时间，并转化为北京时间的时间分布，以及获取一次时间并加上转化时间的时间间隔
 * 计算最大时间，最小时间，标准差，中位数，将时间按0-50，50-100，100-150，150-200分类
 * 测试次数100万次
 * */
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <numeric>
#include "../fmtlog.h"
#include "../fmtlog-inl.h" // 假设 TSCNS 类定义在 fmtlog-inl.h 中

int main() {
    // 创建 TSCNS 实例并初始化
    fmtlog::TSCNS tscns;
    tscns.init();
    fmtlogDetailT<> fmtlog;

    const int num_iterations = 1000000;

    // 存储每次获取时间和格式化时间的耗时
    std::vector<int64_t> retrieve_times;
    std::vector<int64_t> format_times;
    std::vector<int64_t> all_times;

    // 存储分布统计
    std::vector<int> retrieve_time_buckets(5, 0);
    std::vector<int> format_time_buckets(5, 0);
    std::vector<int> all_time_buckets(5, 0);

    for (int i = 0; i < num_iterations; ++i) {
        // 测量获取时间的耗时
        int64_t tsc_start_get = tscns.rdns();
        int64_t tsc_end_get = tscns.rdns();
        int64_t duration_get_ns = tsc_end_get - tsc_start_get;
        retrieve_times.push_back(duration_get_ns);

        // 统计获取时间的分布
        if (duration_get_ns <= 50) retrieve_time_buckets[0]++;
        else if (duration_get_ns <= 100) retrieve_time_buckets[1]++;
        else if (duration_get_ns <= 150) retrieve_time_buckets[2]++;
        else if (duration_get_ns <= 200) retrieve_time_buckets[3]++;
        else retrieve_time_buckets[4]++;

        // 测量格式化北京时间的耗时
        int64_t tsc_start_format = tscns.rdns();
        uint64_t tsc = tscns.rdns();
        uint64_t t = (static_cast<uint64_t>(tsc) > fmtlog.midnightNs)
                     ? (static_cast<uint64_t>(tsc) - fmtlog.midnightNs)
                     : 0;

        uint64_t nanoseconds = t % 1000000000;
        t /= 1000000000;
        uint64_t seconds = t % 60;
        t /= 60;
        uint64_t minutes = t % 60;
        t /= 60;
        uint32_t hours = t;

        if (hours > 23) {
            hours %= 24;
            fmtlog.resetDate();
        }
        int64_t tsc_end_format = tscns.rdns();
        int64_t duration_format_ns = tsc_end_format - tsc_start_format;
        format_times.push_back(duration_format_ns);

        // 统计格式化时间的分布
        if (duration_format_ns <= 50) format_time_buckets[0]++;
        else if (duration_format_ns <= 100) format_time_buckets[1]++;
        else if (duration_format_ns <= 150) format_time_buckets[2]++;
        else if (duration_format_ns <= 200) format_time_buckets[3]++;
        else format_time_buckets[4]++;

        // 统计总时间
        int64_t all_time = duration_get_ns + duration_format_ns;
        all_times.push_back(all_time);
        if (all_time <= 50) all_time_buckets[0]++;
        else if (all_time <= 100) all_time_buckets[1]++;
        else if (all_time <= 150) all_time_buckets[2]++;
        else if (all_time <= 200) all_time_buckets[3]++;
        else all_time_buckets[4]++;
    }

    // 计算统计数据
    auto calculate_stats = [](const std::vector<int64_t>& times) {
        int64_t min_time = *std::min_element(times.begin(), times.end());
        int64_t max_time = *std::max_element(times.begin(), times.end());
        double mean = std::accumulate(times.begin(), times.end(), 0.0) / times.size();

        double sq_sum = std::inner_product(times.begin(), times.end(), times.begin(), 0.0,
                                           std::plus<>(), [mean](double x, double y) { return (x - mean) * (y - mean); });
        double std_dev = std::sqrt(sq_sum / times.size());

        std::vector<int64_t> sorted_times = times;
        std::sort(sorted_times.begin(), sorted_times.end());
        int64_t median = sorted_times[times.size() / 2];

        return std::make_tuple(min_time, max_time, mean, std_dev, median);
    };

    // 输出统计数据
    auto [retrieve_min, retrieve_max, retrieve_mean, retrieve_std_dev, retrieve_median] = calculate_stats(retrieve_times);
    auto [format_min, format_max, format_mean, format_std_dev, format_median] = calculate_stats(format_times);
    auto [all_min, all_max, all_mean, all_std_dev, all_median] = calculate_stats(all_times);

    fmt::print("Retrieve Time Stats:\n");
    fmt::print("Min: {} ns, Max: {} ns, Mean: {:.2f} ns, Std Dev: {:.2f} ns, Median: {} ns\n",
               retrieve_min, retrieve_max, retrieve_mean, retrieve_std_dev, retrieve_median);

    fmt::print("\nFormat Time Stats:\n");
    fmt::print("Min: {} ns, Max: {} ns, Mean: {:.2f} ns, Std Dev: {:.2f} ns, Median: {} ns\n",
               format_min, format_max, format_mean, format_std_dev, format_median);

    fmt::print("\nAll Time Stats:\n");
    fmt::print("Min: {} ns, Max: {} ns, Mean: {:.2f} ns, Std Dev: {:.2f} ns, Median: {} ns\n",
               all_min, all_max, all_mean, all_std_dev, all_median);

    // 计算分布百分比
    auto calculate_percentage = [&](const std::vector<int>& buckets) {
        std::vector<double> percentages(buckets.size());
        for (size_t i = 0; i < buckets.size(); ++i) {
            percentages[i] = static_cast<double>(buckets[i]) / num_iterations * 100.0;
        }
        return percentages;
    };

    auto retrieve_percentages = calculate_percentage(retrieve_time_buckets);
    auto format_percentages = calculate_percentage(format_time_buckets);
    auto all_percentages = calculate_percentage(all_time_buckets);

    fmt::print("\nRetrieve Time Distribution (Count and %):\n");
    for (size_t i = 0; i < retrieve_percentages.size(); ++i) {
        fmt::print("Bucket {}: Count = {}, Percentage = {:.2f}%\n", i, retrieve_time_buckets[i], retrieve_percentages[i]);
    }

    fmt::print("\nFormat Time Distribution (Count and %):\n");
    for (size_t i = 0; i < format_percentages.size(); ++i) {
        fmt::print("Bucket {}: Count = {}, Percentage = {:.2f}%\n", i, format_time_buckets[i], format_percentages[i]);
    }

    fmt::print("\nAll Time Distribution (Count and %):\n");
    for (size_t i = 0; i < all_percentages.size(); ++i) {
        fmt::print("Bucket {}: Count = {}, Percentage = {:.2f}%\n", i, all_time_buckets[i], all_percentages[i]);
    }

    return 0;
}

结果： 

 为什么最短时间和最长时间相差很多：

老板说是因为没有绑核，所以输出不稳定，然后给了我一个绑核的代码：

cpu_set_t cpu_mask;
CPU_ZERO(&cpu_mask);
CPU_SET(mp_tdMgr->m_queryCpuCore, &cpu_mask);
// 设置对应的线程核心
int ret = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpu_mask);
if (ret != 0) {
    loge("[PsiSubTrader] Trader Run Worker thread affinity failed! ret:{}", ret);
} else {
    logi("[PsiSubTrader] Trader Run Worker thread affinity success! cpu core:{}", mp_tdMgr->m_queryCpuCore);
}

如何删除gitee提交的文件

 昨天晚上提交的文件fmtlog里面有.git文件，这样的话会导致gitee仓库那边打不开提交的文件，先删除远程仓库里的错误文件：

两种方法：

1，右键单击文件然后弹出选项选择删除

2，本地操作 ，利用git，cd进库文件夹——>dir会显示当前文件夹下的文件——>git rm -r --cached 待删除的文件名如：git rm -r --cached fmtlog——>git commit -m "删除了文件fmtlog"——>git push

要注意，提交到仓库的文件里面不能有.git（我提交的文件fmtlog和fmt里面都有.git,所以往gitee仓库里面提交了好多次-_-!）

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

ssm143校园一卡通系统软件的设计与实现+jsp(论文+源码)_kaic

ssm143校园一卡通系统软件的设计与实现+jsp(论文+源码)_kaic

毕 业 设 计&#xff08;论 文&#xff09; 题目&#xff1a;校园一卡通系统设计与实现 摘 要 现代经济快节奏发展以及不断完善升级的信息化技术&#xff0c;让传统数据信息的管理升级为软件存储&#xff0c;归纳&#xff0c;集中处理数据信息的管理方式。本校园一卡通系统就是…
阅读更多...
[Go]-sync.map使用详解

[Go]-sync.map使用详解

sync.Map是 Go 语言中在并发环境下使用的安全映射类型。 一、为什么需要sync.Map 在 Go 语言中&#xff0c;普通的map不是并发安全的。当多个 goroutine 同时读写一个普通map时&#xff0c;可能会导致程序出现未定义的行为&#xff0c;比如数据竞争、程序崩溃等。而sync.Map则…
阅读更多...
迁移学习理论与应用

迁移学习理论与应用

迁移学习&#xff08;Transfer Learning&#xff09;是一种机器学习技术&#xff0c;旨在将一个任务&#xff08;源任务&#xff09;上学到的知识迁移到另一个相关但不完全相同的任务&#xff08;目标任务&#xff09;上&#xff0c;从而提高目标任务的学习效果。这种方法的核心…
阅读更多...
孙玲：从流水线工人到谷歌程序员

孙玲：从流水线工人到谷歌程序员

这是《开发者说》的第24期&#xff0c;本期我们邀请的开发者是孙玲&#xff0c;她出生于湖南娄底一个贫穷的农村家庭&#xff0c;2009年高考落榜&#xff0c;她去了深圳一家电子厂&#xff0c;在流水线上给电池喷码&#xff0c;每天12个小时轮班&#xff0c;月薪2300&#xff0…
阅读更多...
深度解析FastDFS：构建高效分布式文件存储的实战指南（上）

深度解析FastDFS：构建高效分布式文件存储的实战指南（上）

文章目录 一、FastDFS简介1.1 概述1.2 特性 二、FastDFS原理架构2.1 FastDFS角色2.2 存储策略2.3 上传过程2.4 文件同步2.5 下载过程 三、FastDFS适用场景四、同类中间件对比4.1 FastDFS和集中存储方式对比4.2 FastDFS与其他文件系统的对比 五、FastDFS部署5.1 单机部署5.1.1 使…
阅读更多...
Argo workflow 拉取git 并使用pvc共享文件

Argo workflow 拉取git 并使用pvc共享文件

文章目录 拉取 Git 仓库并读取文件使用 Kubernetes Persistent Volumes&#xff08;通过 volumeClaimTemplates&#xff09;以及任务之间如何共享数据 拉取 Git 仓库并读取文件 在 Argo Workflows 中&#xff0c;如果你想要一个任务拉取 Git 仓库中的文件&#xff0c;另一个任…
阅读更多...
Xilinx 7 系列 FPGA的各引脚外围电路接法

Xilinx 7 系列 FPGA的各引脚外围电路接法

Xilinx 7系列FPGA的外围电路接法涉及到多个方面&#xff0c;包括电源引脚、时钟输入引脚、FPGA配置引脚、JTAG调试引脚&#xff0c;以及其他辅助引脚。 本文大部分内容由ug475, Product Specification——7 Series FPGAs Packaging and Pinout《7系列FPGA的封装与引脚》整理汇…
阅读更多...
CDH大数据平台搭建

CDH大数据平台搭建

各大开源以及商用厂商的大数据产品汇总&#xff1a; https://zhuanlan.zhihu.com/p/675011462 Ambari 界面&#xff1a; 一、安装一个新的虚拟机 配置要求&#xff1a;8核&#xff0c;10G内存&#xff0c;最好是200G 修改yum源&#xff1a; 修改阿里云的镜像文件&#xff1…
阅读更多...
计算机毕业设计 | SpringBoot+vue汽车资讯网站 汽车购买咨询管理系统(附源码+论文)

计算机毕业设计 | SpringBoot+vue汽车资讯网站 汽车购买咨询管理系统(附源码+论文)

1&#xff0c;绪论 1.1 研究背景 随着计算机技术的发展以及计算机网络的逐渐普及&#xff0c;互联网成为人们查找信息的重要场所&#xff0c;二十一世纪是信息的时代&#xff0c;所以信息的管理显得特别重要。因此&#xff0c;使用计算机来管理汽车资讯网站的相关信息成为必然…
阅读更多...
24.11.19 web框架

24.11.19 web框架

2.2配置环境变量 2.3maven命令测试 mvn -v 测试maven查看版本 2.4maven仓库配置 配置远程仓库地址 配置本地仓库 2.5idea中配置maven 2.6通过配置idea 创建maven项目 创建项目时 构建系统 选到maven 初次创建项目时 会把maven的基础依赖库(jar包) 下载到本地仓库 需要等待一…
阅读更多...
【Golang】——Gin 框架中的模板渲染详解

【Golang】——Gin 框架中的模板渲染详解

Gin 框架支持动态网页开发&#xff0c;能够通过模板渲染结合数据生成动态页面。在这篇文章中&#xff0c;我们将一步步学习如何在 Gin 框架中配置模板、渲染动态数据&#xff0c;并结合静态资源文件创建一个功能完整的动态网站。 文章目录 1. 什么是模板渲染&#xff1f;1.1 概…
阅读更多...
【list的模拟实现】—— 我与C++的模拟实现（十四）

【list的模拟实现】—— 我与C++的模拟实现（十四）

一、list节点 ​ list是一个双向循环带头的链表&#xff0c;所以链表节点结构如下&#xff1a; template<class T>struct ListNode{T val;ListNode* next;ListNode* prve;ListNode(int x){val x;next prve this;}};二、list迭代器 2.1、list迭代器与vector迭代器区别…
阅读更多...
QString 转 char*问题与方法（const_cast的使用问题)

QString 转 char*问题与方法（const_cast的使用问题)

1、背景:今天有QString的变量&#xff0c;将QString的值传递给void func(char * ptr)&#xff0c;于是就有了类似下面这一段离谱的代码 当时我还在想为什么var的值为空了&#xff0c;为什么呢。 2、原因:就是因为右边函数返回的是一个临时指针对象&#xff0c;给到了右边&…
阅读更多...
每天五分钟机器学习：支持向量机算法数学基础之核函数

每天五分钟机器学习：支持向量机算法数学基础之核函数

本文重点 从现在开始，我们将开启支持向量机算法的学习，不过在学习支持向量机算法之前，我们先来学习一些支持向量机所依赖的数学知识，这会帮助我们更加深刻的理解支持向量机算法，本文我们先来学习核函数。 定义 核函数（Kernel Function）是一种在支持向量机（SVM）、高…
阅读更多...
云原生之运维监控实践-使用Prometheus与Grafana实现对Nginx和Nacos服务的监测

云原生之运维监控实践-使用Prometheus与Grafana实现对Nginx和Nacos服务的监测

背景 如果你要为应用程序构建规范或用户故事&#xff0c;那么务必先把应用程序每个组件的监控指标考虑进来&#xff0c;千万不要等到项目结束或部署之前再做这件事情。——《Prometheus监控实战》 去年写了一篇在Docker环境下部署若依微服务ruoyi-cloud项目的文章&#xff0c;当…
阅读更多...
MiniMates：一款轻量级的图片数字人驱动框架

MiniMates：一款轻量级的图片数字人驱动框架

随着数字人技术的不断发展，越来越多的应用场景开始涌现，从虚拟主播到AI伴侣，数字人的应用范围越来越广。然而，现有的数字人驱动框架往往存在性能瓶颈、依赖性强、定制难度高等问题。近期，我发现了一款名为 MiniMates 的轻量级图片数字人驱动框架，它在性能、个性化定制和终…
阅读更多...
SpringBoot3_Web开发

SpringBoot3_Web开发

4. 内容协商 一套系统适配多端数据返回 移动端&#xff1a;返回JSON数据第三方&#xff1a;返回XMLIoT&#xff1a;返回自定义协议数据 1. 默认规则 1. SpringBoot 多端内容适配 基于请求头内容协商 【默认】 客户端向服务端发送请求&#xff0c;携带HTTP标准的 Accept 请求…
阅读更多...
C++ —— 剑斩旧我 破茧成蝶—C++11

C++ —— 剑斩旧我 破茧成蝶—C++11

江河入海&#xff0c;知识涌动&#xff0c;这是我参与江海计划的第2篇。 目录 1. C11的发展历史 2. 列表初始化 2.1 C98传统的{} 2.2 C11中的{} 2.3 C11中的std::initializer_list 3. 右值引用和移动语义 3.1 左值和右值 3.2 左值引用和右值引用 3.3 引用延长生命周期…
阅读更多...
mysql复习题（实验7-8）

mysql复习题（实验7-8）

建立一个学生入学信息管理&#xff08;x_y&#xff09;数据库&#xff0c;设计其数据库模式为&#xff1a; 学生表&#xff08;学号&#xff0c;姓名&#xff0c;性别&#xff0c;入学成绩&#xff0c;籍贯&#xff0c;院系编号&#xff09; 院系表&#xff08;院系编号&…
阅读更多...
详细分析ipvsadm负载均衡的命令

详细分析ipvsadm负载均衡的命令

目录 前言1. 基本知识2. 命令参数3. 拓展 前言 LVS四层负载均衡架构详解Lvs推荐阅读&#xff1a;添加链接描述 1. 基本知识 ipvsadm 是用于管理和配置 Linux 服务器上 IP Virtual Server (IPVS) 的工具&#xff0c;是 Linux 提供的一个负载均衡模块&#xff0c;支持多种负载…
阅读更多...
最新文章

Copyright @ 2022~2023