khronos | An intuitive Date extensions in Kotlin | Date Time Utils library

My objective is to obtain the ability of parallelizing a code in order to be able to run it on GPU, and the Graal would be to have a software that can run in parallel on any GPU or even CPU (Intel, NVIDIA, AMD, and so...).

From what I understood, the best solution would be to use OpenCL. But shortly after that, I also read about SYCL, that is supposed to simplify the codes that run on GPU.

But is it just that ? Isn't better to use a lower level language in order to be sure that it will be possible to be used in the most hardware possible ?

I know that all the compatibilities are listed on The Khronos Group website, but I am reading everything and its opposite on the Internet (like if a NVIDIA card supports CUDA, then it supports OpenCL, or NVIDIA cards will never work with OpenCL, even though OpenCL is supposed to work with everything)...

This is a new topic to me and there are lots of informations on the Internet... It would be great if someone could give me a simple answer to this question.

I am reading the vulkan subgroup tutorial and it mentions that if the local workgroup size is less than the subgroup size, then we will always have inactive invocations.

This post clarifies that there is no direct relation between a SubgroupLocalInvocationId and LocalInvocationId. If there is no relation between the subgroup and local workgroup ids, how does the small size of local workgroup guarantee inactive invocations?

My guess is as follows

I am thinking that the invocations (threads) in a workgroup are divided into subgroups before executing on the GPU. Each subgroup would be an exact match for the basic unit of execution on the GPU (warp for an NVIDIA GPU). This means that if the workgroup size is smaller than the subgroup size then the system somehow tries to construct a minimal subgroup which can be executed on the GPU. This would require using some "inactive/dead" invocations just to meet the minimum subgroup size criteria leading to the aforementioned guaranteed inactive invocations. Is this understanding correct? (I deliberately tried to use basic words for simplicity, please let me know if any of the terminology is incorrect)

Thanks

Question: Are there any granularity/alignment requirements for transfering sub-regions of a VkBuffer from one queue family to another?

I would like to:

1. use a single graphics/present queue for sourcing draw calls from a single VkBuffer;
2. and another separate compute queue to fill sub-allocated regions/sections within said VkBuffer

So, commands submitted to the graphics/present queue (1.) will read/source data written to the VkBuffer by commands submitted to the compute queue (2.). And I do not want to transfer the whole VkBuffer from one queue to the other, but only certain sub-regions (once their computation is finished and the results can be consumed/sourced by the graphics commands).

I've read that whenever you use VK_SHARING_MODE_EXCLUSIVE VkSharingMode you must explicitly transfer ownership from one queue (in my case the compute queue) to the other queue (in my case the graphics/present queue) such that commands submitted to the latter queue sees the changes made by submitted commands in the former queue. I know how to do this and how to correctly synchronize both release and acquire actions with semaphores.

However, since I wanted to use a singe VkBuffer with manual sub-allocations (actually with VMA virtual allocations) and saw that VkBufferMemoryBarrier provides an offset and size properties, I was wondering whether there are any granularity requirements as for which sections/pages of a VkBuffer can be transferred.

Can I actually transfer single bytes of a VkBuffer from one queue family to another or do I have to obey certain granularity/alignment requirements (other than the alignment requirements for my own data structures within that VkBuffer and the usage of that buffer of course)?

I used clang's ftime-trace to profile the compilation of time of my program. Turns out that about 90% of the time is spent parsing the massive vulkan.hpp header provided by the khronos group.

This in turn means that if I minimize the inclusion of this header on header files and put it only on cpp files my compile times should be drastically better.

I face the following problem however.

There's a few objects in the header that I need pretty much everywhere. There's a few error code enumerators, a few enums of other kinds, and a couple of object types, such as

vk::Buffer, vk::Image etc...

These ones make less than a fraction of a percent of the total header, but I cannot include them without including the entire header. What can I do to cherry pick only the types that I actually use and avoid including the entire header every time I need my code to interface with an image?

I am investigating how to do cross-process interop with OpenGL and Direct3D 11 using the EXT_external_objects, EXT_external_objects_win32 and EXT_win32_keyed_mutex OpenGL extensions. My goal is to share a B8G8R8A8_UNORM texture (an external library expects BGRA and I can not change it. What's relevant here is the byte depth of 4) with 1 Mip-level allocated and written to offscreen with D3D11 by one application, and render it with OpenGL in another. Because the texture is being drawn to off-process, I can not use WGL_NV_DX_interop2.

My actual code can be seen here and is written in C# with Silk.NET. For illustration's purpose though, I will describe my problem in psuedo-C(++).

First I create my texture in Process A with D3D11, and obtain a shared handle to it, and send it over to process B.

I've run into an issue while attempting to use SSBOs as follows:

The GLSLangSpec.3.30 says:

Values from the previous pipeline stage are copied into input variables at the beginning of shader execution. Variables declared as in or centroid in may not be written to during shader execution.

If they are copied in and the original values are left untouched, why are input variables not writable?

I'm currently working with OpenGL in C++, and I'm trying to debug by identifying what the currently bound vertex buffer and index buffer are. I have three functions.

I'm learning Vulkan following vulkan-tutorial.com.

I'm stuck because I can't figure out why I'm getting this error when creating the graphics pipeline.