Chris M. Thomasson
10/30/2008 11:48:00 PM
Here is what I am playing around with now:
_________________________________________________________________
/* Simple TSD Object
______________________________________________________________*/
#include <pthread.h>
#include <cstdio>
#if defined(_MSC_VER)
# define DECLSPEC_CDECL __cdecl
#elif defined(__GNUC__)
# define DECLSPEC_CDECL __attribute__((cdecl))
#else
# error MSVC or GCC REQUIRED!!!!! ;^(...
#endif
template<typename T>
class tsd {
pthread_key_t m_key;
static void DECLSPEC_CDECL tsd_dtor(void* state) {
delete reinterpret_cast<T*>(state);
}
public:
struct main_guard {
tsd& m_tsd;
main_guard(tsd& tsd_) : m_tsd(tsd_) {
}
~main_guard() {
m_tsd.clear();
}
};
tsd() {
pthread_key_create(&m_key, tsd_dtor);
}
~tsd() {
pthread_key_delete(m_key);
std::printf("(%p)->tsd<T>::~tsd()\nhit <ENTER> to continue...",
(void*)this);
std::fflush(stdout);
std::getchar();
}
T& instance() const {
T* obj = reinterpret_cast<T*>(pthread_getspecific(m_key));
if (! obj) {
obj = new T();
pthread_setspecific(m_key, obj);
}
return *obj;
}
void clear() {
delete reinterpret_cast<T*>(pthread_getspecific(m_key));
pthread_setspecific(m_key, NULL);
}
};
/* Simple Usage Example
______________________________________________________________*/
#include <cassert>
static tsd<struct foo> g_foo_tsd;
static tsd<struct foo2> g_foo2_tsd;
static tsd<struct foo3> g_foo3_tsd;
struct foo {
foo() {
std::printf("(%p)->foo::foo()\n", (void*)this);
}
~foo() {
std::printf("(%p)->foo::~foo()\n", (void*)this);
}
};
struct foo2 {
foo2() {
std::printf("(%p)->foo2::foo2()\n", (void*)this);
}
~foo2() {
std::printf("(%p)->foo2::~foo2()\n", (void*)this);
}
};
struct foo3 {
foo3() {
std::printf("(%p)->foo3::foo3()\n", (void*)this);
}
~foo3() {
std::printf("(%p)->foo3::~foo3()\n", (void*)this);
}
};
extern "C" void* thread_entry(void* state) {
{
foo& f1 = g_foo_tsd.instance();
foo& f2 = g_foo_tsd.instance();
foo& f3 = g_foo_tsd.instance();
assert(&f1 == &f2 && &f2 == &f3);
}
{
foo2& f1 = g_foo2_tsd.instance();
foo2& f2 = g_foo2_tsd.instance();
foo2& f3 = g_foo2_tsd.instance();
assert(&f1 == &f2 && &f2 == &f3);
}
{
foo3& f1 = g_foo3_tsd.instance();
foo3& f2 = g_foo3_tsd.instance();
foo3& f3 = g_foo3_tsd.instance();
assert(&f1 == &f2 && &f2 == &f3);
}
return 0;
}
int main(void) {
{
tsd<foo>::main_guard tsd_main_guard(g_foo_tsd);
tsd<foo2>::main_guard tsd_main_guard2(g_foo2_tsd);
tsd<foo3>::main_guard tsd_main_guard3(g_foo3_tsd);
pthread_t tid[2];
pthread_create(&tid[0], NULL, thread_entry, NULL);
pthread_create(&tid[1], NULL, thread_entry, NULL);
{
foo& f1 = g_foo_tsd.instance();
foo& f2 = g_foo_tsd.instance();
foo& f3 = g_foo_tsd.instance();
assert(&f1 == &f2 && &f2 == &f3);
}
{
foo2& f1 = g_foo2_tsd.instance();
foo2& f2 = g_foo2_tsd.instance();
foo2& f3 = g_foo2_tsd.instance();
assert(&f1 == &f2 && &f2 == &f3);
}
{
foo3& f1 = g_foo3_tsd.instance();
foo3& f2 = g_foo3_tsd.instance();
foo3& f3 = g_foo3_tsd.instance();
assert(&f1 == &f2 && &f2 == &f3);
}
pthread_join(tid[1], NULL);
pthread_join(tid[0], NULL);
}
std::puts("\n\n\n__________________\nhit <ENTER> to exit...");
std::fflush(stdout);
std::getchar();
return 0;
}
_________________________________________________________________
As you can see it uses compiler specific extensions in order to ensure the
procedure `tsd<T>::tsd_dtor()' has C linkage. I am doing this in order to
get around having to dynamically create a base-class, helper object and a
free extern "C" function. I can't really see any way around having to go
through that mess without resorting to compiler extensions. Humm, if I were
to use a free function, I think I would have to do something ugly like:
_________________________________________________________________
/* Simple TSD Object
______________________________________________________________*/
#include <pthread.h>
#include <cstdio>
struct tsd_object_base {
virtual ~tsd_object_base() = 0;
};
tsd_object_base::~tsd_object_base() {}
extern "C" void tsd_object_dtor(void* state) {
delete reinterpret_cast<tsd_object_base*>(state);
}
template<typename T>
class tsd {
struct tsd_object : public tsd_object_base {
T m_object;
tsd_object() : m_object() {}
};
pthread_key_t m_key;
public:
struct main_guard {
tsd& m_tsd;
main_guard(tsd& tsd_) : m_tsd(tsd_) {
}
~main_guard() {
m_tsd.clear();
}
};
tsd() {
pthread_key_create(&m_key, tsd_object_dtor);
}
~tsd() {
pthread_key_delete(m_key);
std::printf("(%p)->tsd<T>::~tsd()\nhit <ENTER> to continue...",
(void*)this);
std::fflush(stdout);
std::getchar();
}
T& instance() const {
tsd_object* obj =
reinterpret_cast<tsd_object*>(pthread_getspecific(m_key));
if (! obj) {
obj = new tsd_object();
pthread_setspecific(m_key, obj);
}
return obj->m_object;
}
void clear() {
delete reinterpret_cast<tsd_object*>(pthread_getspecific(m_key));
pthread_setspecific(m_key, NULL);
}
};
// [...]
_________________________________________________________________
This works fine, but IMVHO, its kind of messy. However, it is standard wrt
POSIX rules, and a heck of a lot more portable. Is there any way to keep
maximum portability, yet remove the need for helper classes? I suppose I
could do two versions and #ifdef them if the compiler does not support the
extensions I am looking for... Humm... Need advise!
Thanks.