#ifdef __cplusplus
extern "C" {
#endif
int cuda_debug_sync = 0;
int gpu_index = 0;
#ifdef __cplusplus
}
#endif // __cplusplus

#ifdef GPU

#include "dark_cuda.h"
#include "utils.h"
#include "blas.h"
#include "assert.h"
#include <stdlib.h>
#include <time.h>
#include <cuda.h>
#include <stdio.h>

#pragma comment(lib, "cuda.lib")


#ifdef CUDNN
#ifndef USE_CMAKE_LIBS
#pragma comment(lib, "cudnn.lib")
#endif  // USE_CMAKE_LIBS
#endif  // CUDNN

#if defined(CUDNN_HALF) && !defined(CUDNN)
#error "If you set CUDNN_HALF=1 then you must set CUDNN=1"
#endif


void cuda_set_device(int n)
{
    gpu_index = n;
    cudaError_t status = cudaSetDevice(n);
    if(status != cudaSuccess) CHECK_CUDA(status);
}

int cuda_get_device()
{
    int n = 0;
    cudaError_t status = cudaGetDevice(&n);
    CHECK_CUDA(status);
    return n;
}

void *cuda_get_context()
{
    CUcontext pctx;
    CUresult status = cuCtxGetCurrent(&pctx);
    if(status != CUDA_SUCCESS) fprintf(stderr, " Error: cuCtxGetCurrent() is failed \n");
    return (void *)pctx;
}

void check_error(cudaError_t status)
{
    cudaError_t status2 = cudaGetLastError();
    if (status != cudaSuccess)
    {
        const char *s = cudaGetErrorString(status);
        char buffer[256];
        printf("\n CUDA Error: %s\n", s);
        snprintf(buffer, 256, "CUDA Error: %s", s);
#ifdef WIN32
        getchar();
#endif
        error(buffer);
    }
    if (status2 != cudaSuccess)
    {
        const char *s = cudaGetErrorString(status2);
        char buffer[256];
        printf("\n CUDA Error Prev: %s\n", s);
        snprintf(buffer, 256, "CUDA Error Prev: %s", s);
#ifdef WIN32
        getchar();
#endif
        error(buffer);
    }
}

void check_error_extended(cudaError_t status, const char *file, int line, const char *date_time)
{
    if (status != cudaSuccess) {
        printf("CUDA status Error: file: %s() : line: %d : build time: %s \n", file, line, date_time);
        check_error(status);
    }
#if defined(DEBUG) || defined(CUDA_DEBUG)
    cuda_debug_sync = 1;
#endif
    if (cuda_debug_sync) {
        status = cudaDeviceSynchronize();
        if (status != cudaSuccess)
            printf("CUDA status = cudaDeviceSynchronize() Error: file: %s() : line: %d : build time: %s \n", file, line, date_time);
    }
    check_error(status);
}

dim3 cuda_gridsize(size_t n){
    size_t k = (n-1) / BLOCK + 1;
    size_t x = k;
    size_t y = 1;
    if(x > 65535){
        x = ceil(sqrt(k));
        y = (n-1)/(x*BLOCK) + 1;
    }
    //dim3 d = { (unsigned int)x, (unsigned int)y, 1 };
    dim3 d;
    d.x = x;
    d.y = y;
    d.z = 1;
    //printf("%ld %ld %ld %ld\n", n, x, y, x*y*BLOCK);
    return d;
}

static cudaStream_t streamsArray[16];    // cudaStreamSynchronize( get_cuda_stream() );
static int streamInit[16] = { 0 };

cudaStream_t get_cuda_stream() {
    int i = cuda_get_device();
    if (!streamInit[i]) {
        printf("Create CUDA-stream - %d \n", i);
#ifdef CUDNN
        cudaError_t status = cudaStreamCreateWithFlags(&streamsArray[i], cudaStreamNonBlocking);
#else
        cudaError_t status = cudaStreamCreate(&streamsArray[i]);
#endif
        if (status != cudaSuccess) {
            printf(" cudaStreamCreate error: %d \n", status);
            const char *s = cudaGetErrorString(status);
            printf("CUDA Error: %s\n", s);
            status = cudaStreamCreateWithFlags(&streamsArray[i], cudaStreamNonBlocking);    // cudaStreamDefault
            CHECK_CUDA(status);
        }
        streamInit[i] = 1;
    }
    return streamsArray[i];
}

/*
static cudaStream_t streamsArray2[16];    // cudaStreamSynchronize( get_cuda_memcpy_stream() );
static int streamInit2[16] = { 0 };

cudaStream_t get_cuda_memcpy_stream() {
    int i = cuda_get_device();
    if (!streamInit2[i]) {
        printf(" Create COPY stream %d \n", i);
        //cudaError_t status = cudaStreamCreate(&streamsArray2[i], cudaStreamNonBlocking);
        cudaError_t status = cudaStreamCreateWithFlags(&streamsArray2[i], cudaStreamNonBlocking);
        if (status != cudaSuccess) {
            printf(" cudaStreamCreate-Memcpy error: %d \n", status);
            const char *s = cudaGetErrorString(status);
            printf("CUDA Error: %s\n", s);
            status = cudaStreamCreateWithFlags(&streamsArray2[i], cudaStreamNonBlocking);
            CHECK_CUDA(status);
        }
        streamInit2[i] = 1;
    }
    return streamsArray2[i];
}
*/

#ifdef CUDNN
static int cudnnInit[16] = { 0 };
static cudnnHandle_t cudnnHandle[16];

cudnnHandle_t cudnn_handle()
{
    int i = cuda_get_device();
    if(!cudnnInit[i]) {
        cudnnCreate(&cudnnHandle[i]);
        cudnnInit[i] = 1;
        cudnnStatus_t status = cudnnSetStream(cudnnHandle[i], get_cuda_stream());
        CHECK_CUDNN(status);
        printf(" Create cudnn-handle %d \n", i);
    }
    return cudnnHandle[i];
}


void cudnn_check_error(cudnnStatus_t status)
{
#if defined(DEBUG) || defined(CUDA_DEBUG)
    cudaDeviceSynchronize();
#endif
    if (cuda_debug_sync) {
        cudaDeviceSynchronize();
    }
    cudnnStatus_t status2 = CUDNN_STATUS_SUCCESS;
#ifdef CUDNN_ERRQUERY_RAWCODE
    cudnnStatus_t status_tmp = cudnnQueryRuntimeError(cudnn_handle(), &status2, CUDNN_ERRQUERY_RAWCODE, NULL);
#endif
    if (status != CUDNN_STATUS_SUCCESS)
    {
        const char *s = cudnnGetErrorString(status);
        char buffer[256];
        printf("\n cuDNN Error: %s\n", s);
        snprintf(buffer, 256, "cuDNN Error: %s", s);
#ifdef WIN32
        getchar();
#endif
        error(buffer);
    }
    if (status2 != CUDNN_STATUS_SUCCESS)
    {
        const char *s = cudnnGetErrorString(status2);
        char buffer[256];
        printf("\n cuDNN Error Prev: %s\n", s);
        snprintf(buffer, 256, "cuDNN Error Prev: %s", s);
#ifdef WIN32
        getchar();
#endif
        error(buffer);
    }
}

void cudnn_check_error_extended(cudnnStatus_t status, const char *file, int line, const char *date_time)
{
    if (status != CUDNN_STATUS_SUCCESS) {
        printf("\n cuDNN status Error in: file: %s() : line: %d : build time: %s \n", file, line, date_time);
        cudnn_check_error(status);
    }
#if defined(DEBUG) || defined(CUDA_DEBUG)
    cuda_debug_sync = 1;
#endif
    if (cuda_debug_sync) {
        cudaError_t status = cudaDeviceSynchronize();
        if (status != CUDNN_STATUS_SUCCESS)
            printf("\n cudaError_t status = cudaDeviceSynchronize() Error in: file: %s() : line: %d : build time: %s \n", file, line, date_time);
    }
    cudnn_check_error(status);
}

static cudnnHandle_t switchCudnnHandle[16];
static int switchCudnnInit[16];
#endif


void cublas_check_error(cublasStatus_t status)
{
#if defined(DEBUG) || defined(CUDA_DEBUG)
    cudaDeviceSynchronize();
#endif
    if (cuda_debug_sync) {
        cudaDeviceSynchronize();
    }
    if (status != CUBLAS_STATUS_SUCCESS) {
        printf("cuBLAS Error\n");
    }
}

void cublas_check_error_extended(cublasStatus_t status, const char *file, int line, const char *date_time)
{
    if (status != CUBLAS_STATUS_SUCCESS) {
      printf("\n cuBLAS status Error in: file: %s() : line: %d : build time: %s \n", file, line, date_time);
    }
#if defined(DEBUG) || defined(CUDA_DEBUG)
    cuda_debug_sync = 1;
#endif
    if (cuda_debug_sync) {
        cudaError_t status = cudaDeviceSynchronize();
      if (status != CUDA_SUCCESS)
          printf("\n cudaError_t status = cudaDeviceSynchronize() Error in: file: %s() : line: %d : build time: %s \n", file, line, date_time);
    }
    cublas_check_error(status);
}

static int blasInit[16] = { 0 };
static cublasHandle_t blasHandle[16];

cublasHandle_t blas_handle()
{
    int i = cuda_get_device();
    if (!blasInit[i]) {
        CHECK_CUBLAS(cublasCreate(&blasHandle[i]));
        cublasStatus_t status = cublasSetStream(blasHandle[i], get_cuda_stream());
        CHECK_CUBLAS(status);
        blasInit[i] = 1;
    }
    return blasHandle[i];
}


static int switchBlasInit[16] = { 0 };
static cublasHandle_t switchBlasHandle[16];

static cudaStream_t switchStreamsArray[16];
static int switchStreamInit[16] = { 0 };

cudaStream_t switch_stream(int i) {
    int dev_id = cuda_get_device();

    //printf(" switch_stream = %d \n", i);
    if (!switchStreamInit[i]) {
        CHECK_CUDA(cudaStreamCreateWithFlags(&switchStreamsArray[i], cudaStreamNonBlocking));
        switchStreamInit[i] = 1;
        printf(" Create stream %d \n", i);
    }

    //cudaStreamQuery(streamsArray[0]);   // Flush previous stream queue
    streamsArray[dev_id] = switchStreamsArray[i];
    streamInit[dev_id] = switchStreamInit[i];

    //printf("switch_stream %d - get_cuda_stream() = %d \n", i, get_cuda_stream());

    /*
    if (!switchBlasInit[i]) {
        CHECK_CUDA( cublasCreate(&switchBlasHandle[i]) );
        switchBlasInit[i] = 1;
        CHECK_CUDA( cublasSetStream(switchBlasHandle[i], switchStreamsArray[i]) );
        printf(" Create blas-handle %d \n", i);
    }
    blasHandle[dev_id] = switchBlasHandle[i];
    blasInit[dev_id] = switchBlasInit[i];
    */

#ifdef CUDNN
    if (!switchCudnnInit[i]) {
        CHECK_CUDNN( cudnnCreate(&switchCudnnHandle[i]) );
        switchCudnnInit[i] = 1;
        CHECK_CUDNN(cudnnSetStream(switchCudnnHandle[i], switchStreamsArray[i]));
        printf(" Create cudnn-handle %d \n", i);
    }
    cudnnHandle[dev_id] = switchCudnnHandle[i];
    cudnnInit[dev_id] = switchCudnnInit[i];
#endif

    return switchStreamsArray[i];
}

#ifndef cudaEventWaitDefault
#define cudaEventWaitDefault 0x00
#endif // cudaEventWaitDefault

static const int max_events = 1024;
static cudaEvent_t switchEventsArray[1024];
static volatile int event_counter = 0;

void wait_stream(int i) {
    int dev_id = cuda_get_device();
    if (event_counter >= max_events) error("CUDA max_events exceeded \n");

    CHECK_CUDA( cudaEventCreateWithFlags(&switchEventsArray[event_counter], cudaEventDisableTiming) );
    //printf(" create event = %d (wait for stream = %d) \n", event_counter, i);

    //CHECK_CUDA(cudaEventRecordWithFlags(switchEventsArray[i], switchStreamsArray[i], cudaEventRecordExternal) );
    CHECK_CUDA( cudaEventRecord(switchEventsArray[event_counter], switchStreamsArray[i]) );
    CHECK_CUDA( cudaStreamWaitEvent(streamsArray[dev_id], switchEventsArray[event_counter], cudaEventWaitDefault) );
    //cudaStreamWaitEvent(streamsArray[dev_id], switchEventsArray[i], cudaEventWaitExternal);
    event_counter++;
}

void reset_wait_stream_events() {
    int i;
    for (i = 0; i < event_counter; ++i) {
        CHECK_CUDA(cudaEventDestroy(switchEventsArray[i]));
    }
    event_counter = 0;
}


static float **pinned_ptr = NULL;
static size_t pinned_num_of_blocks = 0;
static size_t pinned_index = 0;
static size_t pinned_block_id = 0;
static const size_t pinned_block_size = (size_t)1024 * 1024 * 1024 * 1;   // 1 GB block size
static pthread_mutex_t mutex_pinned = PTHREAD_MUTEX_INITIALIZER;

// free CPU-pinned memory
void free_pinned_memory()
{
    if (pinned_ptr) {
        int k;
        for (k = 0; k < pinned_num_of_blocks; ++k) {
            cuda_free_host(pinned_ptr[k]);
        }
        free(pinned_ptr);
        pinned_ptr = NULL;
    }
}

// custom CPU-pinned memory allocation
void pre_allocate_pinned_memory(const size_t size)
{
    const size_t num_of_blocks = size / pinned_block_size + ((size % pinned_block_size) ? 1 : 0);
    printf("pre_allocate... pinned_ptr = %p \n", pinned_ptr);

    pthread_mutex_lock(&mutex_pinned);
    if (!pinned_ptr) {
        pinned_ptr = (float **)calloc(num_of_blocks, sizeof(float *));
        if(!pinned_ptr) error("calloc failed in pre_allocate() \n");

        printf("pre_allocate: size = %Iu MB, num_of_blocks = %Iu, block_size = %Iu MB \n",
            size / (1024*1024), num_of_blocks, pinned_block_size / (1024 * 1024));

        int k;
        for (k = 0; k < num_of_blocks; ++k) {
            cudaError_t status = cudaHostAlloc((void **)&pinned_ptr[k], pinned_block_size, cudaHostRegisterMapped);
            if (status != cudaSuccess) fprintf(stderr, " Can't pre-allocate CUDA-pinned buffer on CPU-RAM \n");
            CHECK_CUDA(status);
            if (!pinned_ptr[k]) error("cudaHostAlloc failed\n");
            else {
                printf(" Allocated %d pinned block \n", pinned_block_size);
            }
        }
        pinned_num_of_blocks = num_of_blocks;
    }
    pthread_mutex_unlock(&mutex_pinned);
}

// simple - get pre-allocated pinned memory
float *cuda_make_array_pinned_preallocated(float *x, size_t n)
{
    pthread_mutex_lock(&mutex_pinned);
    float *x_cpu = NULL;
    const size_t memory_step = 512;// 4096;
    const size_t size = sizeof(float)*n;
    const size_t allocation_size = ((size / memory_step) + 1) * memory_step;

    if (pinned_ptr && pinned_block_id < pinned_num_of_blocks && (allocation_size < pinned_block_size/2))
    {
        if ((allocation_size + pinned_index) > pinned_block_size) {
            const float filled = (float)100 * pinned_index / pinned_block_size;
            printf("\n Pinned block_id = %d, filled = %f %% \n", pinned_block_id, filled);
            pinned_block_id++;
            pinned_index = 0;
        }
        if ((allocation_size + pinned_index) < pinned_block_size && pinned_block_id < pinned_num_of_blocks) {
            x_cpu = (float *)((char *)pinned_ptr[pinned_block_id] + pinned_index);
            pinned_index += allocation_size;
        }
        else {
            //printf("Pre-allocated pinned memory is over! \n");
        }
    }

    if(!x_cpu) {
        if (allocation_size > pinned_block_size / 2) {
            printf("Try to allocate new pinned memory, size = %d MB \n", size / (1024 * 1024));
            cudaError_t status = cudaHostAlloc((void **)&x_cpu, size, cudaHostRegisterMapped);
            if (status != cudaSuccess) fprintf(stderr, " Can't allocate CUDA-pinned memory on CPU-RAM (pre-allocated memory is over too) \n");
            CHECK_CUDA(status);
        }
        else {
            printf("Try to allocate new pinned BLOCK, size = %d MB \n", size / (1024 * 1024));
            pinned_num_of_blocks++;
            pinned_block_id = pinned_num_of_blocks - 1;
            pinned_index = 0;
            pinned_ptr = (float **)realloc(pinned_ptr, pinned_num_of_blocks * sizeof(float *));
            cudaError_t status = cudaHostAlloc((void **)&pinned_ptr[pinned_block_id], pinned_block_size, cudaHostRegisterMapped);
            if (status != cudaSuccess) fprintf(stderr, " Can't pre-allocate CUDA-pinned buffer on CPU-RAM \n");
            CHECK_CUDA(status);
            x_cpu = pinned_ptr[pinned_block_id];
        }
    }

    if (x) {
        cudaError_t status = cudaMemcpyAsync(x_cpu, x, size, cudaMemcpyDefault, get_cuda_stream());
        CHECK_CUDA(status);
    }

    pthread_mutex_unlock(&mutex_pinned);
    return x_cpu;
}

float *cuda_make_array_pinned(float *x, size_t n)
{
    float *x_gpu;
    size_t size = sizeof(float)*n;
    //cudaError_t status = cudaMalloc((void **)&x_gpu, size);
    cudaError_t status = cudaHostAlloc((void **)&x_gpu, size, cudaHostRegisterMapped);
    if (status != cudaSuccess) fprintf(stderr, " Can't allocate CUDA-pinned memory on CPU-RAM \n");
    CHECK_CUDA(status);
    if (x) {
        status = cudaMemcpyAsync(x_gpu, x, size, cudaMemcpyDefault, get_cuda_stream());
        CHECK_CUDA(status);
    }
    if (!x_gpu) error("cudaHostAlloc failed\n");
    return x_gpu;
}

float *cuda_make_array(float *x, size_t n)
{
    float *x_gpu;
    size_t size = sizeof(float)*n;
    cudaError_t status = cudaMalloc((void **)&x_gpu, size);
    //cudaError_t status = cudaMallocManaged((void **)&x_gpu, size, cudaMemAttachGlobal);
    //status = cudaMemAdvise(x_gpu, size, cudaMemAdviseSetPreferredLocation, cudaCpuDeviceId);
    if (status != cudaSuccess) fprintf(stderr, " Try to set subdivisions=64 in your cfg-file. \n");
    CHECK_CUDA(status);
    if(x){
        //status = cudaMemcpy(x_gpu, x, size, cudaMemcpyHostToDevice);
        status = cudaMemcpyAsync(x_gpu, x, size, cudaMemcpyDefault, get_cuda_stream());
        CHECK_CUDA(status);
    }
    if(!x_gpu) error("Cuda malloc failed\n");
    return x_gpu;
}

void **cuda_make_array_pointers(void **x, size_t n)
{
    void **x_gpu;
    size_t size = sizeof(void*) * n;
    cudaError_t status = cudaMalloc((void **)&x_gpu, size);
    if (status != cudaSuccess) fprintf(stderr, " Try to set subdivisions=64 in your cfg-file. \n");
    CHECK_CUDA(status);
    if (x) {
        status = cudaMemcpyAsync(x_gpu, x, size, cudaMemcpyDefault, get_cuda_stream());
        CHECK_CUDA(status);
    }
    if (!x_gpu) error("Cuda malloc failed\n");
    return x_gpu;
}

void cuda_random(float *x_gpu, size_t n)
{
    static curandGenerator_t gen[16];
    static int init[16] = {0};
    int i = cuda_get_device();
    if(!init[i]){
        curandCreateGenerator(&gen[i], CURAND_RNG_PSEUDO_DEFAULT);
        curandSetPseudoRandomGeneratorSeed(gen[i], time(0));
        init[i] = 1;
    }
    curandGenerateUniform(gen[i], x_gpu, n);
    CHECK_CUDA(cudaPeekAtLastError());
}

float cuda_compare(float *x_gpu, float *x, size_t n, char *s)
{
    float* tmp = (float*)xcalloc(n, sizeof(float));
    cuda_pull_array(x_gpu, tmp, n);
    //int i;
    //for(i = 0; i < n; ++i) printf("%f %f\n", tmp[i], x[i]);
    axpy_cpu(n, -1, x, 1, tmp, 1);
    float err = dot_cpu(n, tmp, 1, tmp, 1);
    printf("Error %s: %f\n", s, sqrt(err/n));
    free(tmp);
    return err;
}

int *cuda_make_int_array(size_t n)
{
    int *x_gpu;
    size_t size = sizeof(int)*n;
    cudaError_t status = cudaMalloc((void **)&x_gpu, size);
    if(status != cudaSuccess) fprintf(stderr, " Try to set subdivisions=64 in your cfg-file. \n");
    CHECK_CUDA(status);
    return x_gpu;
}

int *cuda_make_int_array_new_api(int *x, size_t n)
{
	int *x_gpu;
	size_t size = sizeof(int)*n;
	cudaError_t status = cudaMalloc((void **)&x_gpu, size);
    CHECK_CUDA(status);
	if (x) {
		//status = cudaMemcpy(x_gpu, x, size, cudaMemcpyHostToDevice);
        cudaError_t status = cudaMemcpyAsync(x_gpu, x, size, cudaMemcpyHostToDevice, get_cuda_stream());
        CHECK_CUDA(status);
	}
	if (!x_gpu) error("Cuda malloc failed\n");
	return x_gpu;
}

void cuda_free(float *x_gpu)
{
    //cudaStreamSynchronize(get_cuda_stream());
    cudaError_t status = cudaFree(x_gpu);
    CHECK_CUDA(status);
}

void cuda_free_host(float *x_cpu)
{
    //cudaStreamSynchronize(get_cuda_stream());
    cudaError_t status = cudaFreeHost(x_cpu);
    CHECK_CUDA(status);
}

void cuda_push_array(float *x_gpu, float *x, size_t n)
{
    size_t size = sizeof(float)*n;
    //cudaError_t status = cudaMemcpy(x_gpu, x, size, cudaMemcpyHostToDevice);
    cudaError_t status = cudaMemcpyAsync(x_gpu, x, size, cudaMemcpyHostToDevice, get_cuda_stream());
    CHECK_CUDA(status);
}

void cuda_pull_array(float *x_gpu, float *x, size_t n)
{
    size_t size = sizeof(float)*n;
    //cudaError_t status = cudaMemcpy(x, x_gpu, size, cudaMemcpyDeviceToHost);
    //printf("cuda_pull_array - get_cuda_stream() = %d \n", get_cuda_stream());
    cudaError_t status = cudaMemcpyAsync(x, x_gpu, size, cudaMemcpyDeviceToHost, get_cuda_stream());
    CHECK_CUDA(status);
    cudaStreamSynchronize(get_cuda_stream());
}

void cuda_pull_array_async(float *x_gpu, float *x, size_t n)
{
    size_t size = sizeof(float)*n;
    cudaError_t status = cudaMemcpyAsync(x, x_gpu, size, cudaMemcpyDefault, get_cuda_stream());
    check_error(status);
    //cudaStreamSynchronize(get_cuda_stream());
}

int get_number_of_blocks(int array_size, int block_size)
{
    return array_size / block_size + ((array_size % block_size > 0) ? 1 : 0);
}

int get_gpu_compute_capability(int i, char *device_name)
{
    typedef struct cudaDeviceProp cudaDeviceProp;
    cudaDeviceProp prop;
    cudaError_t status = cudaGetDeviceProperties(&prop, i);
    CHECK_CUDA(status);
    if (device_name) strcpy(device_name, prop.name);
    int cc = prop.major * 100 + prop.minor * 10;    // __CUDA_ARCH__ format
    return cc;
}

void show_cuda_cudnn_info()
{
    int cuda_version = 0, cuda_driver_version = 0, device_count = 0;
    CHECK_CUDA(cudaRuntimeGetVersion(&cuda_version));
    CHECK_CUDA(cudaDriverGetVersion(&cuda_driver_version));
    fprintf(stderr, " CUDA-version: %d (%d)", cuda_version, cuda_driver_version);
    if(cuda_version > cuda_driver_version) fprintf(stderr, "\n Warning: CUDA-version is higher than Driver-version! \n");
#ifdef CUDNN
    fprintf(stderr, ", cuDNN: %d.%d.%d", CUDNN_MAJOR, CUDNN_MINOR, CUDNN_PATCHLEVEL);
#endif  // CUDNN
#ifdef CUDNN_HALF
    fprintf(stderr, ", CUDNN_HALF=1");
#endif  // CUDNN_HALF
    CHECK_CUDA(cudaGetDeviceCount(&device_count));
    fprintf(stderr, ", GPU count: %d ", device_count);
    fprintf(stderr, " \n");
}

#else // GPU
#include "darknet.h"
void cuda_set_device(int n) {}
#endif // GPU