thread-local-storage

I'm dealing with some C++ code that has an optimised version that uses inline assembly. The optimised version is exhibiting behaviour that is not thread safe, which can be traced to 3 global variables that are accessed extensively from inside the assembly. __attribute__ ((aligned (16))) unsigned int SHAVITE_MESS[16]; __attribute__ ((aligned (16))) thread_local unsigned char SHAVITE_PTXT[8*4]; __attribute__ ((aligned (16))) unsigned int SHAVITE_CNTS[4] = {0,0,0,0}; ... asm ("movaps xmm0, SHAVITE_PTXT[rip]"); asm ("movaps xmm1, SHAVITE_PTXT[rip+16]"); asm ("movaps xmm3, SHAVITE_CNTS[rip]"); asm

The ELF Handling For Thread-Local Storage document gives assembly sequences for the various models (local exec/initial exec/general dynamic) for various architectures. But not ARM -- is there anywhere I can see such code sequences for ARM? I'm working on a compiler and want to generate code that will operate properly with the platform linkers (both program and dynamic). For clarity, let's assume an ARMv7 CPU and a pretty new kernel and glibc (say 3.13+ / 2.19+), but I'd also be interested in what has to change for older hw/sw if that's easy to explain. I don't exactly understand what you want.

This program: #include <iostream> struct Foo { Foo() { std::cout << "Foo()\n"; } ~Foo() { std::cout << "~Foo()\n"; } }; struct Bar { Bar() { std::cout << "Bar()\n"; } ~Bar() { std::cout << "~Bar()\n"; thread_local Foo foo; } }; Bar bar; int main() { return 0; } Prints Bar() ~Bar() Foo() for me (GCC 6.1, Linux, x86-64). ~Foo() is never called. Is that the expected behaviour? ecatmur The Standard does not cover this case; the strictest reading would be that it is legal to initialize a thread_local in the destructor of an object with static storage duration, but it is illegal to allow the program

Assume there is some not-reentrant function that uses global variables: int i; void foo(void){ /* modify i */ } And then, I want to use this function in multithreaded code, so I can change code this way: void foo(int i){ /* modify i */ } or, by using gcc __thread specifier, more simplier: __thread int i; void foo(void){ /* modify i */ } Advantages of the last is that I don't need to change another code which call foo(). My questions is, how much overhead of thread-local storage is? Is there some not obvious issues with TLS? Is there some overhead if I will modify TLS`ed variable via separate

Possible Duplicate: C++11 thread_local in gcc - alternatives Is there any way to fully emulate thread_local using GCC's __thread? I wanted to use the c++11 thread_local to create and use thread_local variable but as it is not yet supported by gcc, I am using gcc specific __thread . The way I declared the variable is myClass { public: static __thread int64_t m_minInt; }; __thread int64_t myClass::m_minInt = 100; When I compile it, I get an error like error: ‘myClass::minInt’ is thread-local and so cannot be dynamically initialized How to properly do it? PS: gcc version: 4.6.3 You need to use