Wrap Vulkan's VkInstance into unique_ptr without additional dynamic allocations

Question

I'm trying to wrap VkInstance (opaque pointer) into unique_ptr but seems like I can't.

...
    VkInstance instance;
    if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
        throw std::runtime_error("failed to create vulkan instance");
    }

    auto del = [](VkInstance* p) {
        DBG("release vk instance");
        vkDestroyInstance(*p, nullptr);
    };
    auto ptr = std::unique_ptr<VkInstance, decltype(del)>(instance, del);
...

The error:

no instance of constructor "std::unique_ptr<_Tp, _Dp>::unique_ptr [with _Tp=VkInstance, _Dp=lambda [](VkInstance *p)->void]" matches the argument list

I can't figure out why. VkInstance is a pointer, so I'm passing it, deleter have to accept pointer to a memory address, so it receiving it still, but still types doesn't match.

Dereferrencing it with & and passing it into make_unique causes a segfault. Makes sense.

The only way I managed to make it work only with with additional new call, like this:

...
    VkInstance* instance = new VkInstance;
    if (vkCreateInstance(&createInfo, nullptr, instance) != VK_SUCCESS) {
        throw std::runtime_error("failed to create vulkan instance");
    }

    auto del = [](VkInstance* p) {
        DBG("release vk instance");
        vkDestroyInstance(*p, nullptr);
    };
    auto ptr = std::unique_ptr<VkInstance, decltype(del)>(instance, del);
...

But this is kinda ridiculous solution, as I'm allocation dynamically for a thing which should lay in a CPU register and transferred almost immediately to unique_ptr area of control.

So, can I achieve somehow what I'm trying to do, without further overengineering?

Answer 1

std::unique_ptr can work with types that aren't even pointers; it can certainly work with opaque pointer types like VkInstance. However, you have to know how to do things the way std::unique_ptr expects.

The key point is this: stop using lambdas for the deleter. unique_ptr's deleter type has useful functionality in it, none of which can be used if you use a lambda type. Also, if you want to use the name of the type of a functor, having to do decltype gymnastics instead of just giving it a name is kind of tacky.

So make a proper deleter:

struct VkInstanceDeleter
{
  using pointer = VkInstance;

  void operator()(VkInstance inst) {vkDestroyInstance(inst, nullptr);}
};

using InstPtr = std::unique_ptr<VkInstance, VkInstanceDeleter>;

InstPtr can now be used to manage VkInstance objects. The only issue is that you can't use -> on it, but that's not meaningful in Vulkan anyway.

Answer 2

I think you forgot the & on your "instance" object when passing it to the std::unique_ptr constructor:

#include <iostream>
#include <memory>

struct Foo
{
};

int main()
{
    Foo f;
    auto deleter = [](Foo* f){std::cout << "deleting it!\n";};
    auto ptr = std::unique_ptr<Foo, decltype(deleter)>(&f, deleter);
}

You can try it here: https://tio.run/##RY1BDoIwFETX/FN8MTGtwQvQytJLqDGkFNIE2gq/C0I4e61E4vbNzBvl/aVTKsajsaoPjUZp3ESjrocK/mzQgxvnCiBFQRHenIMFVgFgLOFQG8t4Alni2ArI6kAOG91r0iNe8f5kKTljy5eJmrJULhBKiflWMbZDQ4eHzcW6bz19d1s5WPMO@pWITJIiaVVPs9fs5@cVO7XF/sYFrDF@AA

Answer 3

The problem is that VkInstance is a pointer, not "pointed-to-type", so basically you should have something like std::unique_ptr<VkInstancePointee>. But since we don't have this type, and this is basically implementation detail of Vulkan which can be changed without notice its better not to use it. So if you want RAII behavior you just need to create wrapper. Something like this:

class VkInstanceWrapper
{
public:
  static VkInstanceWrapper Create(const VkInstanceCreateInfo* createInfo) {
    return VkInstanceWrapper(createInfo);
  }

  VkInstanceWrapper(const VkInstanceCreateInfo* createInfo) {
    if (vkCreateInstance(createInfo, nullptr, &instance) != VK_SUCCESS) {
      throw std::runtime_error("failed to create vulkan instance");
    }
  }

  ~VkInstanceWrapper() {
    vkDestroyInstance(&instance, nullptr);
  }

  // To use in other vulkan calls
  operator VkInstance *() {
    return &instance;
  }

  // You need to delete copy constructor/assignment
  VkInstanceWrapper(const VkInstanceWrapper&) = delete;
  VkInstanceWrapper& operator=(const VkInstanceWrapper&) = delete;

  // You can either define or delete move constructor/assignment
  VkInstanceWrapper(VkInstanceWrapper&&) = delete;
  VkInstanceWrapper& operator=(VkInstanceWrapper&&) = delete;

private:
  VkInstance instance;
};

Answer 4

So, after researching a bit more, I think I need something like this:

1. https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3677.html
2. https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3830.pdf
3. https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3949.pdf

Found out these from here: One-liner for RAII on non pointer?

And those are not implemented, but conforms to the general RAII concept. So, seems like unique pointers are only for pointer allocated resources, not for the value resources, which opaque handles in my case are.