p99_tss.h

Go to the documentation of this file.

/* This may look like nonsense, but it really is -*- mode: C -*-             */
/*                                                                           */
/* Except of parts copied from previous work and as explicitly stated below, */
/* the author and copyright holder for this work is                          */
/* (C) copyright  2012 Jens Gustedt, INRIA, France                           */
/*                                                                           */
/* This file is free software; it is part of the P99 project.                */
/* You can redistribute it and/or modify it under the terms of the QPL as    */
/* given in the file LICENSE. It is distributed without any warranty;        */
/* without even the implied warranty of merchantability or fitness for a     */
/* particular purpose.                                                       */
/*                                                                           */
#ifndef P99_TSS_H
#define P99_TSS_H 1

#define _XOPEN_SOURCE 600
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include <pthread.h>
#if defined(__GNUC__) || defined(P00_DOXYGEN)
# include "p99_atomic.h"
#endif

#include "p99_compiler.h"

#ifndef PTHREAD_DESTRUCTOR_ITERATIONS
# warning "definition of PTHREAD_DESTRUCTOR_ITERATIONS is missing"

# define TSS_DTOR_ITERATIONS 1
#else
# define TSS_DTOR_ITERATIONS PTHREAD_DESTRUCTOR_ITERATIONS
#endif

P99_ENC_DECLARE(pthread_key_t, tss_t);

typedef void (*tss_dtor_t)(void*);

enum thrd_status {
  thrd_timedout = ETIMEDOUT,
  thrd_success = 0,
  thrd_busy = EBUSY,
  thrd_error = INT_MIN,
  thrd_nomem = ENOMEM,
  thrd_intr = -1
};

p99_inline
int tss_create(tss_t *p00_key, tss_dtor_t dtor) {
  return pthread_key_create(&P99_ENCP(p00_key), dtor) ? thrd_error : thrd_success;
}

p99_inline
void tss_delete(tss_t p00_key) {
  (void)pthread_key_delete(P99_ENC(p00_key));
}

p99_inline
void *tss_get(tss_t p00_key) {
  return pthread_getspecific(P99_ENC(p00_key));
}

p99_inline
int tss_set(tss_t p00_key, void *p00_val) {
  return pthread_setspecific(P99_ENC(p00_key), p00_val) ? thrd_error : thrd_success;
}

struct p99_tss {
  tss_t p00_val;
  tss_dtor_t p00_func;
  bool volatile p00_done;
  atomic_flag p00_flg;
};

typedef struct p99_tss p99_tss;

/* This is an implementation to bootstrap the thread specific
   code. Once initialization functionalities that are better suited
   for application code are defined elsewhere. */
p99_inline
void p00_key_once_init(p99_tss * p00_key) {
  if (!p00_key->p00_done) {
    P99_SPIN_EXCLUDE(&p00_key->p00_flg) {
      if (!p00_key->p00_done) {
        if (!p00_key->p00_func) p00_key->p00_func = free;
        int p00_ret = tss_create(&P99_ENCP(p00_key), p00_key->p00_func);
        if (p00_ret) {
          errno = p00_ret;
          perror("can't create thread specific key");
          abort();
        }
        p00_key->p00_done = true;
      }
    }
  }
}

p99_inline
void* p00_thread_local_get(p99_tss * p00_key, size_t p00_size) {
  p00_key_once_init(p00_key);
  void * p00_ret = tss_get(P99_ENCP(p00_key));
  if (P99_UNLIKELY(!p00_ret)) {
    p00_ret = calloc(1, p00_size);
    tss_set(P99_ENCP(p00_key), p00_ret);
  }
  return p00_ret;
}

#if defined(thread_local) && !defined(P99_EMULATE_THREAD_LOCAL) && !defined(P00_DOXYGEN)

#define P99_DECLARE_THREAD_LOCAL(T, NAME)                      \
P99_WEAK(NAME)                                                 \
thread_local T NAME

#define P99_THREAD_LOCAL(NAME) (NAME)

#else

#define P99_DECLARE_THREAD_LOCAL(T, NAME)                      \
            \
P99_WEAK(NAME)                                                 \
p99_tss NAME;                                                  \
typedef T P99_PASTE3(p00_, NAME, _type)

#define P99_THREAD_LOCAL(NAME) (*(P99_PASTE3(p00_, NAME, _type)*)p00_thread_local_get(&(NAME), sizeof(P99_PASTE3(p00_, NAME, _type))))

#endif


#endif