demo
Well-known member
The crash is actually this failed assert
and I'm not quite sure how that's possible unless it's a lib bug...Code:dash-qt: /home/ubuntu/build/dash/depends/x86_64-unknown-linux-gnu/share/../include/boost/thread/pthread/recursive_mutex.hpp:113: void boost::recursive_mutex::lock(): Assertion `!pthread_mutex_lock(&m)' failed.
https://en.wikipedia.org/wiki/Mutual_exclusion
http://stackoverflow.com/questions/...-mutual-exclusion-among-more-than-two-threads
http://stackoverflow.com/questions/187761/recursive-lock-mutex-vs-non-recursive-lock-mutex
http://antonym.org/2012/02/threading-with-boost-part-iii-mutexes.html
Recursive Mutexes
Normally a mutex is locked only once, then unlocked. Depending on the structure of your application, there may be times when it would be useful to be able to lock a mutex multiple times on the one thread (in very special circumstances, such as nested method calls). For example, you have two (or more) methods which may be called independently, and another method which itself calls one of the other two. If they all need the mutex held to function safely, this can cause complications when determining when the mutex needs to be locked and released. However, by using a recursive mutex, it can be locked as many times as necessary, provided it is unlocked the same number of times. Thus all these methods can be called individually, as they all lock the resources, and in a nested fashion, as the mutex can be locked multiple times. Provided the mutex is unlocked the same number of times (which is a matter of care and thought), the mutex will be correctly released by the end of the nested operation.
Somewhere in your code you forgot to unlock.
Start counting how many times you locked and unlocked the recursive mutex.
My sense is that the interoperability betwen python and c++ may cause the problem.
Last edited: