CUDA: упаковка выделения памяти устройства в C++

Сейчас я начинаю использовать CUDA и должен признать, что немного разочарован C API. Я понимаю причины выбора C, но если бы язык был основан на C++, некоторые аспекты были бы намного проще, например. выделение памяти устройства (через cudaMalloc).

Я планировал сделать это сам, используя перегруженный operator new с размещением new и RAII (две альтернативы). Мне интересно, есть ли какие-то оговорки, которых я пока не заметил. Код кажется для работы, но мне все еще интересно узнать о потенциальных утечках памяти.

Использование кода RAII будет следующим:

CudaArray<float> device_data(SIZE);
// Use `device_data` as if it were a raw pointer.

Возможно, в этом контексте класс является излишним (тем более, что вам все равно придется использовать cudaMemcpy, класс, инкапсулирующий только RAII), поэтому другим подходом будет размещение new:

float* device_data = new (cudaDevice) float[SIZE];
// Use `device_data` …
operator delete [](device_data, cudaDevice);

Здесь cudaDevice просто действует как тег, вызывающий перегрузку. Однако, поскольку при обычном размещении new это будет указывать на размещение, я считаю синтаксис странно согласованным и, возможно, даже более предпочтительным, чем использование класса.

Буду признателен за критику любого рода. Может быть, кто-нибудь знает, планируется ли что-то в этом направлении в следующей версии CUDA (которая, как я слышал, улучшит ее поддержку C++, что бы они под этим ни подразумевали).

Итак, мой вопрос состоит из трех частей:

1. Является ли моя перегрузка new семантически правильной? Утечка памяти?
2. Есть ли у кого-нибудь информация о будущих разработках CUDA, которые пойдут в этом общем направлении (давайте посмотрим правде в глаза: интерфейсы C в C++ s * ck)?
3. Как я могу продолжить это последовательно (есть другие API-интерфейсы, которые следует учитывать, например, есть не только память устройства, но также хранилище постоянной памяти и память текстуры)?

// Singleton tag for CUDA device memory placement.
struct CudaDevice {
    static CudaDevice const& get() { return instance; }
private:
    static CudaDevice const instance;
    CudaDevice() { }
    CudaDevice(CudaDevice const&);
    CudaDevice& operator =(CudaDevice const&);
} const& cudaDevice = CudaDevice::get();

CudaDevice const CudaDevice::instance;

inline void* operator new [](std::size_t nbytes, CudaDevice const&) {
    void* ret;
    cudaMalloc(&ret, nbytes);
    return ret;
}

inline void operator delete [](void* p, CudaDevice const&) throw() {
    cudaFree(p);
}

template <typename T>
class CudaArray {
public:
    explicit
    CudaArray(std::size_t size) : size(size), data(new (cudaDevice) T[size]) { }

    operator T* () { return data; }

    ~CudaArray() {
        operator delete [](data, cudaDevice);
    }

private:
    std::size_t const size;
    T* const data;

    CudaArray(CudaArray const&);
    CudaArray& operator =(CudaArray const&);
};

О используемом здесь синглтоне: Да, я в курсе его недостатков. Однако в данном контексте это не актуально. Все, что мне здесь было нужно, это небольшой тег, который нельзя было скопировать. Все остальное (например, соображения многопоточности, время инициализации) не применяются.