Performance loss in C++0x and static local variables?

What is a realistic performance loss due to the fact that in C++0x all other threads shall wait in a case like this:

string& program_name() {
  static string instance = "Parallel Pi";
  return instance;
}

Lets assume the optimal scenario: The programmer was very careful that even with 100 threads only the main thread calls the function program_name, all the other 99 worker threads are busy doing useful stuff, which does not involve calling this "critical" function.

I quote from the new C++0x-Std § 6.7.(4) stmt.decl

...such an object is initialized the first time control passes through its declaration... If control enters the declaration concurrently while the object is being initialized, the concurrent execution shall wait for completion of the initialization...

What is a realistic overhead that a real-world compiler is needed to impose on me to ensure that that static initialization is done as required by the standard.

• Is a lock/mutex required? I assume they are expensive, even when not really needed?
• If they are expensive, will this 开发者_高级运维be done by less expensive mechanisms?

edit: added string...

---

If control enters the declaration concurrently while the object is being initialized, the concurrent execution shall wait for completion of the initialization...

I think this is reasonable and very normal thing to do in concurrent programming. Anyway, this statement doesn't say that all other threads must wait for this initialization. They have to wait in case they need to access the initializing object.

Is a lock/mutex required? I assume they are expensive, even when not really needed?

Could be. Mutex / lock aren't that expensive actually, they're expensive only when the locked code fragment needs to be accessed frequently by many or even all threads.

If they are expensive, will this be done by less expensive mechanisms?

There are also another non-lock based solutions AFAIK.

---

If you were really concerned about the price of the lock, you could simply call the function before you started your worker threads, which would initialise the static. If you call it after the threads start, either you or the compiler has got to arrange for locking of some sort, so there is no real extra overhead.