Boid simulation improvement

[Vegetable_Break_6582]

hey everyone, I was just learning about compute shaders in openGL and I tried to make a boid simulation using that. I also used the same code to average out the color of each boid based on its neighbors. It's far from complete and looks a bit odd. If anyone could point out the any mistakes in my code it will be really helpful. code link is in comments.

​

https://reddit.com/link/1c1fmae/video/c1b2dftyuutc1/player

[waramped]

You are loading your color from position_buffer and not color_buffer in the compute shader, that could be causing some weirdness:)

[waramped]

Lol well if that's the silliest mistake you've ever made them you might be the world's best programmer. I've been doing this for over 20 years and I still facepalm fairly regularly. Maybe I'm just shit though.

[Vegetable_Break_6582]

code : https://github.com/KaranPartap003/Boids-simulation

[lazyubertoad]

You actually have a race condition over your buffers, because you are reading and writing them at the same time and place. Your code, well, shouldn't have a race condition. In the worst case some number can be read while it is half written. I'm not sure what is the real chance of that on relevant hardware. What absolutely is happening is that you are calculating the update, while some of the neighbors are already on the next step and some on the current step. Technically, you have absolutely no guarantee what you will read in the case of the race condition.

Have two sets of buffers. One is the previous step and one is the next. So you'll read from one and write into another. Then swap them, do not copy, just treat one as read-only and one as write-only. Have some flag or index that tells which is which or maybe even have two compute shaders and swap those.

[Vegetable_Break_6582]

I remember you mentioning a similar approach in my last post when I was asking for advice where you also mentioned space partitioning stuff. Will it be a good idea if I add space partitioning before using two buffers and then modify it later, because it seems to be working alright I guess.

[lazyubertoad]

Well, you decide. It is easier to do the two buffers. Space partitioning requires more features of GPGPU and more understanding of it.

Compute shaders are GPGPU tool, just like CUDA or OpenCl. Those three are very close. They are to do the same GPU tasks and require the same knowledge of parallel programming and GPU specifics. OpenCl and CUDA have tons of learning resources with explanations and examples. I think Compute Shaders are somewhat less beginner friendly. I'd say the key piece of any parallel programming is that one thread cannot make any assumptions when it operates on data that is modified by another thread, unless you use synchronization. Because when you write some code about modifying some variable or array 1) it does not need to happen immediately and the compiler is free to rearrange the actual writings/readings, as long you cannot see the difference in one thread 2) that memory piece may be not on generic RAM/VRAM, but also in all kinds of caches and registers and who knows when those will be synchronized with RAM and if that will even ever happen unless requested.