fcthread.c

Go to the documentation of this file.

/***********************************************************************
 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
***********************************************************************/
 
#ifdef HAVE_CONFIG_H
#include <fc_config.h>
#endif
 
/* utility */
#include "log.h"
#include "mem.h"
#include "support.h"
 
#include "fcthread.h"
 
static at_thread_exit_cb *ate_cb = nullptr;
 
/*******************************************************************/
bool register_at_thread_exit_callback(at_thread_exit_cb *cb)
{
  if (ate_cb != nullptr) {
    log_error("Trying to register multiple at_thread_exit callbacks.");
    log_error("That's not supported yet.");
 
    return FALSE;
  }
 
  ate_cb = cb;
 
  return TRUE;
}
 
/*******************************************************************/
static void at_thread_exit(void)
{
  if (ate_cb != nullptr) {
    ate_cb();
  }
}
 
#ifdef FREECIV_C11_THR
 
struct fc_thread_wrap_data {
  void *arg;
  void (*func)(void *arg);
};
 
/*******************************************************************/
static int fc_thread_wrapper(void *arg)
{
  struct fc_thread_wrap_data *data = (struct fc_thread_wrap_data *) arg;
 
  data->func(data->arg);
 
  free(data);
 
  at_thread_exit();
 
  return EXIT_SUCCESS;
}
 
/*******************************************************************/
int fc_thread_start(fc_thread *thread, void (*function) (void *arg),
                    void *arg)
{
  int ret;
 
  /* Freed by child thread once it's finished with data */
  struct fc_thread_wrap_data *data = fc_malloc(sizeof(*data));
 
  data->arg = arg;
  data->func = function;
 
  ret = thrd_create(thread, &fc_thread_wrapper, data);
 
  return ret != thrd_success;
}
 
/*******************************************************************/
void fc_thread_wait(fc_thread *thread)
{
  int *return_value = nullptr;
 
  thrd_join(*thread, return_value);
}
 
/*******************************************************************/
fc_thread_id fc_thread_self(void)
{
  return thrd_current();
}
 
/*******************************************************************/
bool fc_threads_equal(fc_thread_id thr1, fc_thread_id thr2)
{
  return thrd_equal(thr1, thr2);
}
 
/*******************************************************************/
void fc_mutex_init(fc_mutex *mutex)
{
  mtx_init(mutex, mtx_plain|mtx_recursive);
}
 
/*******************************************************************/
void fc_mutex_destroy(fc_mutex *mutex)
{
  mtx_destroy(mutex);
}
 
/*******************************************************************/
void fc_mutex_allocate(fc_mutex *mutex)
{
  mtx_lock(mutex);
}
 
/*******************************************************************/
void fc_mutex_release(fc_mutex *mutex)
{
  mtx_unlock(mutex);
}
 
/*******************************************************************/
void fc_thread_cond_init(fc_thread_cond *cond)
{
  cnd_init(cond);
}
 
/*******************************************************************/
void fc_thread_cond_destroy(fc_thread_cond *cond)
{
  cnd_destroy(cond);
}
 
/*******************************************************************/
void fc_thread_cond_wait(fc_thread_cond *cond, fc_mutex *mutex)
{
  cnd_wait(cond, mutex);
}
 
/*******************************************************************/
void fc_thread_cond_signal(fc_thread_cond *cond)
{
  cnd_signal(cond);
}
 
#elif defined(FREECIV_HAVE_PTHREAD)
 
struct fc_thread_wrap_data {
  void *arg;
  void (*func)(void *arg);
};
 
/*******************************************************************/
static void *fc_thread_wrapper(void *arg)
{
  struct fc_thread_wrap_data *data = (struct fc_thread_wrap_data *) arg;
 
  data->func(data->arg);
 
  free(data);
 
  at_thread_exit();
 
  return nullptr;
}
 
/*******************************************************************/
int fc_thread_start(fc_thread *thread, void (*function) (void *arg),
                    void *arg)
{
  int ret;
  pthread_attr_t attr;
 
  /* Freed by child thread once it's finished with data */
  struct fc_thread_wrap_data *data = fc_malloc(sizeof(*data));
 
  data->arg = arg;
  data->func = function;
 
  /* Explicitly set thread as joinable to maximize portability
     between pthread implementations */
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 
  ret = pthread_create(thread, &attr, &fc_thread_wrapper, data);
 
  pthread_attr_destroy(&attr);
 
  return ret;
}
 
/*******************************************************************/
void fc_thread_wait(fc_thread *thread)
{
  void **return_value = nullptr;
 
  pthread_join(*thread, return_value);
}
 
/*******************************************************************/
fc_thread_id fc_thread_self(void)
{
  return pthread_self();
}
 
/*******************************************************************/
bool fc_threads_equal(fc_thread_id thr1, fc_thread_id thr2)
{
  return pthread_equal(thr1, thr2);
}
 
/*******************************************************************/
void fc_mutex_init(fc_mutex *mutex)
{
  pthread_mutexattr_t attr;
 
  pthread_mutexattr_init(&attr);
  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 
  pthread_mutex_init(mutex, &attr);
 
  pthread_mutexattr_destroy(&attr);
}
 
/*******************************************************************/
void fc_mutex_destroy(fc_mutex *mutex)
{
  pthread_mutex_destroy(mutex);
}
 
/*******************************************************************/
void fc_mutex_allocate(fc_mutex *mutex)
{
  pthread_mutex_lock(mutex);
}
 
/*******************************************************************/
void fc_mutex_release(fc_mutex *mutex)
{
  pthread_mutex_unlock(mutex);
}
 
/*******************************************************************/
void fc_thread_cond_init(fc_thread_cond *cond)
{
  pthread_cond_init(cond, nullptr);
}
 
/*******************************************************************/
void fc_thread_cond_destroy(fc_thread_cond *cond)
{
  pthread_cond_destroy(cond);
}
 
/*******************************************************************/
void fc_thread_cond_wait(fc_thread_cond *cond, fc_mutex *mutex)
{
  pthread_cond_wait(cond, mutex);
}
 
/*******************************************************************/
void fc_thread_cond_signal(fc_thread_cond *cond)
{
  pthread_cond_signal(cond);
}
 
#elif defined(FREECIV_HAVE_WINTHREADS)
 
struct fc_thread_wrap_data {
  void *arg;
  void (*func)(void *arg);
};
 
/*******************************************************************/
static DWORD WINAPI fc_thread_wrapper(LPVOID arg)
{
  struct fc_thread_wrap_data *data = (struct fc_thread_wrap_data *) arg;
 
  data->func(data->arg);
 
  free(data);
 
  at_thread_exit();
 
  return 0;
}
 
/*******************************************************************/
int fc_thread_start(fc_thread *thread, void (*function) (void *arg), void *arg)
{
  /* Freed by child thread once it's finished with data */
  struct fc_thread_wrap_data *data = fc_malloc(sizeof(*data));
 
  data->arg = arg;
  data->func = function;
 
  *thread = CreateThread(nullptr, 0, &fc_thread_wrapper, data, 0, nullptr);
 
  if (*thread == nullptr) {
    return 1;
  }
 
  return 0;
}
 
/*******************************************************************/
void fc_thread_wait(fc_thread *thread)
{
  DWORD exit_code;
 
  GetExitCodeThread(*thread, &exit_code);
 
  while (exit_code == STILL_ACTIVE) {
    fc_usleep(1000);
    GetExitCodeThread(*thread, &exit_code);
  }
 
  CloseHandle(*thread);
}
 
/*******************************************************************/
fc_thread_id fc_thread_self(void)
{
  return GetCurrentThreadId();
}
 
/*******************************************************************/
bool fc_threads_equal(fc_thread_id thr1, fc_thread_id thr2)
{
  return thr1 == thr2;
}
 
/*******************************************************************/
void fc_mutex_init(fc_mutex *mutex)
{
  *mutex = CreateMutex(nullptr, FALSE, nullptr);
}
 
/*******************************************************************/
void fc_mutex_destroy(fc_mutex *mutex)
{
  CloseHandle(*mutex);
}
 
/*******************************************************************/
void fc_mutex_allocate(fc_mutex *mutex)
{
  WaitForSingleObject(*mutex, INFINITE);
}
 
/*******************************************************************/
void fc_mutex_release(fc_mutex *mutex)
{
  ReleaseMutex(*mutex);
}
 
/* TODO: Windows thread condition variable support.
 *       Currently related functions are always dummy ones below
 *       (see #ifndef FREECIV_HAVE_THREAD_COND) */
 
#else /* No thread implementation */
 
#error "No working thread implementation"
 
#endif /* FREECIV_HAVE_PTHREAD || FREECIV_HAVE_WINTHREADS */
 
 
#ifndef FREECIV_HAVE_THREAD_COND
 
/* Dummy thread condition variable functions */
 
/*******************************************************************/
void fc_thread_cond_init(fc_thread_cond *cond)
{}
 
/*******************************************************************/
void fc_thread_cond_destroy(fc_thread_cond *cond)
{}
 
/*******************************************************************/
void fc_thread_cond_wait(fc_thread_cond *cond, fc_mutex *mutex)
{}
 
/*******************************************************************/
void fc_thread_cond_signal(fc_thread_cond *cond)
{}
 
#endif /* !FREECIV_HAVE_THREAD_COND */
 
/*******************************************************************/
bool has_thread_cond_impl(void)
{
#ifdef FREECIV_HAVE_THREAD_COND
  return TRUE;
#else
  return FALSE;
#endif
}