p99_tss.h

Go to the documentation of this file.

/* This may look like nonsense, but it really is -*- mode: C; coding: utf-8 -*- */
/*                                                                              */
/* Except for parts copied from previous work and as explicitly stated below,   */
/* the authors and copyright holders for this work are as follows:              */
/* (C) copyright  2012-2014 Jens Gustedt, INRIA, France                         */
/* (C) copyright  2012 William Morris                                           */
/*                                                                              */
/* This file is free software; it is part of the P99 project.                   */
/*                                                                              */
/* Licensed under the Apache License, Version 2.0 (the "License");              */
/* you may not use this file except in compliance with the License.             */
/* You may obtain a copy of the License at                                      */
/*                                                                              */
/*     http://www.apache.org/licenses/LICENSE-2.0                               */
/*                                                                              */
/* Unless required by applicable law or agreed to in writing, software          */
/* distributed under the License is distributed on an "AS IS" BASIS,            */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.     */
/* See the License for the specific language governing permissions and          */
/* limitations under the License.                                               */
/*                                                                              */
#ifndef P99_TSS_H
#define P99_TSS_H 1
 
#include <unistd.h>
#include <sys/time.h>
#include <pthread.h>
 
#include "p99_defarg.h"
#include "p99_atomic.h"
 
#if !p99_has_feature(threads_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_WARN_UNUSED_RESULT
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_WARN_UNUSED_RESULT
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;
}
 
 
#endif
 
struct p99_tss {
  tss_t p00_val;
  tss_dtor_t p99_dtor;
  bool volatile p00_done;
  atomic_flag p00_flg;
};
 
typedef struct p99_tss p99_tss;
 
p99_inline
p99_tss* p99_tss_init(p99_tss* p00_el, tss_dtor_t p00_f) {
  if (p00_el) {
    *p00_el = (p99_tss) { .p99_dtor = p00_f, };
    atomic_flag_clear_explicit(&p00_el->p00_flg, memory_order_release);
  }
  return p00_el;
}
 
/* 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_tss_init(p99_tss * p00_key) {
  if (P99_UNLIKELY(!p00_key->p00_done)) {
    P99_SPIN_EXCLUDE(&p00_key->p00_flg) {
      if (!p00_key->p00_done) {
        int p00_ret = tss_create(&P99_ENCP(p00_key), p00_key->p99_dtor);
        if (p00_ret) {
          errno = p00_ret;
          perror("can't create thread specific key");
          abort();
        }
        p00_key->p00_done = true;
      }
    }
  }
}
 
p99_inline
void p99_tss_delete(p99_tss * p00_key) {
  p00_tss_init(p00_key);
  tss_delete(P99_ENCP(p00_key));
  memcpy(p00_key, &P99_LVAL(p99_tss const, .p00_done = false), sizeof *p00_key);
}
 
p99_inline
void* p99_tss_get(p99_tss * p00_key) {
  p00_tss_init(p00_key);
  return tss_get(P99_ENCP(p00_key));
}
 
P99_DEFARG_DOCU(p99_tss_set)
p99_inline
P99_WARN_UNUSED_RESULT
int p99_tss_set(p99_tss * p00_key, void *p00_val) {
  int p00_ret = thrd_success;
  void * p00_vol = p99_tss_get(p00_key);
  if (p00_val != p00_vol) {
    p00_ret = tss_set(P99_ENCP(p00_key), p00_val);
    if (p00_ret == thrd_success && p00_vol && p00_key->p99_dtor) {
      p00_key->p99_dtor(p00_vol);
    }
  }
  return p00_ret;
}
 
#ifndef P00_DOXYGEN
inline
P99_PROTOTYPE(int, p99_tss_set, p99_tss*, void *);
#define p99_tss_set(...) P99_CALL_DEFARG(p99_tss_set, 2, __VA_ARGS__)
#endif
 
#define p99_tss_set_defarg_1() (0)
 
 
P00_DOCUMENT_IDENTIFIER_ARGUMENT(P99_TSS_DECLARE_LOCAL, 1)
#ifdef P00_DOXYGEN
# define P99_TSS_DECLARE_LOCAL(T, NAME, DTOR)                  \
               \
p99_tss NAME
#else
# define P99_TSS_DECLARE_LOCAL(...)                            \
P99_IF_LT(P99_NARG(__VA_ARGS__), 3)                            \
(P00_TSS_DECLARE_LOCAL(__VA_ARGS__, (free)))                   \
(P00_TSS_DECLARE_LOCAL(__VA_ARGS__))
 
#define P00_TSS_DECLARE_LOCAL(T, NAME, DTOR)                   \
P99_WEAK(NAME)                                                 \
P00_TSS_DECLARE_LOCAL3(NAME, T, DTOR);                         \
P00_TSS_DEFINE_LOCAL3(NAME, T, DTOR)
 
# define P99_TSS_DECLARE_LOCAL_EXTERN(...)                     \
P99_IF_LT(P99_NARG(__VA_ARGS__), 3)                            \
(P00_TSS_DECLARE_LOCAL_EXTERN(__VA_ARGS__, (free)))            \
(P00_TSS_DECLARE_LOCAL_EXTERN(__VA_ARGS__))
 
#define P00_TSS_DECLARE_LOCAL_EXTERN(T, NAME, DTOR)            \
extern                                                         \
P00_TSS_DECLARE_LOCAL3(NAME, T, DTOR)
 
# define P99_TSS_DEFINE_LOCAL(...)                             \
P99_IF_LT(P99_NARG(__VA_ARGS__), 3)                            \
(P00_TSS_DEFINE_LOCAL(__VA_ARGS__, (free)))                    \
(P00_TSS_DEFINE_LOCAL(__VA_ARGS__))
 
#define P00_TSS_DEFINE_LOCAL(T, NAME, DTOR)                    \
P00_TSS_DEFINE_LOCAL3(NAME, T, DTOR)
 
 
#endif
 
 
#define P00_TSS_DECLARE_LOCAL3(NAME, T, DTOR)                  \
               \
p99_tss NAME;                                                  \
typedef T P99_PASTE3(p00_, NAME, _type)
 
#define P00_TSS_DEFINE_LOCAL3(NAME, T, DTOR)                   \
p99_tss NAME = { .p99_dtor = (DTOR), }
 
 
#define P99_TSS_LOCAL(NAME) (*(P99_PASTE3(p00_, NAME, _type)*)p99_tss_get_alloc(&(NAME), sizeof(P99_PASTE3(p00_, NAME, _type))))
 
 
p99_inline
void* p99_tss_get_alloc(p99_tss * p00_key, size_t p00_size) {
  void * p00_ret = p99_tss_get(p00_key);
  if (P99_UNLIKELY(!p00_ret))
    if (p00_size) {
      p00_ret = calloc(1, p00_size);
      if (p99_tss_set(p00_key, p00_ret) != thrd_success) {
        free(p00_ret);
        p00_ret = 0;
      }
    }
  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_DECLARE_THREAD_LOCAL_EXTERN(T, NAME)               \
extern                                                         \
thread_local T NAME
 
#define P99_DEFINE_THREAD_LOCAL(T, NAME)                       \
thread_local T NAME
 
 
#define P99_THREAD_LOCAL(NAME) (NAME)
 
#else
 
#define P99_DECLARE_THREAD_LOCAL P99_TSS_DECLARE_LOCAL
 
#define P99_DECLARE_THREAD_LOCAL_EXTERN P99_TSS_DECLARE_LOCAL_EXTERN
 
#define P99_DEFINE_THREAD_LOCAL P99_TSS_DEFINE_LOCAL
 
#define P99_THREAD_LOCAL P99_TSS_LOCAL
#endif
 
 
#endif