Semms to be fixed with Alfreds soon to come merge.

Lets check again after this merge. Should only be a matter of days.

Some more details on this bug:

The three functions in mbilog.cpp are missing necessary thread safety mechanisms:

mbilog::RegisterBackend
mbilog::UnregisterBackend
mbilog::DistributeToBackends

An example failing scenario is:

(1) At the beginning of main, write some logging output. This block of code in mbilog::DistributeToBackends will be triggered:

if(backends.empty() && (dummyBackend == NULL))
{
  dummyBackend = new mbilog::BackendCout();
  dummyBackend->SetFull(false);
  RegisterBackend(dummyBackend);
}

(2) Register a backend:

mbilog::RegisterBackend(new mbilog::BackendCout());

(3) Spawn a bunch of threads (e.g. in an OMP-parallelized for loop) that all immediately write logging information. In mbilog::RegisterBackend more than one (usually) will the next block of code:

else if((backends.size()>1) && (dummyBackend != NULL))
{
  //if there was added another backend remove the dummy backend and delete it
  UnregisterBackend(dummyBackend);
  delete dummyBackend;
  dummyBackend = NULL;
}

Since access to the dummyBackend variable is not protected I get glibc double free crashes.

Note that access to the backends static variable also needs to be protected.

Should this 2-year-old bug maybe be a higher priority?

A readers/writer lock would be ideal for best performance, but ITK doesn't seem to provide one (at least not yet...). See this ongoing thread:

http://comments.gmane.org/gmane.comp.lib.itk.user/43007

Updating target milestone to upcoming release

Updating target milestone.

Writing messages to the mbi-log is thread-safe. The registration/unregistration of backends is not thread-safe, as explained above. To make it thread safe you have to add a mutex lock to the backend list. The problem is that the mbilog-module has no dependencies so far (and shall not get any). Therefore, we cannot use the ITK mutex.

In future versions we can use the C++11 mutex lock. At the moment we are not able to use it because of backwards compatibility. Once we are free of this limitation it will be fixed.