partake | PARTAKE is a web application to manage event organization | Calendar library

It totally depends on what is being planned, so there is no single answer.

In your case, drills seem to accumulate information over time and to change state. There seems to be a separate drill every time you do planning and only that drill is executed. You might want to keep only the current state, but I would generally want to keep transition tables to know when something happens.

A variation might be a class or a training, where there is a standard training. That might be stored as an entity (say in trainings). You would then have a training_schedule table, which could have past and future dates -- as well as a unique id. Then the participants would be linked to the training_schedule.

Yet another variation is a budget versus actuals. In this case, the budget is in many ways its own entity, that you want to name and keep over time. The actuals accumulate and you want to compare them. That would be a different data model, because there can be multiple budgets active at the same time (the original one for the year and the updated budget based on actuals that have already happened).

In CUDA the thread id is only unique per so-called thread block, meaning, that your example kernel only does the right thing with only one block doing work. This is probably done in early examples to ease you into the ideas, but it is generally a very bad thing to do in terms of performance:

With one block, you can only utilize one of many streaming multiprocessors (SMs) in a GPU and even that SM will only be able to hide memory access latencies when it has enough parallel work to do while waiting.

A single thread-block also limits you in the number of threads and therefore in the problem-size, if your kernel doesn't contain a loop so every thread can compute more than one element.

Kernel execution is seen strongly hierarchically: Restricting ourselves to one dimensional indexing for simplicity, a kernel is executed on a so-called grid of gridDim.x thread blocks, each containing blockDim.x threads numbered per block by threadIdx.x, while each block is numbered via blockIdx.x.

To get a unique ID for a thread (in a fashion that ideally uses the hardware to load elements from an array), you have to take blockIdx.x * blockDim.x + threadIdx.x. If more than one element shall be computed by every thread, you use a loop of the form

It means that it is creating the class when running the program and can be changed while running the program

while loops automatically continue when you reach the end of the indented code suite, so there is no need for your if suites to do it manually. But you need to put the prompts in the while so it keeps prompting for more data as you go.

Your code could be

I managed to reproduce this issue with the simplified code below. It seems to me like a bug, or at least as an undocumented limitation of the Aggregate method. It fails after enumerating a number of around Int32.MaxValue elements.

This code should help: