A colleague and I are doing a "virtual 3d creature evolver" application for our Bachelor project, based on genetics algorithms it create and mutate 3d creatures to achieve a goal (e.g. max distance traveled in a given time).
We did use Bullet for all physics things and Ogre3d as a rendering system.
One of the main goal was to make a multiplatform worker that could compute result against an experiment and broadcast those to the community. This approach let us spawn a dozen worker on dedicated server that only compute a lot of creatures and give bests results back. Or allow multiple user working on the same experiment to get bests results.
Everything is almost done, we are generating our first results.
For somes basics experimentations we achieve to create running spider from a given spider shape (in fact it didn't use all of his legs, but still running
). But for more complexe experimentation like biped walking we get stuck in a more problematic things.The worker reached a score of X, but when we simulate the result within our computer the score is in fact very different.
We did some test on different servers and computer and it appear that float precision did vary a little bit in each of theses configuration. That make sens because there are different compilator, different architectures, etc... So micro movement and stability of the body is not exactly the same on both computer and the creature instead of walking for X meters fall quickly on our computer
.So our question is what would be a good approach to reach a more higher determinism across platforms ? Is there some tricks that improve float precision determinism across implementations ?
Another question is about performance. Because of the nature of our project, we need to be able to compute as fast as possible a small experiment.
An experiment is generally composed by a scene with some static object (0..10) a static floor and 1 entity.
An entity is composed by somes btCompoundShape (1..30-40) with two childShape (sphere and cylinder) and the same number of 6dof constraints. Because we need some good looking constraint we put the number of iteration from 10 to 20, and it seems to be acceptable.
For now the bullet setup is quite the same as the tutorial one (except the number of iteration for the constraint solver) for this specific purpose what could we look on to improve ? Is there some kind of parallelism that would help us ?
Thank for reading me,
Cyprien