auto foo = [](int a ,int b){return a+b;};
int a = 10,b = 5;
std::print("foo {} a:{} b{}",foo(a,b),a,b);

struct d{
int cnt = 0;
};
d data;
std::atomic_ref<int> at_data (data.cnt);


std::jthread th0 ([&]{at.data++;});
std::jthread th1 ([&]{at.data+=3;})

#include <format>
#include <stdint.h>
#include <chrono>
#include <vector>
#include <thread>
#include <iostream>
#include <print>
#include <atomic>
#include <random>
int call = 0;
std::atomic <int64_t> size_out = 0;
int thread_id = 0;
struct _rand {
    std::mt19937_64 mt;
    _rand() {
        std::random_device rd;
        mt.seed(rd());
    }
    template<typename T>
    T random(T min, T max) {
       std::uniform_int_distribution<std::int64_t> dist(min, max);
       return dist(mt);

    }
};
_rand mtrd;
void generate_password(int64_t size) {
  
    std::string sMask = "qwertyuiopasdfghjklzxcvbnm1234567890";
    std::string sOutPassword = "";

    // gen
    
    for (int64_t fillChars = 0; fillChars < size; fillChars++) {
        sOutPassword += sMask[mtrd.random<int>(0,sMask.size())];
        size_out.fetch_add(sOutPassword.size(), std::memory_order_relaxed);
    }
   
   
}

void bench(int64_t size) {
    auto in = std::chrono::high_resolution_clock::now();
    std::vector<std::jthread> jthreads;
    jthreads.reserve(std::jthread::hardware_concurrency());
    for (int i = 0; i < std::jthread::hardware_concurrency(); i++) {
        jthreads.emplace_back([=] {
            generate_password(size / std::jthread::hardware_concurrency());
            });

        if (jthreads[i].joinable()) {
            thread_id = jthreads[i].get_id()._Get_underlying_id();
            std::print("thread ({}) :: ({}) size: ({})\n", (std::to_string(call).size() < 2 ? std::format("0{}", call) : std::to_string(call)), thread_id, size_out.load());
            call++;

        }
        if (call >= std::jthread::hardware_concurrency()) {
            auto out = std::chrono::high_resolution_clock::now();
            std::cout << "----------------------\n out time : " << std::chrono::duration_cast<std::chrono::nanoseconds>(out - in).count() << " ns\n";
        }
    }
}
int main(int argc, char** argv) {
   
    int64_t i64MaxSize = (argc < 2 ? 10000000 : std::stoll(argv[1]));
    if (argc < 2) {
        std::print("argv[1] empty!\nset default size_buffer={}\n", i64MaxSize);
    }
    else {
        std::print("size_buffer={}\n", i64MaxSize);
    }
    uint32_t u32MaxThreads = std::jthread::hardware_concurrency();
    std::print("--------------------------------------\n");
    std::print("                                      \n");
    std::print("        CPU Bench by HCPP             \n");
    std::print("    max_cpu:{}         size:{}        \n", u32MaxThreads,i64MaxSize);
    std::print("--------------------------------------\n");
    bench(i64MaxSize);
    
    
}

struct vec_api {
    template<typename _Vec, typename _Same>
    void remover(_Vec& d, _Same obj) {
        d.erase(std::remove(d.begin(), d.end(), obj), d.end());
    }
};

vec_api vapi;
std::vector<uint8_t> _codes = { 0x10,0xFF,0xA0 };
vapi.remover(_codes, 0x10);

struct vec_api {
    template<typename _Vec, typename _Same>
    void remover(_Vec& d, _Same obj) {
        d.erase(std::remove(d.begin(), d.end(), obj), d.end());
    }
    template<typename _Vec>
    void resize(_Vec& d, uint64_t size) {
        d.resize(size);
    }
    template<typename _Vec>
    void reserve(_Vec& d, uint64_t size) {
        d.reserve(size);
    }
    template<typename _Vec, typename _Same>
    void addpb(_Vec& d,_Same obj) {
        d.push_back(obj);
    }
    template<typename _Vec, typename _Same>
    void addeb(_Vec& d, _Same obj) {
        d.emplace_back(obj);
    }
    template<typename _Vec, typename... _Args>
    void addeb(_Vec& d, _Args&&... args) {
        d.emplace_back(std::forward<_Args>(args)...);
    }
    template<typename _Vec, typename... _Args>
    void addpb(_Vec& d, _Args&&... args) {
        d.emplace_back(std::forward<_Args>(args)...);
    }
    template<typename _Vec>
    bool isEmpty(_Vec& d) {
       return d.empty() ? true : false;
    }
};

struct threads {
    std::vector <std::jthread> _threads;
    vec_api vec;
    template<typename..._Args>
    void loadToJThread(int32_t threads_count,_Args&&...args) {
        vec.reserve(_threads, threads_count);
        for (int n = 0; n < threads_count; n++) {
            vec.addeb(_threads, std::forward<_Args>(args)...);
        }
    }
};