memalloc | A simple memory allocator - Memory allocation

In second pass, depth attachment description, it "loads" image in undefined state:

As I'm not passing a pointer of a pointer, I do not need a temporary variable to hold the value of the head, correct?

That is correct. The function will receive a copy of the pointer passed by the calling module. In that module, the value of that pointer will not be changed by your function (i.e. it will remain pointing at the head of the list).

As an aside, even if you know that your passed head value will not (read: should not) be NULL, it is still better to add a check for that, in case a future editor of your code does something silly.

Also, your while loop can be much simplified:

To understand what's going, you need to understand what VkAllocationCallbacks are for. So let's dive in.

When you call vkCreateDevice for example, a Vulkan implementation needs to return a VkDevice handle. This is undoubtedly a pointer to an object. So... where did it's memory come from? There must be some internal, implementation-defined data structure in play. And that likely requires heap allocation.

However, for a low-level system, it is generally considered rude for it to arbitrarily allocate heap memory without the knowledge or consent of the application using that system. The larger application may want to pre-allocate a bunch of memory specifically for the Vulkan implementation's use, for any number of reasons.

Being able to do that requires being able to replace the Vulkan implementation's heap allocation functions with your own. That is what VkAllocationCallbacks are for: allowing your program to provide heap-allocation services to the Vulkan implementations, which will use them for its own internal data structures. And that last part is important: these allocations are for internal use.

vkAllocateMemory is a function for allocating device-accessible memory. Now yes, depending on the memory type used, it may allocate from the same pool of memory as CPU-accessible memory. But the memory vkAllocateMemory is allocating from is not for the Vulkan implementations usage; it's for your application's usage, mediated through the Vulkan API.

Now, above I said "in certain contexts". When you create a device using VkAllocationCallbacks, the callbacks will be used to allocate implementation memory for any Vulkan function using that device. That is the context of those callbacks. Other functions have their own context. For example, when you call vkCreateDescriptorPool, you also give it callbacks. These callbacks, if specified, will be used for any allocations used for descriptor pools.

Now, as stated above, vkAllocateMemory allocates device-accessible memory. However, it also creates a VkDeviceMemory object that represents this storage. This object lives in CPU space, and therefore it must have been allocated from CPU storage.

That's what the 200 bytes you saw represents: not the device memory allocation itself, but the allocation of CPU storage used to manage that device memory. You could say that the internal implementation object represented by VkDeviceMemory takes up 200 bytes.

Overall, you cannot track device-accessible allocations through a system intended to provide you with access to how much CPU-accessible memory is being allocated by Vulkan.

Generally speaking, if you have any issue with the Cuba C library, the best thing to do is to contact the author: https://wwwth.mpp.mpg.de/members/hahn/. If an issue is fixed upstream, it'll be eventually included in the Cuba.jl Julia wrapper.

Understand that your memory allocation worry is misplaced for a few different reasons:

1. you aren't doing the benchmark correctly: the BenchmarkTools.jl package provides more accurate and reliable tools for benchmarking:

Your code is correct but you measure the performance incorrectly.

Note that for this use case scenario (calling external processes) you should be fine with green threads - no need to distribute the load at all!

When a Julia function is executed for the first time it is being compiled. When you execute it on several parallel process all of them need to compile the same piece of code.

On top of that the first @distribution macro run also takes a long time to compile. Hence before using @timed you should call once both the fpar and nofpar functions.

Last but not least, there is no addprocs in your code but I assume that you have used -p Julia option to add the worker processes to your Julia master process. By the way you did not mention how many of the worker processes you have.

I usually test code like this:

In your memalloc and these lines you close the file

Nicol Bolas helped me find the problem. I now use the format returned by this vr_api function: