Как собрать статическую библиотеку с CUDA в MS VC 2015?

[New man]

Я хочу создать статическую библиотеку с кодом CUDA.

Собственно, там такой код:
MarchingCubesLib.h

#include <cstdint>


struct FOutFloat3
{
    float x;
    float y;
    float z;
};

struct FOutVertex
{
    FOutFloat3 position;
    FOutFloat3 normal;
};

struct FOutTriangle
{
    FOutVertex vertices[3];
};

#pragma pack(push, 1)
struct FOutMeshPart
{
    uint32_t count = 0;
    FOutTriangle* triangles = nullptr;
    FOutMeshPart() noexcept {}
    ~FOutMeshPart();
};
#pragma pack(pop)

#pragma pack(push, 1)
struct FMarchingCubesParams
{
    uint32_t rows;
    uint32_t columns;
    uint32_t slices;
    uint16_t cube_size;
    // horizontal(x), vertical(y), depth(z)
    float voxel_size_mm[3];
    float iso_level;
};
#pragma pack(pop)

enum MarchingCubesResult {
    Success, DeviceError, Error
};

MarchingCubesResult MarchingCubes(float* data, FOutMeshPart& polygons, const FMarchingCubesParams params);

И реализация в MarchingCubesLib.cu

MarchingCubesResult MarchingCubes(float * data, FOutMeshPart& polygons, const FMarchingCubesParams params)
{
    // Thread number set up
    // TODO: exchange number of blocks and threads
    const int threads = params.slices / params.cube_size;
    const dim3 blocks(params.rows / params.cube_size, params.columns / params.cube_size, 1);
    const int grid_size = blocks.x * blocks.y * threads;

    cudaError_t cudaResult = cudaSetDevice(0);
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::DeviceError;

    CudaSmartPtr<uint8_t> poly_nums;
    CudaSmartPtr<FMarchingCubesParams> paramsOnDevice;
    CudaSmartPtr<float> dataOnDevice;

    cudaResult = cudaMallocManaged(&paramsOnDevice.ptr, sizeof(params));
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::Error;
    cudaResult = cudaMemcpy(paramsOnDevice.ptr, &params, sizeof(params), cudaMemcpyHostToDevice);
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::Error;

    cudaResult = cudaMallocManaged(&poly_nums.ptr, grid_size * sizeof(uint8_t));
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::Error;
    cudaResult = cudaMalloc(&dataOnDevice.ptr, params.rows*params.columns*params.slices * sizeof(float));
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::Error;
    cudaResult = cudaMemcpy(dataOnDevice.ptr, data, params.rows*params.columns*params.slices * sizeof(float), cudaMemcpyHostToDevice);
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::Error;

    count_polygons <<<blocks, threads >>> (dataOnDevice.ptr, paramsOnDevice.ptr, poly_nums.ptr);
    cudaResult = cudaGetLastError();
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::Error;
    cudaDeviceSynchronize();

    CudaSmartPtr<int> start_indexes_for_kernels;
    cudaResult = cudaMallocManaged(&start_indexes_for_kernels.ptr, grid_size * sizeof(int));
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::Error;
    size_t total_triangle_num = 0;
    for (size_t i = 0; i < grid_size; ++i)
    {
        start_indexes_for_kernels.ptr[i] = total_triangle_num;
        total_triangle_num += poly_nums.ptr[i];
    }
    poly_nums.free();

    CudaSmartPtr<FOutTriangle> triangles;
    cudaResult = cudaMalloc(&triangles.ptr, total_triangle_num * sizeof(FOutTriangle));
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::Error;

    polygonyse <<<blocks, threads>>> (dataOnDevice.ptr, paramsOnDevice.ptr, start_indexes_for_kernels.ptr, triangles.ptr);
    cudaResult = cudaGetLastError();
    if (cudaResult != cudaError_t::cudaSuccess)
        return MarchingCubesResult::Error;
    cudaDeviceSynchronize();

    // Copy data to result
    delete[] polygons.triangles;
    polygons.triangles = nullptr;
    polygons.count = total_triangle_num;
    polygons.triangles = new FOutTriangle[total_triangle_num];
    cudaMemcpy(polygons.triangles, triangles.ptr, total_triangle_num * sizeof(FOutTriangle), cudaMemcpyDeviceToHost);

    return MarchingCubesResult::Success;
}

В настройках указал ConfigurationType: Static Library (lib).

В итоге он собирает этот lib файл, но при попытке подключить библиотеку к другому проекту, в нём появляются ошибки вида

unresolved external symbol cudaDeviceSynchronize
Project1 D:\Programs\tmp\Project1\MarchingCu besLib.lib(MarchingCubesLib.cu.obj) 1

То есть, в библиотеке нет реализаций методов CUDA.
Как сделать так, чтобы получилась нормальная библиотека?

[waleri]

Явно cudaDeviceSynchronize лежит в другой библиотеке.

[p51x]

Задам немного странный вопрос: а вы саму CUDA-либу cudart_static.lib то линкуете?