118 lines
7.1 KiB
C++
118 lines
7.1 KiB
C++
/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
|
|
|
|
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 St, Fifth Floor, Boston, MA
|
|
02110-1301 USA */
|
|
|
|
|
|
#ifndef ATOMIC_CLASS_H_INCLUDED
|
|
#define ATOMIC_CLASS_H_INCLUDED
|
|
|
|
#include "my_atomic.h"
|
|
|
|
/**
|
|
Wrapper class to use C++ syntax to access atomic integers.
|
|
*/
|
|
#define DEFINE_ATOMIC_CLASS(NAME, SUFFIX, TYPE) \
|
|
class Atomic_##NAME \
|
|
{ \
|
|
public: \
|
|
/* Create a new Atomic_* object. */ \
|
|
Atomic_##NAME(TYPE n= 0) \
|
|
{ \
|
|
my_atomic_store##SUFFIX(&value, n); \
|
|
} \
|
|
/* Atomically read the value. */ \
|
|
TYPE atomic_get() \
|
|
{ \
|
|
return my_atomic_load##SUFFIX(&value); \
|
|
} \
|
|
/* Atomically set the value. */ \
|
|
void atomic_set(TYPE n) \
|
|
{ \
|
|
my_atomic_store##SUFFIX(&value, n); \
|
|
} \
|
|
/* Atomically add to the value, and return the old value. */ \
|
|
TYPE atomic_add(TYPE n) \
|
|
{ \
|
|
return my_atomic_add##SUFFIX(&value, n); \
|
|
} \
|
|
/* Atomically set the value and return the old value. */ \
|
|
TYPE atomic_get_and_set(TYPE n) \
|
|
{ \
|
|
return my_atomic_fas##SUFFIX(&value, n); \
|
|
} \
|
|
/* If the old value is equal to *old, set the value to new and */ \
|
|
/* return true. Otherwise, store the old value in '*old' and */ \
|
|
/* return false. */ \
|
|
bool atomic_compare_and_swap(TYPE *old, TYPE n) \
|
|
{ \
|
|
return my_atomic_cas##SUFFIX(&value, old, n); \
|
|
} \
|
|
/* Read the value *non-atomically*. */ \
|
|
TYPE non_atomic_get() \
|
|
{ \
|
|
return value; \
|
|
} \
|
|
/* Set the value *non-atomically*. */ \
|
|
void non_atomic_set(TYPE n) \
|
|
{ \
|
|
value= n; \
|
|
} \
|
|
/* Add to the value *non-atomically*. */ \
|
|
TYPE non_atomic_add(TYPE n) \
|
|
{ \
|
|
TYPE ret= value; \
|
|
value+= n; \
|
|
return ret; \
|
|
} \
|
|
/* Set the value to the greatest of (old, n). */ \
|
|
\
|
|
/* The function will internally requires multiple atomic */ \
|
|
/* operations. If the old value is known (or guessed), and less */ \
|
|
/* than n, it requires one atomic operation less. Therefore, */ \
|
|
/* the caller should set *guess to whatever is the likely value */ \
|
|
/* that the variable currently has, if such a guess is known. */ \
|
|
\
|
|
/* @return If the new value is changed to n, *guess is set to */ \
|
|
/* the old value and the the function returns true. Otherwise, */ \
|
|
/* *guess is set to the current value (which is greater than or */ \
|
|
/* equal to n), and the function returns false. */ \
|
|
bool atomic_set_to_max(TYPE n, TYPE *guess= NULL) \
|
|
{ \
|
|
TYPE _guess; \
|
|
if (guess == NULL) \
|
|
{ \
|
|
_guess= n - 1; \
|
|
guess= &_guess; \
|
|
} \
|
|
else \
|
|
DBUG_ASSERT(*guess < n); \
|
|
bool ret; \
|
|
do { \
|
|
ret= atomic_compare_and_swap(guess, n); \
|
|
} while (!ret && *guess < n); \
|
|
return ret; \
|
|
} \
|
|
\
|
|
private: \
|
|
TYPE value; \
|
|
}
|
|
|
|
DEFINE_ATOMIC_CLASS(int32, 32, int32);
|
|
DEFINE_ATOMIC_CLASS(int64, 64, int64);
|
|
//DEFINE_ATOMIC_CLASS(pointer, ptr, void *);
|
|
|
|
#endif //ifndef ATOMIC_CLASS_H_INCLUDED
|