mush | Mush is a flexible dependency injection framework for Python | Dependency Injection library

If you are using pandas, change the separator like this:

If you have branching in a kernel and within a work group some workers do branch A and some branch B, all workers have to compute both branches and discard the non-used branch result respectively. This negatively impacts execution time and is the reason why branching on GPUs should be avoided if possible. In your example with the empty return branch, if only one worker in the workgroup has to do the time consuming calculation, all the other workers have to wait, blocking hardware resources for other workgroups. If workgroups are small and you are lucky that all threads do the return branch, then that particular workgroup is executed very fast.

The matching between physical GPU "cores" and work group size is irrelevant for the computation results, but can impact performance to some extent. Workgrouop size should be a multiple of 32 (the GPU subdivides its "cores" into groups of 32, so-called warps). So if workgroup size is 16, half of the GPU will always be idle. If the workgroup size is extraordinarily large on the other hand (like 1024) and you have branching in the kernel, then it is less likely that all workers do the same branch and you end up in the above scenario.

Workgroup size is a bit of a tradeoff sometimes, if you need communication across the workgroup via local memory. Larger workgroup allows for more local communication, but increases "double-branch" likelyhood. If you don't use local memory, you can freely tune workgroup size for best performance (usually 64-256).

Ideally you want to saturate the GPU with millions of threads to have no idle "cores" and best performance.

1. This is not possible. You cannot communicate data across kernels in "global variables" in private or local memory space. You need to use global kernel arguments to temporarily store results, and thus write the values to video memory temporarily and read from video memory in the next kernel. The only memory space allowed for "global variables" is constant: With it, you can create large look-up tables for example. These are read-only. constant variables are cached in L2 whenever possible.

2. Potentially several thousand. When you finish one kernel and start another, you have a global synchronization point. All instances of kernel 1 need to be finished before kernel 2 can start.

3. Yes. It depends on the global range, local (work group) range, number of operations (especially if-else branching, because one work group can take significantly longer than the other), but not on the number of kernel arguments / buffer bindings. The larger the global size, the longer the kernel takes, the smaller are relative time-vatiations between work groups and the smaller is the relative performance loss of the kernel change (synchronization point).

4. Better question: How large should the global range be for a kernel to be performant? Answer: Very large, like 100 times the CUDA core / stream processor count.

There are tricks to reduce the number of required global synchronization points. For example: If a kernel can combine multiple different tasks from different kernels, squash two kernels together into one. Example here: lattice Boltzmann method, two-step swap versus one-step swap.

Another common trick is to allocate a buffer twice in video memory. In even steps, read from A and write to B and in odd steps the other way around. Avoid reading from A and at the same time writing to other elements of A (introduces race-conditions).

I'll give you a few options. First, I'll answer your original question. Second, I'll give you a suggestion that will make it more performant. Third, I'll offer another option that changes how you store your state.

I believe the main issue is that as you iterate over the source array you need to find the matching elements in the state machine array. There are many methods to doing that but the easiest is to simply "do it". Meaning as you find an element to compare, then find the matching element in the other array. Since you have nested data, you'll do that at two levels.

This code will work (but is not performant):

You are enqueueing state updates in a loop using a standard update. This means each update uses the state from the render cycle the update is enqueued in. Each subsequent update overwrites the previous state update, so the net result is the last enqueued update is the one that sets state for the next render cycle.

Use a functional state update. The difference here is that functional state updates updates from the previous state, not the state from the previous render cycle. It requires only a minor tweak from setDict({...dict, [x]: res.y}) to setDict(dict => ({...dict, [x]: res.y})).

You can't chain shift() and pop(), because shift() returns the element that was removed, not the updated array.

For your needs you can use .slice() to get the sub-array without the first and last elements. And you can chain it from sort(), since it returns the array (in addition to modifying it in place).

Since slice() doesn't modify the array, you need to subtract 2 from the length when calculating the average.

You can make your local variable sheet an instance variable:

You cannot stop the task created by threading.Thread(). Use subprocess instead:

will match Unicode character work? depending on your application it may have Unicode support