seg fault for accessing a singleton-like static member - c++

Question

Here is the code, simplified...
//A class used in the next class, Nothing much to worry about
class BasicLogger{
//...
};
Below is my main class. It has two member you need to look at: A static member(called log) of its own type.
And, a container (called repo) for holding objects of the above class. repo's items are accessible using operator[] overload:
class Logger {
protected:
// repository of profilers. each profiler is distinguished by a file name!
std::map<const std::string, boost::shared_ptr<BasicLogger> > repo;
public:
Logger(){} //breakpoints never reach here. why?
//universal singleton-like access to this class
static Logger log;
//returns a member stored in the above 'repo'
virtual BasicLogger & operator[](const std::string &key);
};
The problem comes from this method:
BasicLogger & Logger::operator[](const std::string &key)
{
std::map<std::string, boost::shared_ptr<BasicLogger> >::iterator it = repo.find(key);
if(it == repo.end()){
std::cout << "creating a new Logger for " << key << std::endl;
boost::shared_ptr<BasicLogger> t(new LogEngine(key));
std::map<const std::string, boost::shared_ptr<BasicLogger> > repo_debug;//just for debug
repo_debug.insert(std::make_pair(key,t));//ok
repo.insert(std::make_pair(key,t));//seg fault
return *t;
}
return *it->second;
}
and last piece of information: Throughout the project, items in repo container are accessed like below.
namespace{
BasicLogger & logger = Logger::log["path_set"];
}
Problem:
The problem is that at the beginning of program, before anything, the control goes directly to BasicLogger & logger = Logger::log["path_set"];
Q1: why exactly does the control go here first? just because log is static or anonymous namespaces are also attended initially?
Anyways,
so when the operator[] is executed, repo seems to be uninitialized. I added a local dummy variable(repo_debug) with the same signature as repo. and observed their value using gdb:
//local repo_debug
Details:{... _M_header = {... _M_parent = 0x0, _M_left = 0x7fffffffdc08, _M_right = 0x7fffffffdc08}, _M_node_count = 0}}}
//main 'repo'
Details:{..._M_parent = 0x0, _M_left = 0x0, _M_right = 0x0}, _M_node_count = 0}}}
Q2. why is repo uninitialized? Basically, why Logger's constructor is not called?
Q3. suggestions to take care of this problem is highly appreciated.
Thanks

Answer 1

Q1: Presumably the declarations are in separate compilation units. Static initialization order across compilation units is implementation defined. So, it's this way due to chance. I'd say lucky chance because the other way you would have initially thought that it works only to find that it breaks on another cpu / compiler / os later on.
Q2: Because logger in the anonymous namespace was initialized first causing a segfault which prevents the static log from ever initializing.
Q3. You could avoid the problem by avoiding singletons in your design. But if you want singletons, one way to avoid static initialization order fiasco is Construct On First Use Idiom:
Logger& Logger::log() {
static Logger* log = new Logger();
return *log;
}
The drawback is that the dynamically allocated object is never actually freed (singletons would be freed at the end of the program anyway, but might be a problem if you run without an OS)
Thread safety of initialization of static locals is guaranteed by the standard in §6.7/4 (c++11 draft):
...Otherwise such a variable is
initialized the first time control passes through its declaration; such a variable is considered initialized upon
the completion of its initialization. If the initialization exits by throwing an exception, the initialization
is not complete, so it will be tried again the next time control enters the declaration. If control enters
the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for
completion of the initialization.
In earlier standards and in visual c++, you can avoid concurrency issues by making sure that log is called in at least one constructor that is invoked during static initialization (which happens before main program can spawn any threads).