spawn | Openprovider RESTful sync service | Runtime Evironment library

You are not measuring the elapsed time correctly:

1. total_send_time measures the duration of the spawn() call, but as the actual task is executed asynchronously, start_in.elapsed() does not give you any information about how much time the task actually takes.

2. The ran in time, as measured by start.elapsed() is also not useful at all. As you are using blocking sleep operation, you are just measuring how much time your app has spent in the std::thread::sleep()

3. Last but not least, your time_to_sleep calculation is completely incorrect, because of the issue mentioned in point 1.

You can use two levels of aggregation -- the inner one to get the status per parent and device. For this, you can actually use min(taskStatus) to get the status:

Pythons multiprocessing package is limited to shared memory parallelization. It spawns new processes that all have access to the main memory of a single machine.

You cannot simply scale out such a software onto multiple nodes. As the different machines do not have a shared memory that they can access.

To run your program on multiple nodes at once, you should have a look into MPI (Message Passing Interface). There is also a python package for that.

Depending on your task, it may also be suitable to run the program 4 times (so one job per node) and have it work on a subset of the data. It is often the simpler approach, but not always possible.

1. It is the main method, so there is no need to cleanup. When main returns, the program exits. If this wasn't the main, then you would be correct.

2. There is no best practice that fits all use cases. The code you show here is a very common pattern. The function creates a goroutine, and returns a channel so that others can communicate with that goroutine. There is no rule that governs how channels must be created. There is no way to terminate that goroutine though. One use case this pattern fits well is reading a large resultset from a database. The channel allows streaming data as it is read from the database. In that case usually there are other means of terminating the goroutine though, like passing a context.

3. Again, there are no hard rules on how channels should be created/closed. A channel can be left open, and it will be garbage collected when it is no longer used. If the use case demands so, the channel can be left open indefinitely, and the scenario you worry about will never happen.

The value type of your unordered_map is std::variant, but in your brace init list, you're passing float instead of a double. This conversion from float to a variant is not allowed.

Either change your value type to std::variant, or pass literals of float type, e.g. 1.5f instead of 1.5.

The minimized issue in code is

You need to add the seconds of cooldown you want on the spawner when you declare it too, E.G spawnCooldown = Time.time + coolDownPeriodInSeconds;

You also need to set spawnCooldown to be a float, which stores numbers. Currently you have stored it as a bool, which only stores true or false values, and therefore cannot be compared to Time.time further in the code.

Lastly you are missing the closing } character in the if block

What is happening currently is you are doing the following:

1. Setting spawn Cooldown to be the current Time
2. For every frame after that, checking if the new current time is greater than the old time you set as spawnCooldown. Since it always is, the code will then run through the spawn script.

If you change it to

#[tokio::main] converts your function into the following:

The third and all subsequent parameters in the setInterval function can be used to pass parameters with.

So in your case, pass the eventname reference to setTimeout after the delay argument, and only reference the DoStuff function without calling it.