CODEWITHSUNDEEP
vulkan
xaxazak
xaxazak

Reputation: 830

Vulkan: Any downsides to creating pipelines, command-buffers, etc one at a time?

Some Vulkan objects (eg vkPipelines, vkCommandBuffers) are able to be created/allocated in arrays (using size + pointer parameters). At a glance, this appears to be done to make it easier to code using common usage patterns. But in some cases (eg: when creating a C++ RAII wrapper), it's nicer to create them one at a time. It is, of course, simple to achieve this.

However, I'm wondering whether there are any significant downsides to doing this?

(I guess this may vary depending on the actual object type being created - but I didn't think it'd be a good idea to ask the same question for each object)

Assume that, in both cases, objects are likely to be created in a first-created-last-destroyed manner, and that - while the objects are individually created and destroyed - this will likely happen in a loop.

Also note:

Are there any reasons I should modify my RAII wrapper to allow for array-based creation/destruction? For example, will it save memory (significantly)? Will single-creation reduce performance?

Upvotes: 4

Views: 1204

Answers (3)

Nicol Bolas
Nicol Bolas

Reputation: 474336

Remember that vkPipeline creation does not require external synchronization. That means that the process is going to handle its own mutexes and so forth. As such, it makes sense to avoid locking those internal mutexes whenever possible.

Also, the process is slow. So being able to batch it up and execute it into another thread is very useful.

Command buffer creation doesn't have either of these concerns. So there, you should feel free to allocate whatever CBs you need. However, multiple creation will never harm performance, and it may help it. So there's no reason to avoid it.

Upvotes: 2

krOoze
krOoze

Reputation: 13306

There may (or may not) be better performance (depending on driver and the type of your workload). But there is obviously potential for better performance.

If you create one or ten command buffers in you application then it does not matter.

For most cases it will be like less than 5 %. So if you do not care about that (e.g. your application already runs 500 FPS), then it does not matter.

Then again, C++ is a versatile language. I think this is a non-problem. You would simply have a static member function or a class that would construct/initialize N objects (there's probably a pattern name for that).

The destruction may be trickier. You can again have static member function that would destroy N objects. But it would not be called automatically and it is annoying to have null/husk objects around. And the destructor would still be called on VK_NULL_HANDLE. There is also a problem, that a pool reset or destruction would invalidate all the command buffer C++ objects, so there's probably no way to do it cleanly/simply.

Upvotes: 1

PistonMiner
PistonMiner

Reputation: 11

Vulkan is an API designed around modern graphics hardware. If you know you want to create a certain number of objects up front, you should use the batch functions if they exist, as the driver may be able to optimize creation/allocation, resulting in potentially better performance.

Upvotes: 1

Related Questions