C++ Thread多线程并发记录（11）多核计算Base16编码

最新推荐文章于 2024-07-09 22:37:42 发布

CodingKit

最新推荐文章于 2024-07-09 22:37:42 发布

阅读量112

点赞数 2

文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/qq_42761215/article/details/139538228

版权

#include <iostream>
#include <vector>
#include <chrono>
#include <thread>
#include <unordered_map>

//编码表
static std::unordered_map<int, char> base16{{0,  '0'},
                                            {1,  '1'},
                                            {2,  '2'},
                                            {3,  '3'},
                                            {4,  '4'},
                                            {5,  '5'},
                                            {6,  '6'},
                                            {7,  '7'},
                                            {8,  '8'},
                                            {9,  '9'},
                                            {10, 'A'},
                                            {11, 'B'},
                                            {12, 'C'},
                                            {13, 'D'},
                                            {14, 'E'},
                                            {15, 'F'}
};

//Base16编码
static void Base16Encode(unsigned char *data, int size, unsigned char *output) {
    for (int i = 0; i < size; ++i) {
        unsigned char byte_ = data[i];
        char high_bit = base16[byte_ >> 4];
        char low_bit = base16[byte_ & 0x0F];
        output[i * 2] = high_bit;
        output[i * 2 + 1] = low_bit;
    }
}

//多线程Base16编码
void Base16EncodeThread(std::vector<unsigned char> &data, std::vector<unsigned char> &output){
    //数据切片
    size_t size = data.size();
    auto thread_count = std::thread::hardware_concurrency(); //CPU支持的最大线程数
    int slice_count = size / thread_count;
    //处理数据量很小的情况
    if (size < thread_count){
        //如果数据切片数量小于线程数
        thread_count = 1;
        slice_count = size;
    }

    //准备线程
    std::vector<std::thread> ths;
    ths.resize(thread_count);   //分配线程数量
    //任务分配
    for (int i = 0; i < thread_count; ++i) {
        int offset = i * slice_count;
        int count = slice_count;

        if (thread_count > 1 && i == thread_count - 1){
            count = slice_count + size % thread_count;
        }
        ths[i] = std::thread(Base16Encode, data.data() + offset, count, output.data());
    }
    for (auto & th : ths) {
        if (th.joinable())
            th.join();
    }

}

int main() {
    //编码测试
/*    std::string str_test{"Base16 encoding test."};
    char test[1024] = {};
    Base16Encode((unsigned char *)str_test.c_str(), str_test.size(), (unsigned char *)test);
    std::cout << test << std::endl;*/

    //待编码数据准备
    std::vector<unsigned char> data_test;
    data_test.resize(1024 * 1024 * 100); //100M
    for (int i = 0; i < data_test.size(); ++i) {
        data_test[i] = i % 256;
    }

    //单线程测试
    {
        std::vector<unsigned char> output1;
        output1.resize(data_test.size() * 2);
        std::cout << "one thread start -> " << std::endl;
        auto start_time = std::chrono::system_clock::now();
        Base16Encode(data_test.data(), data_test.size(), output1.data());
        auto end_time = std::chrono::system_clock::now();
        auto time_duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time) ;
        std::cout << data_test.size() / (1024 * 1024) << " M bytes encode cost " << time_duration.count() << "milliseconds" << std::endl;
    }
    //多线程测试
    {
        std::vector<unsigned char> output1;
        output1.resize(data_test.size() * 2);
        std::cout << "Muti-Thread start -> " << std::endl;
        auto start_time = std::chrono::system_clock::now();
        //Base16Encode(data_test.data(), data_test.size(), output1.data());
        Base16EncodeThread(data_test, output1);
        auto end_time = std::chrono::system_clock::now();
        auto time_duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time) ;
        std::cout << data_test.size() / (1024 * 1024) << " M bytes encode cost " << time_duration.count() << "milliseconds" << std::endl;
    }

    return 0;
}