Cuda性能测试工具

//utils.h
#pragma once
#include <chrono>
#include <iostream>
#include <cuda_runtime.h>

using namespace std::chrono;

#define CUDA_CHECK(call)                                                  \
    do {                                                                  \
        cudaError_t err = call;                                           \
        if (err != cudaSuccess) {                                         \
            fprintf(stderr, "CUDA error %s:%d: %s\n", __FILE__, __LINE__, \
                    cudaGetErrorString(err));                             \
            exit(1);                                                      \
        }                                                                 \
    } while (0)

// for cpu
class TimeCost {
public:
    TimeCost() : _start_time(std::chrono::high_resolution_clock::now()) {}

    void begin_time_point() {
        _start_time = std::chrono::high_resolution_clock::now();
    }

    double get_time_cost(bool is_reset = false) {
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
            end_time - _start_time);
        double cost = static_cast<double>(duration.count()) / 1e3;

        if (is_reset) {
            _start_time = std::chrono::high_resolution_clock::now();
        }

        return cost;
    }

private:
    std::chrono::high_resolution_clock::time_point _start_time;
};

// for gpu
class TimeCostCuda {
public:
    TimeCostCuda() {
        CUDA_CHECK(cudaEventCreate(&_start));
        CUDA_CHECK(cudaEventCreate(&_stop));
        CUDA_CHECK(cudaEventRecord(_start, 0));
    }

    ~TimeCostCuda() {
        CUDA_CHECK(cudaEventDestroy(_start));
        CUDA_CHECK(cudaEventDestroy(_stop));
    }

    double get_time_cost(bool is_reset = false) {
        CUDA_CHECK(cudaEventRecord(_stop, 0));
        CUDA_CHECK(cudaEventSynchronize(_stop));
        float elapsedTime;
        CUDA_CHECK(cudaEventElapsedTime(&elapsedTime, _start, _stop));


        if (is_reset) {
            CUDA_CHECK(cudaEventRecord(_start, 0));
        }
        return elapsedTime;
    }


private:
    cudaEvent_t _start, _stop;
};