openCL | Repository for OpenCL codes | GPU library

With those changes, I'm able to acheive 3 to 4 stable delay ;)

LINE 79 of

https://github.com/OpenVidu/openvidu/blob/master/openvidu-server/docker/openvidu-recording/scripts/composed.sh

I REPLACED

The problem is that OpenCL buffer to which weights are accumulated is not initialized (zeroed). Fixing that:

I'm hesitant to make blanket statements about what's fast or what's slow in your code without fine-grained profiling data, but here are some candidates for how to improve things:

• You are splitting the algorithm rather awkwardly across CPU and GPU, and are doing the maximum amount of memory copying, which presumably the pure CPU version doesn't do. Do as much computation on the GPU as possible, copy as little data as possible between device and host.
• Your values for A & B elements are in the range 0..65535. There is no need to make every element a 64-bit integer.
• Especially if you are using the Iris GPU which uses shared memory, use zero-copy buffers. There are detailed explanations of this, but essentially:
  • Don't: allocate host memory, fill it, then create a CL buffer and copy to that.
  • Instead: create a CL buffer, map it into host memory space, fill it directly through the mapped pointer, then unmap it.
• Generating the random numbers on GPU would save you a lot of memory bandwidth - no need to copy A & B to device memory. Not all random number generators are suitable for this though, and there certainly isn't one built into OpenCL.
• This: if(C[i] <= (LIST_SIZE * LIST_SIZE)) is needlessly doing computation on the host. Yes, comparison is computation. If you perform this check in your kernel, you don't need to write to array C - or at least, you can write a 0 or 1 to an array of bytes instead of 64-bit integers. This will save you memory bandwidth and host side execution time.
• If you implement the above advice, you'll realise it would be best to just increment the inner/outer counters on GPU.
  1. You don't need 2 counters, the second one can be inferred by subtracting the first from the total iterations.
  2. The naive correct approach in OpenCL would be to use an atomic increment in every work-item.
  3. Atomically updating a single memory location from every work item won't perform great. Better: use work-groups. Work out by how much to increase the counter for all the elements a group using local memory, then perform an atomic addition to the global counter in just one of the group's work items.
• You may want to try processing more than one A/B pair per work-item after the above changes to further reduce overhead for accumulating the counts.

After some debuging and reading about OpenCL-HPP I found the problem.

The main issue is that the OpenCL-HPP uses pthreads and if they are not included / linked one gets problems like described above.

Articles that helped:
cmake fails to configure with a pthread error
Cmake error undefined reference to `pthread_create'
Cmake gives me an error (pthread_create not found) while building BornAgain

The main issue is that the Call_once method crashes without any really understandable cause. The project will build though.

One thing that derails everything is the CMake it is not really helping with understanding the linking procedure.

Output from the CMake setup:

You didn't tell ffmpeg what to do with the audio so it just picked the audio from the first input (see stream selection).

Because you are using xfade you probably want to use acrossfade as shown in Merging multiple video files with ffmpeg and xfade filter:

A good start is to format your code so you have consistent indentation. I have done that for you here. If you are using Visual Studio Community, select the text and press Ctrl+K and then Ctrl+F.

Now to the profiling. Here is a simple Clock class that is easy to use for profiling:

barrier is only a synchronization point for all threads within a (local) work group. But you want to have a global synchronization for all threads. You can't do such a global synchronization in a kernel; you would have to split the kernel into two parts and repeatedly call the odd and even kernels. Finishung a kernel represents a global synchronization point.

In your case it works on small scale, i.e. if you have only a single work group, because then the local size is equal to global size and the barrier works on all available threads.

PTX register naming is summarized here. PTX has a virtual register convention, meaning the registers are effectively variable names, they don't necessarily correspond to hardware registers in a physical device. Therefore, as indicated there, the actual interpretation of these requires more PTX code than the snippet you have here. (The virtual registers are formally declared before their usage.) Specifically, you would normally find a set of declarations something like this:

You can get the value which is next to last non-NA value.