c-vector | dynamic array implementation in C | Functional Programming library

You can do a few things like:

1. Don't render your component until the request is done or...

2. Use loading flag state

Use an extra state for the "loading" flag.. you can start this on "true" and after finished change it to false and render your component with the data.

This is my example:

Each Cuda multiprocessor has execution units (several each for int, float, special functions, ...). Those work as pipelines, which take several cycles to complete a calculation, but in each cycle a new calculation can be inserted (=scheduled) and several calculations are processed at the same time at different stages of the pipeline.

Groups of 32 threads (warps) within a block are scheduled the same instruction at the same time (same cycle or often two cycles depending on how many execution and datapath resources are available on the architecture and needed for this instruction), together with a bitfield, stating, for which threads this instruction should be actively executed. If some threads of a warp evaluated an if clause as false, they are temporarily deactivated. Or some threads may have already exited the kernel.

The effect is that if the 32 warps diverge (branch differently), each execution path has to be run through for each of the 32 threads (with some threads deactivated for each path). That should be avoided for performance reasons, as the computation resources are reserved nevertheless. Threads from different warps don't have this interdependency. The algorithm should be structured in a way to consider this.

With Volta, Independent Thread Scheduling was introduced. Each thread has its own instruction counter (and manages a separate function callstack). But the scheduler still will schedule groups of 32 threads (warps) with bitfields for active threads. What changed is that the scheduler can interleave the diverging paths. Instead of executing CCCIIIEEECCC pre-Volta (instructions: C=common, I=if branch, e=else branch), it could execute CCCIEEIIECCC, if the available execution units or the memory latency better fits. As programmer, one has to be careful, as it can be no longer assumed that the threads have not diverged, even when executing the same instruction. That is why __syncwarp was introduced and all kind of cooperation functions (e.g. the shuffle instructions) got a sync variant. Nevertheless (although we cannot know for sure, if the threads diverged) one still has to program in a way that all 32 threads can work together, if executed synchronously, especially for coalesced memory accesses. Putting __syncwarp after each possibly diverging instruction can help to ensure convergence. (But do performance profiling).

The Independent Thread Scheduling is also the reason, why __syncthreads must definitely be called correctly on the RTX 3080 - with each thread participating. A typical correcting solution for the deadlock case you mentioned in the comment is to close the if clause, sync all the threads and open a new if clause with the same condition as the previous one.

Is there any way to view the elements nicely without displaying some part of the STL containers?

You either have a very old GDB, or some non-standard setup.

Here is what it looks like on a Fedora-34 system with default GDB installation:

You can try identical in sapply and compare each with the first element.

The copying of an entire std::vector is O(N) as each element T needs to be copied.

All overloads of std::vector::operator[] are required by the C++ standard to have constant complexity. Normally it's implemented using pointer arithmetic on the data in the std::vector.

So, v[i] = v[j]; is O(1).

The fact that T could be arbitrarily multidimensional does not matter here. A vector copy is O(N) since if you double the number of elements, you double the time (in some limit anyway). The vector element copy is O(1) since it does not depend on the number of elements in the vector.

i had the same situation and i think if you want to update your tiles postgis solution(medium article) is much faster and easier.

but if you just want to read raster tiles as a static map, the file system solution is much faster and you can keep your data with some structure like {z(directory)}/{x(directory)}/{y(tile)} and i recommend to take a look at tippecanoe project. it's a perfect way for static map, even better than file system solution.

if you just want to change styles any time you want i recommend to use vector tiles. it's so much faster.

This is because of a simple reason. When you erase an entry, the array needs to remove that "bubble" (which is the empty slot) and compact the array. Which means that it needs to move some stuff. So when moving, what they do is something like this,

Throw in rowwise and also check the length of vector to compare to avoid the warnings.

You have failed to link the library with your program.

Doing