os0sync.h

Go to the documentation of this file.

/*****************************************************************************

Copyright (c) 1995, 2011, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2008, Google Inc.

Portions of this file contain modifications contributed and copyrighted by
Google, Inc. Those modifications are gratefully acknowledged and are described
briefly in the InnoDB documentation. The contributions by Google are
incorporated with their permission, and subject to the conditions contained in
the file COPYING.Google.

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; version 2 of the License.

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.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA

*****************************************************************************/

/**************************************************/
#ifndef os0sync_h
#define os0sync_h

#include "univ.i"
#include "ut0lst.h"
#include "sync0types.h"

#ifdef __WIN__

typedef HANDLE                  os_native_event_t;
typedef CRITICAL_SECTION        fast_mutex_t;
typedef CONDITION_VARIABLE      os_cond_t;
#else

typedef pthread_mutex_t         fast_mutex_t;
typedef pthread_cond_t          os_cond_t;
#endif

struct os_fast_mutex_t {
        fast_mutex_t            mutex;  
#ifdef UNIV_PFS_MUTEX
        struct PSI_mutex*       pfs_psi;
#endif
};

typedef struct os_event*        os_event_t;

struct os_event {
#ifdef __WIN__
        HANDLE          handle;         
#endif
        os_fast_mutex_t os_mutex;       
        ibool           is_set;         
        ib_int64_t      signal_count;   
        os_cond_t       cond_var;       
        UT_LIST_NODE_T(os_event_t) os_event_list;
};

#define OS_SYNC_INFINITE_TIME   ULINT_UNDEFINED

#define OS_SYNC_TIME_EXCEEDED   1

typedef struct os_mutex_t*      os_ib_mutex_t;

extern os_ib_mutex_t    os_sync_mutex;

extern ulint            os_thread_count;

extern ulint            os_event_count;
extern ulint            os_mutex_count;
extern ulint            os_fast_mutex_count;

/*********************************************************/
UNIV_INTERN
void
os_sync_init(void);
/*==============*/
/*********************************************************/
UNIV_INTERN
void
os_sync_free(void);
/*==============*/
/*********************************************************/
UNIV_INTERN
os_event_t
os_event_create(void);
/*==================*/
/**********************************************************/
UNIV_INTERN
void
os_event_set(
/*=========*/
        os_event_t      event); 
/**********************************************************/
UNIV_INTERN
ib_int64_t
os_event_reset(
/*===========*/
        os_event_t      event); 
/**********************************************************/
UNIV_INTERN
void
os_event_free(
/*==========*/
        os_event_t      event); 
/**********************************************************/
UNIV_INTERN
void
os_event_wait_low(
/*==============*/
        os_event_t      event,          
        ib_int64_t      reset_sig_count);
#define os_event_wait(event) os_event_wait_low(event, 0)
#define os_event_wait_time(event, t) os_event_wait_time_low(event, t, 0)

/**********************************************************/
UNIV_INTERN
ulint
os_event_wait_time_low(
/*===================*/
        os_event_t      event,                  
        ulint           time_in_usec,           
        ib_int64_t      reset_sig_count);       
/*********************************************************/
UNIV_INTERN
os_ib_mutex_t
os_mutex_create(void);
/*=================*/
/**********************************************************/
UNIV_INTERN
void
os_mutex_enter(
/*===========*/
        os_ib_mutex_t   mutex); 
/**********************************************************/
UNIV_INTERN
void
os_mutex_exit(
/*==========*/
        os_ib_mutex_t   mutex); 
/**********************************************************/
UNIV_INTERN
void
os_mutex_free(
/*==========*/
        os_ib_mutex_t   mutex); 
/**********************************************************/
UNIV_INLINE
ulint
os_fast_mutex_trylock(
/*==================*/
        os_fast_mutex_t*        fast_mutex);    
/**********************************************************************
Following os_fast_ mutex APIs would be performance schema instrumented:

os_fast_mutex_init
os_fast_mutex_lock
os_fast_mutex_unlock
os_fast_mutex_free

These mutex APIs will point to corresponding wrapper functions that contain
the performance schema instrumentation.

NOTE! The following macro should be used in mutex operation, not the
corresponding function. */

#ifdef UNIV_PFS_MUTEX
# define os_fast_mutex_init(K, M)                       \
        pfs_os_fast_mutex_init(K, M)

# define os_fast_mutex_lock(M)                          \
        pfs_os_fast_mutex_lock(M, __FILE__, __LINE__)

# define os_fast_mutex_unlock(M)        pfs_os_fast_mutex_unlock(M)

# define os_fast_mutex_free(M)          pfs_os_fast_mutex_free(M)

/*********************************************************/
UNIV_INLINE
void
pfs_os_fast_mutex_init(
/*===================*/
        PSI_mutex_key           key,            
        os_fast_mutex_t*        fast_mutex);    
/**********************************************************/
UNIV_INLINE
void
pfs_os_fast_mutex_free(
/*===================*/
        os_fast_mutex_t*        fast_mutex);    
/**********************************************************/
UNIV_INLINE
void
pfs_os_fast_mutex_lock(
/*===================*/
        os_fast_mutex_t*        fast_mutex,     
        const char*             file_name,      
        ulint                   line);          
/**********************************************************/
UNIV_INLINE
void
pfs_os_fast_mutex_unlock(
/*=====================*/
        os_fast_mutex_t*        fast_mutex);    
#else /* UNIV_PFS_MUTEX */

# define os_fast_mutex_init(K, M)                       \
        os_fast_mutex_init_func(&((os_fast_mutex_t*)(M))->mutex)

# define os_fast_mutex_lock(M)                          \
        os_fast_mutex_lock_func(&((os_fast_mutex_t*)(M))->mutex)

# define os_fast_mutex_unlock(M)                        \
        os_fast_mutex_unlock_func(&((os_fast_mutex_t*)(M))->mutex)

# define os_fast_mutex_free(M)                          \
        os_fast_mutex_free_func(&((os_fast_mutex_t*)(M))->mutex)
#endif /* UNIV_PFS_MUTEX */

/**********************************************************/
UNIV_INTERN
void
os_fast_mutex_unlock_func(
/*======================*/
        fast_mutex_t*           fast_mutex);    
/*********************************************************/
UNIV_INTERN
void
os_fast_mutex_init_func(
/*====================*/
        fast_mutex_t*           fast_mutex);    
/**********************************************************/
UNIV_INTERN
void
os_fast_mutex_lock_func(
/*====================*/
        fast_mutex_t*           fast_mutex);    
/**********************************************************/
UNIV_INTERN
void
os_fast_mutex_free_func(
/*====================*/
        fast_mutex_t*           fast_mutex);    
/**********************************************************/
#if defined(HAVE_IB_GCC_ATOMIC_BUILTINS)

# define HAVE_ATOMIC_BUILTINS

# ifdef HAVE_IB_GCC_ATOMIC_BUILTINS_64
#  define HAVE_ATOMIC_BUILTINS_64
# endif

/**********************************************************/
# define os_compare_and_swap(ptr, old_val, new_val) \
        __sync_bool_compare_and_swap(ptr, old_val, new_val)

# define os_compare_and_swap_ulint(ptr, old_val, new_val) \
        os_compare_and_swap(ptr, old_val, new_val)

# define os_compare_and_swap_lint(ptr, old_val, new_val) \
        os_compare_and_swap(ptr, old_val, new_val)

# ifdef HAVE_IB_ATOMIC_PTHREAD_T_GCC
#  define os_compare_and_swap_thread_id(ptr, old_val, new_val) \
        os_compare_and_swap(ptr, old_val, new_val)
#  define INNODB_RW_LOCKS_USE_ATOMICS
#  define IB_ATOMICS_STARTUP_MSG \
        "Mutexes and rw_locks use GCC atomic builtins"
# else /* HAVE_IB_ATOMIC_PTHREAD_T_GCC */
#  define IB_ATOMICS_STARTUP_MSG \
        "Mutexes use GCC atomic builtins, rw_locks do not"
# endif /* HAVE_IB_ATOMIC_PTHREAD_T_GCC */

/**********************************************************/
# define os_atomic_increment(ptr, amount) \
        __sync_add_and_fetch(ptr, amount)

# define os_atomic_increment_lint(ptr, amount) \
        os_atomic_increment(ptr, amount)

# define os_atomic_increment_ulint(ptr, amount) \
        os_atomic_increment(ptr, amount)

# define os_atomic_increment_uint64(ptr, amount) \
        os_atomic_increment(ptr, amount)

/* Returns the resulting value, ptr is pointer to target, amount is the
amount to decrement. */

# define os_atomic_decrement(ptr, amount) \
        __sync_sub_and_fetch(ptr, amount)

# define os_atomic_decrement_lint(ptr, amount) \
        os_atomic_decrement(ptr, amount)

# define os_atomic_decrement_ulint(ptr, amount) \
        os_atomic_decrement(ptr, amount)

# define os_atomic_decrement_uint64(ptr, amount) \
        os_atomic_decrement(ptr, amount)

/**********************************************************/
# define os_atomic_test_and_set_byte(ptr, new_val) \
        __sync_lock_test_and_set(ptr, (byte) new_val)

# define os_atomic_test_and_set_ulint(ptr, new_val) \
        __sync_lock_test_and_set(ptr, new_val)

#elif defined(HAVE_IB_SOLARIS_ATOMICS)

# define HAVE_ATOMIC_BUILTINS
# define HAVE_ATOMIC_BUILTINS_64

/* If not compiling with GCC or GCC doesn't support the atomic
intrinsics and running on Solaris >= 10 use Solaris atomics */

# include <atomic.h>

/**********************************************************/
# define os_compare_and_swap_ulint(ptr, old_val, new_val) \
        (atomic_cas_ulong(ptr, old_val, new_val) == old_val)

# define os_compare_and_swap_lint(ptr, old_val, new_val) \
        ((lint) atomic_cas_ulong((ulong_t*) ptr, old_val, new_val) == old_val)

# ifdef HAVE_IB_ATOMIC_PTHREAD_T_SOLARIS
#  if SIZEOF_PTHREAD_T == 4
#   define os_compare_and_swap_thread_id(ptr, old_val, new_val) \
        ((pthread_t) atomic_cas_32(ptr, old_val, new_val) == old_val)
#  elif SIZEOF_PTHREAD_T == 8
#   define os_compare_and_swap_thread_id(ptr, old_val, new_val) \
        ((pthread_t) atomic_cas_64(ptr, old_val, new_val) == old_val)
#  else
#   error "SIZEOF_PTHREAD_T != 4 or 8"
#  endif /* SIZEOF_PTHREAD_T CHECK */
#  define INNODB_RW_LOCKS_USE_ATOMICS
#  define IB_ATOMICS_STARTUP_MSG \
        "Mutexes and rw_locks use Solaris atomic functions"
# else /* HAVE_IB_ATOMIC_PTHREAD_T_SOLARIS */
#  define IB_ATOMICS_STARTUP_MSG \
        "Mutexes use Solaris atomic functions, rw_locks do not"
# endif /* HAVE_IB_ATOMIC_PTHREAD_T_SOLARIS */

/**********************************************************/
# define os_atomic_increment_ulint(ptr, amount) \
        atomic_add_long_nv(ptr, amount)

# define os_atomic_increment_lint(ptr, amount) \
        os_atomic_increment_ulint((ulong_t*) ptr, amount)

# define os_atomic_increment_uint64(ptr, amount) \
        atomic_add_64_nv(ptr, amount)

/* Returns the resulting value, ptr is pointer to target, amount is the
amount to decrement. */

# define os_atomic_decrement_lint(ptr, amount) \
        os_atomic_increment_ulint((ulong_t*) ptr, -(amount))

# define os_atomic_decrement_ulint(ptr, amount) \
        os_atomic_increment_ulint(ptr, -(amount))

# define os_atomic_decrement_uint64(ptr, amount) \
        os_atomic_increment_uint64(ptr, -(amount))

/**********************************************************/
# define os_atomic_test_and_set_byte(ptr, new_val) \
        atomic_swap_uchar(ptr, new_val)

# define os_atomic_test_and_set_ulint(ptr, new_val) \
        atomic_swap_ulong(ptr, new_val)

#elif defined(HAVE_WINDOWS_ATOMICS)

# define HAVE_ATOMIC_BUILTINS

# ifndef _WIN32
#  define HAVE_ATOMIC_BUILTINS_64
# endif

/**********************************************************/
UNIV_INLINE
lint
win_cmp_and_xchg_lint(
/*==================*/
        volatile lint*  ptr,            
        lint            new_val,        
        lint            old_val);       
/**********************************************************/
UNIV_INLINE
lint
win_xchg_and_add(
/*=============*/
        volatile lint*  ptr,    
        lint            val);   
/**********************************************************/
UNIV_INLINE
ulint
win_cmp_and_xchg_ulint(
/*===================*/
        volatile ulint* ptr,            
        ulint           new_val,        
        ulint           old_val);       
/**********************************************************/
UNIV_INLINE
DWORD
win_cmp_and_xchg_dword(
/*===================*/
        volatile DWORD* ptr,            
        DWORD           new_val,        
        DWORD           old_val);       
/**********************************************************/
# define os_compare_and_swap_ulint(ptr, old_val, new_val) \
        (win_cmp_and_xchg_ulint(ptr, new_val, old_val) == old_val)

# define os_compare_and_swap_lint(ptr, old_val, new_val) \
        (win_cmp_and_xchg_lint(ptr, new_val, old_val) == old_val)

/* windows thread objects can always be passed to windows atomic functions */
# define os_compare_and_swap_thread_id(ptr, old_val, new_val) \
        (win_cmp_and_xchg_dword(ptr, new_val, old_val) == old_val)

# define INNODB_RW_LOCKS_USE_ATOMICS
# define IB_ATOMICS_STARTUP_MSG \
        "Mutexes and rw_locks use Windows interlocked functions"

/**********************************************************/
# define os_atomic_increment_lint(ptr, amount) \
        (win_xchg_and_add(ptr, amount) + amount)

# define os_atomic_increment_ulint(ptr, amount) \
        ((ulint) (win_xchg_and_add((lint*) ptr, (lint) amount) + amount))

# define os_atomic_increment_uint64(ptr, amount)                \
        ((ib_uint64_t) (InterlockedExchangeAdd64(               \
                                (ib_int64_t*) ptr,              \
                                (ib_int64_t) amount) + amount))

/**********************************************************/
# define os_atomic_decrement_lint(ptr, amount) \
        (win_xchg_and_add(ptr, -(lint) amount) - amount)

# define os_atomic_decrement_ulint(ptr, amount) \
        ((ulint) (win_xchg_and_add((lint*) ptr, -(lint) amount) - amount))

# define os_atomic_decrement_uint64(ptr, amount)                \
        ((ib_uint64_t) (InterlockedExchangeAdd64(               \
                                (ib_int64_t*) ptr,              \
                                -(ib_int64_t) amount) - amount))

/**********************************************************/
# define os_atomic_test_and_set_byte(ptr, new_val) \
        ((byte) InterlockedExchange(ptr, new_val))

# define os_atomic_test_and_set_ulong(ptr, new_val) \
        InterlockedExchange(ptr, new_val)

#else
# define IB_ATOMICS_STARTUP_MSG \
        "Mutexes and rw_locks use InnoDB's own implementation"
#endif
#ifdef HAVE_ATOMIC_BUILTINS
#define os_atomic_inc_ulint(m,v,d)      os_atomic_increment_ulint(v, d)
#define os_atomic_dec_ulint(m,v,d)      os_atomic_decrement_ulint(v, d)
#else
#define os_atomic_inc_ulint(m,v,d)      os_atomic_inc_ulint_func(m, v, d)
#define os_atomic_dec_ulint(m,v,d)      os_atomic_dec_ulint_func(m, v, d)
#endif /* HAVE_ATOMIC_BUILTINS */

/**********************************************************/
#ifdef HAVE_ATOMIC_BUILTINS
#define os_increment_counter_by_amount(mutex, counter, amount)  \
        (void) os_atomic_increment_ulint(&counter, amount)

#define os_decrement_counter_by_amount(mutex, counter, amount)  \
        (void) os_atomic_increment_ulint(&counter, (-((lint) amount)))
#else
#define os_increment_counter_by_amount(mutex, counter, amount)  \
        do {                                                    \
                mutex_enter(&(mutex));                          \
                (counter) += (amount);                          \
                mutex_exit(&(mutex));                           \
        } while (0)

#define os_decrement_counter_by_amount(mutex, counter, amount)  \
        do {                                                    \
                ut_a(counter >= amount);                        \
                mutex_enter(&(mutex));                          \
                (counter) -= (amount);                          \
                mutex_exit(&(mutex));                           \
        } while (0)
#endif  /* HAVE_ATOMIC_BUILTINS */

#define os_inc_counter(mutex, counter)                          \
        os_increment_counter_by_amount(mutex, counter, 1)

#define os_dec_counter(mutex, counter)                          \
        do {                                                    \
                os_decrement_counter_by_amount(mutex, counter, 1);\
        } while (0);

#ifndef UNIV_NONINL
#include "os0sync.ic"
#endif

#endif