Cleanup for thread local storage?

["Stephen Spackman" <Stephen dot Spackman at quantum dot com>]

Hi, I'm afraid I don't know if this question is an advanced
head-scratcher or a newbie oversight of the "can't think of the right
search term" variety, but I'm getting nowhere. 

What is the intended cleanup mechanism for (compiler native) thread
local storage?

The compiler rejects the cleanup attribute on thread local variables,
presumably on the grounds that they are not dynamic (though I was
secretly hoping that, despite documentation to the contrary, some angel
would have put in the effort and it would 'just work', because in the
motivating sense, if not in implementation mechanism, TL statics *are*
dynamic - and at times I'm a pathetic optimist). The pthread cleanup
mechanism is more or less unworkable since it is stack-based and thus
out of step with TLS in both scope and time. The pthread thread specific
storage mechanism has cleanup handlers, but is not integrated AFAIK with
native TLS, and TLS is supposed to provide a better alternative. And at
this point I run out of ideas.

It's important because one of the things that TLS is nice for is
optimizations like per-thread task queues and free lists, but a
*reliable* mechanism is needed to release their contents on thread exit,
and it really *should* be bound to the variable declaration point
itself, or many of the benefits of TLS are lost.

Any guidance would be appreciated.

Thanks.

Stephen P Spackman


-----------------------------------------------------------
The information contained in this transmission may be 
confidential. Any disclosure, copying, or further 
distribution of confidential information is not permitted 
unless such privilege is explicitly granted in writing by 
Quantum Corporation. Furthermore, Quantum Corporation is not 
responsible for the proper and complete transmission of the 
substance of this communication or for any delay in its 
receipt.
------------------------------------------------------------