mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-08 20:55:01 +00:00
194 lines
6.2 KiB
C
194 lines
6.2 KiB
C
/* os_mutex-unix.c -*-C-*-
|
|
*
|
|
*************************************************************************
|
|
*
|
|
* @copyright
|
|
* Copyright (C) 2009-2013, Intel Corporation
|
|
* All rights reserved.
|
|
*
|
|
* @copyright
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* * Neither the name of Intel Corporation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* @copyright
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
|
|
* WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
**************************************************************************/
|
|
|
|
#include "os_mutex.h"
|
|
#include "bug.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <pthread.h>
|
|
|
|
// contains notification macros for VTune.
|
|
#include "cilk-ittnotify.h"
|
|
|
|
/*
|
|
* OS Mutex functions.
|
|
*
|
|
* Not to be confused with the spinlock mutexes implemented in cilk_mutex.c
|
|
*/
|
|
|
|
struct os_mutex {
|
|
pthread_mutex_t mutex; ///< On Linux, os_mutex is implemented with a pthreads mutex
|
|
};
|
|
|
|
// Unix implementation of the global OS mutex. This will be created by the
|
|
// first call to global_os_mutex_lock() and *NEVER* destroyed. On gcc-based
|
|
// systems there's no way to guarantee the ordering of constructors and
|
|
// destructors, so we can't be guaranteed that our destructor for a static
|
|
// object will be called *after* any static destructors that may use Cilk
|
|
// in the user's application
|
|
static struct os_mutex *global_os_mutex = NULL;
|
|
|
|
/* Sometimes during shared library load malloc doesn't work.
|
|
To handle that case, preallocate space for one mutex. */
|
|
static struct os_mutex static_mutex;
|
|
static int static_mutex_used;
|
|
|
|
struct os_mutex *__cilkrts_os_mutex_create(void)
|
|
{
|
|
int status;
|
|
struct os_mutex *mutex = (struct os_mutex *)malloc(sizeof(struct os_mutex));
|
|
pthread_mutexattr_t attr;
|
|
|
|
ITT_SYNC_CREATE(mutex, "OS Mutex");
|
|
|
|
if (!mutex) {
|
|
if (static_mutex_used) {
|
|
__cilkrts_bug("Cilk RTS library initialization failed");
|
|
} else {
|
|
static_mutex_used = 1;
|
|
mutex = &static_mutex;
|
|
}
|
|
}
|
|
|
|
status = pthread_mutexattr_init(&attr);
|
|
CILK_ASSERT (status == 0);
|
|
#if defined DEBUG || CILK_LIB_DEBUG
|
|
#ifdef PTHREAD_MUTEX_ERRORCHECK
|
|
status = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
|
|
#else
|
|
status = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
|
|
#endif
|
|
CILK_ASSERT (status == 0);
|
|
#endif
|
|
status = pthread_mutex_init (&mutex->mutex, &attr);
|
|
CILK_ASSERT (status == 0);
|
|
pthread_mutexattr_destroy(&attr);
|
|
|
|
return mutex;
|
|
}
|
|
|
|
void __cilkrts_os_mutex_lock(struct os_mutex *p)
|
|
{
|
|
int status;
|
|
status = pthread_mutex_lock (&p->mutex);
|
|
ITT_SYNC_ACQUIRED(p);
|
|
if (__builtin_expect(status, 0) == 0)
|
|
return;
|
|
if (status == EDEADLK)
|
|
__cilkrts_bug("Cilk runtime error: deadlock acquiring mutex %p\n",
|
|
p);
|
|
else
|
|
__cilkrts_bug("Cilk runtime error %d acquiring mutex %p\n",
|
|
status, p);
|
|
}
|
|
|
|
int __cilkrts_os_mutex_trylock(struct os_mutex *p)
|
|
{
|
|
int status;
|
|
status = pthread_mutex_trylock (&p->mutex);
|
|
return (status == 0);
|
|
}
|
|
|
|
void __cilkrts_os_mutex_unlock(struct os_mutex *p)
|
|
{
|
|
int status;
|
|
ITT_SYNC_RELEASING(p);
|
|
status = pthread_mutex_unlock (&p->mutex);
|
|
CILK_ASSERT(status == 0);
|
|
}
|
|
|
|
void __cilkrts_os_mutex_destroy(struct os_mutex *p)
|
|
{
|
|
pthread_mutex_destroy (&p->mutex);
|
|
if (p == &static_mutex) {
|
|
static_mutex_used = 0;
|
|
} else {
|
|
free(p);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* create_global_os_mutex
|
|
*
|
|
* Function used with pthread_once to initialize the global OS mutex. Since
|
|
* pthread_once requires a function which takes no parameters and has no
|
|
* return value, the global OS mutex will be stored in the static (global
|
|
* to the compilation unit) variable "global_os_mutex."
|
|
*
|
|
*
|
|
* global_os_mutex will never be destroyed.
|
|
*/
|
|
static void create_global_os_mutex(void)
|
|
{
|
|
CILK_ASSERT(NULL == global_os_mutex);
|
|
global_os_mutex = __cilkrts_os_mutex_create();
|
|
}
|
|
|
|
void global_os_mutex_lock(void)
|
|
{
|
|
// pthread_once_t used with pthread_once to guarantee that
|
|
// create_global_os_mutex() is only called once
|
|
static pthread_once_t global_os_mutex_is_initialized = PTHREAD_ONCE_INIT;
|
|
|
|
// Execute create_global_os_mutex once in a thread-safe manner
|
|
// Note that create_global_os_mutex returns the mutex in the static
|
|
// (global to the module) variable "global_os_mutex"
|
|
pthread_once(&global_os_mutex_is_initialized,
|
|
create_global_os_mutex);
|
|
|
|
// We'd better have allocated a global_os_mutex
|
|
CILK_ASSERT(NULL != global_os_mutex);
|
|
|
|
// Acquire the global OS mutex
|
|
__cilkrts_os_mutex_lock(global_os_mutex);
|
|
}
|
|
|
|
void global_os_mutex_unlock(void)
|
|
{
|
|
// We'd better have allocated a global_os_mutex. This means you should
|
|
// have called global_os_mutex_lock() before calling
|
|
// global_os_mutex_unlock(), but this is the only check for it.
|
|
CILK_ASSERT(NULL != global_os_mutex);
|
|
|
|
// Release the global OS mutex
|
|
__cilkrts_os_mutex_unlock(global_os_mutex);
|
|
}
|
|
|
|
/* End os_mutex-unix.c */
|