p99_threads_posix.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  2011-2014, 2018 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_THREADS_POSIX_H
#define P99_THREADS_POSIX_H 1
 
#define P99_ONCE_FLAG_INIT { { 0 } }
 
#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_cond_t, cnd_t);
 
typedef struct p00_thrd p00_thrd;
P99_ENC_DECLARE(struct p00_thrd*, thrd_t);
 
P99_ENC_DECLARE(pthread_mutex_t, mtx_t);
 
typedef int (*thrd_start_t)(void*);
 
 
 
struct p00_thrd {
  atomic_flag p00_detached;
  unsigned p00_foreign;
  int p00_ret;
  pthread_t p00_id;
  union {
    struct {
      thrd_start_t p00_func;
      void *p00_arg;
    } p00_init;
    jmp_buf p00_jmp;
  } p00_ovrl;
};
 
enum mtx_type {
  mtx_plain = 0,
 
  mtx_recursive = 1,
 
  mtx_timed = 2,
 
  mtx_normal = 4,
 
  mtx_errorcheck = 8,
 
  mtx_extras = (mtx_normal | mtx_errorcheck | mtx_recursive),
};
 
 
// 7.26.2 Initialization functions
 
p99_inline
void thrd_yield(void) {
  if (P99_UNLIKELY(sched_yield())) errno = 0;
}
 
/* Tentative definitions for global variables. This has the advantage
   that this defines weak symbols and we avoid to have to create a
   specific library. */
P99_DECLARE_THREAD_LOCAL(p00_thrd *, p00_thrd_local);
 
#define P00_THRD_LOCAL P99_THREAD_LOCAL(p00_thrd_local)
 
P99_WEAK(p00_foreign_nb)
_Atomic(size_t) p00_foreign_nb;
 
P99_WEAK(p00_foreign_tab)
p00_thrd ** p00_foreign_tab;
 
P99_WEAK(p00_foreign_cleanup)
void p00_foreign_cleanup(void) {
  size_t p00_foreign = atomic_load_explicit(&p00_foreign_nb, memory_order_consume);
  p00_thrd ** p00_thrd = p00_foreign_tab;
  p00_foreign_tab = 0;
  if (p00_foreign) {
    /* Ensure that all data is synchronized with all threads, not only
       with the last one that changed p00_foreign_nb. */
    atomic_thread_fence(memory_order_seq_cst);
    for (size_t p00_i = 0; p00_i < p00_foreign; ++p00_i) {
      if (!pthread_equal(p00_thrd[p00_i]->p00_id, pthread_self()))
        fputs("found foreign thread\n", stderr);
      free(p00_thrd[p00_i]);
    }
  }
  free(p00_thrd);
}
 
p99_inline
thrd_t thrd_current(void) {
  p00_thrd * p00_loc = P00_THRD_LOCAL;
  if (P99_UNLIKELY(!p00_loc)) {
    size_t p00_nb = atomic_fetch_add_explicit(&p00_foreign_nb, 1, memory_order_acq_rel);
    if (!p00_nb) atexit(p00_foreign_cleanup);
    if ((p00_nb^(p00_nb-1)) == (p00_nb+(p00_nb-1))) {
      p00_foreign_tab = realloc(p00_foreign_tab, sizeof(p00_thrd*[2*(p00_nb+1)]));
    }
    p00_loc = malloc(sizeof *p00_loc);
    p00_foreign_tab[p00_nb] = p00_loc;
    *p00_loc = (p00_thrd) {
      .p00_id = pthread_self(),
      .p00_foreign = p00_nb + 1,
    };
    P00_THRD_LOCAL = p00_loc;
    if (p00_nb) {
      union {
        unsigned char raw[16];
        pthread_t thrd;
        unsigned long long ull;
      } id = { .raw = { 0 } };
      id.thrd = p00_loc->p00_id;
      fprintf(stderr, "foreign thread %llu is %zu\n", id.ull, p00_nb + 1);
    }
  }
  return (thrd_t)P99_ENC_INIT(p00_loc);
}
 
P99_CONST_FUNCTION
p99_inline
int thrd_equal(thrd_t p00_thr0, thrd_t p00_thr1) {
  return P99_ENC(p00_thr0) ==  P99_ENC(p00_thr1);
}
 
 
// 7.26.3 Condition variable functions
 
P99_WARN_UNUSED_RESULT
p99_inline
int cnd_broadcast(cnd_t *p00_cond) {
  return pthread_cond_broadcast(&P99_ENCP(p00_cond)) ? thrd_error : thrd_success;
}
 
p99_inline
void cnd_destroy(cnd_t *p00_cond) {
  (void)pthread_cond_destroy(&P99_ENCP(p00_cond));
}
 
P99_WARN_UNUSED_RESULT
p99_inline
int cnd_init(cnd_t *p00_cond) {
  int p00_ret = pthread_cond_init(&P99_ENCP(p00_cond), 0);
  switch (p00_ret) {
  case 0:         return thrd_success;
  case ENOMEM:    return thrd_nomem;
  default:        return thrd_error;
  }
}
 
P99_WARN_UNUSED_RESULT
p99_inline
int cnd_signal(cnd_t *p00_cond) {
  return pthread_cond_signal(&P99_ENCP(p00_cond)) ? thrd_error : thrd_success;
}
 
#if (POSIX_TIMEOUTS > 0) || !defined(POSIX_TIMEOUTS)
 
P99_WARN_UNUSED_RESULT
p99_inline
int cnd_timedwait(cnd_t *restrict p00_cond, mtx_t *restrict p00_mtx, const struct timespec *restrict p00_ts) {
  int p00_ret = pthread_cond_timedwait(&P99_ENCP(p00_cond), &P99_ENCP(p00_mtx), p00_ts);
  switch (p00_ret) {
  case 0:         return thrd_success;
  case ETIMEDOUT: return thrd_timedout;
  default:        return thrd_error;
  };
}
 
#endif
 
P99_WARN_UNUSED_RESULT
p99_inline
int cnd_wait(cnd_t *p00_cond, mtx_t *p00_mtx) {
  return pthread_cond_wait(&P99_ENCP(p00_cond), &P99_ENCP(p00_mtx)) ? thrd_error : thrd_success;
}
 
// 7.26.4 Mutex functions
 
p99_inline
void mtx_destroy(mtx_t *p00_mtx) {
  (void)pthread_mutex_destroy(&P99_ENCP(p00_mtx));
}
 
P99_WARN_UNUSED_RESULT
p99_inline
int mtx_init(mtx_t *p00_mtx, int p00_type) {
  if (p00_type & mtx_extras) {
    pthread_mutexattr_t p00_attr;
    int p00_ret = pthread_mutexattr_init(&p00_attr);
    if (P99_UNLIKELY(p00_ret)) return thrd_error;
    switch (p00_type & mtx_extras) {
    case mtx_normal: p00_ret = PTHREAD_MUTEX_NORMAL; break;
    case mtx_errorcheck: p00_ret = PTHREAD_MUTEX_ERRORCHECK; break;
    case mtx_recursive: p00_ret = PTHREAD_MUTEX_RECURSIVE; break;
    default: return thrd_error;
    }
    p00_ret = pthread_mutexattr_settype(&p00_attr, p00_ret);
    if (P99_UNLIKELY(p00_ret)) return thrd_error;
    p00_ret = pthread_mutex_init(&P99_ENCP(p00_mtx), &p00_attr);
    if (P99_UNLIKELY(p00_ret)) return thrd_error;
  } else {
    int p00_ret = pthread_mutex_init(&P99_ENCP(p00_mtx), 0);
    if (P99_UNLIKELY(p00_ret)) return thrd_error;
  }
  return thrd_success;
}
 
P99_WARN_UNUSED_RESULT
p99_inline
int mtx_lock(mtx_t *p00_mtx) {
  return pthread_mutex_lock(&P99_ENCP(p00_mtx)) ? thrd_error : thrd_success;
}
 
#if (POSIX_TIMEOUTS > 0) || !defined(POSIX_TIMEOUTS)
 
P99_WARN_UNUSED_RESULT
p99_inline
int mtx_timedlock(mtx_t *restrict p00_mtx, const struct timespec *restrict p00_ts) {
  int p00_ret = pthread_mutex_timedlock(&P99_ENCP(p00_mtx), p00_ts);
  switch (p00_ret) {
  case 0:         return thrd_success;
  case ETIMEDOUT: return thrd_timedout;
  default:        return thrd_error;
  };
}
 
#endif
 
p99_inline
int mtx_trylock(mtx_t *p00_mtx) {
  int p00_ret = pthread_mutex_trylock(&P99_ENCP(p00_mtx));
  switch (p00_ret) {
  case 0:         return thrd_success;
  case EBUSY:     return thrd_busy;
  default:        return thrd_error;
  };
}
 
P99_WARN_UNUSED_RESULT
p99_inline
int mtx_unlock(mtx_t *p00_mtx) {
  return pthread_mutex_unlock(&P99_ENCP(p00_mtx)) ? thrd_error : thrd_success;
}
 
 
P99_SETJMP_INLINE(p00_thrd_create)
void * p00_thrd_create(void* p00_context);
 
P99_WARN_UNUSED_RESULT
p99_inline
int thrd_create(thrd_t *p00_thr, thrd_start_t p00_func, void *p00_arg) {
  p00_thrd * p00_cntxt = malloc(sizeof *p00_cntxt);
  if (!p00_cntxt) return thrd_nomem;
  *p00_cntxt = (p00_thrd const) {
    .p00_ovrl = {
      .p00_init = {
        .p00_func = p00_func,
        .p00_arg = p00_arg,
      },
    },
    .p00_detached = ATOMIC_FLAG_INIT,
  };
  int p00_ret = pthread_create(&p00_cntxt->p00_id, 0, p00_thrd_create, p00_cntxt);
  if (P99_UNLIKELY(p00_ret)) {
    free(p00_cntxt);
    switch (p00_ret) {
    case ENOMEM:    return thrd_nomem;
    default:        return thrd_error;
    };
  } else {
    P99_ENCP(p00_thr) = p00_cntxt;
    return thrd_success;
  }
}
 
P99_WARN_UNUSED_RESULT
p99_inline
int thrd_detach(thrd_t p00_thr) {
  /* The thread is not yet detached so its pthread id is still
     valid. If it already has finished, this will just free the
     resources that pthread holds for it. */
  int p00_ret = pthread_detach(P99_ENC(p00_thr)->p00_id) ? thrd_error : thrd_success;
  if (atomic_flag_test_and_set_explicit(&P99_ENC(p00_thr)->p00_detached, memory_order_acq_rel)) {
    /* The thread has already finished. Free the state, since nobody
       will join it, anyhow. */
    free(P99_ENC(p00_thr));
    return thrd_success;
  } else {
    return p00_ret;
  }
}
 
#ifdef P00_DOXYGEN
 
p99_inline void thrd_exit(int p00_res);
#else
p99_inline
_Noreturn
void thrd_exit(int p00_res) {
  p00_thrd * p00_cntxt = P00_THRD_LOCAL;
  if (P99_LIKELY(p00_cntxt)) {
    if (!p00_cntxt->p00_foreign) {
      p00_cntxt->p00_ret = p00_res;
      longjmp(p00_cntxt->p00_ovrl.p00_jmp, 1);
    } else {
      free(p00_cntxt);
      P00_THRD_LOCAL = 0;
    }
  }
  /* should only be reached by threads that where created directly
     with pthreads, e.g main */
  fprintf(stderr,
          "P99: We are exiting a foreign thread (main?) with error code %d\n"
          "P99: There is no consistent way we can transmit that code to the environment\n",
          p00_res);
  pthread_exit(0);
}
#endif
 
#if defined(P99_INTERCEPT_MAIN) || defined(P00_DOXYGEN)
 
int p99_threads_main(int, char*[]);
 
struct p00_threads_main_arg {
  int p00_argc;
  char**p00_argv;
};
 
P99_WEAK(p00_threads_main)
int p00_threads_main(void* p00_arg) {
  struct p00_threads_main_arg *p00_a = p00_arg;
  int p00_argc = p00_a->p00_argc;
  char**p00_argv = p00_a->p00_argv;
  free(p00_arg);
  /* To have the same behavior as prescribed by the standard, we have
     to exit the whole process if main returns. The only thing that we
     wouldn't be able to emulate is the fact that leaving main without
     return statement is permitted. But the compiler should warn the
     user about that. */
  int p00_ret = p99_threads_main(p00_argc, p00_argv);
  fprintf(stderr, "exiting main thread with code %d", p00_ret);
  fflush(0);
  exit(p00_ret);
}
 
P99_MAIN_INTERCEPT(p99_threads_main) {
  thrd_t id = P99_INIT;
  struct p00_threads_main_arg * p00_arg = malloc(sizeof *p00_arg);
  *p00_arg = (struct p00_threads_main_arg) {
    .p00_argc = *p00_argc,
    .p00_argv = *p00_argv,
  };
  thrd_create(&id, p00_threads_main, p00_arg);
  thrd_detach(id);
  pthread_exit(0);
}
 
#undef main
#define main p99_threads_main
#endif
 
 
 
P99_WARN_UNUSED_RESULT
p99_inline
int thrd_join(thrd_t p00_thr, int *p00_res) {
  void *p00_res0;
  if (P99_UNLIKELY(pthread_join(P99_ENC(p00_thr)->p00_id, &p00_res0))) return thrd_error;
  if (p00_res) *p00_res = P99_ENC(p00_thr)->p00_ret;
  free(P99_ENC(p00_thr));
  return thrd_success;
}
 
P99_WARN_UNUSED_RESULT
p99_inline
int thrd_sleep(const struct timespec *p00_duration, struct timespec *p00_remaining) {
  errno = 0;
  int p00_ret = nanosleep(p00_duration, p00_remaining);
  if (p00_ret) {
    p00_ret = (errno == EINTR) ? thrd_intr : thrd_error;
    errno = 0;
    return p00_ret;
  } else return thrd_success;
}
 
/*
  This is static inline because of the following message from gcc:
 
   sorry, unimplemented: function ‘p00_thrd_create’ can never be inlined because it uses setjmp
*/
P99_WARN_UNUSED_RESULT
P99_SETJMP_INLINE(p00_thrd_create)
void * p00_thrd_create(void* p00_context) {
  p00_thrd * p00_cntxt = p00_context;
  P00_THRD_LOCAL = p00_cntxt;
  {
    thrd_start_t p00_func = p00_cntxt->p00_ovrl.p00_init.p00_func;
    void * p00_arg = p00_cntxt->p00_ovrl.p00_init.p00_arg;
    if (!setjmp(p00_cntxt->p00_ovrl.p00_jmp)) {
      p00_cntxt->p00_ret = p00_func(p00_arg);
    }
    if (atomic_flag_test_and_set_explicit(&p00_cntxt->p00_detached, memory_order_acq_rel)) {
      free(p00_cntxt);
    }
  }
  P00_THRD_LOCAL = 0;
  return 0;
}
 
 
#endif /* P99_THREADS_POSIX_H */