raw_atomics.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * 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 of the License, 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. 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_ASSORTED_RAW_ATOMICS_HPP_
#define FOEDUS_ASSORTED_RAW_ATOMICS_HPP_

#include <stdint.h>

namespace foedus {
namespace assorted {

template <typename T>
inline bool raw_atomic_compare_exchange_strong(T* target, T* expected, T desired) {
  // Use newer builtin instead of __sync_val_compare_and_swap
  return ::__atomic_compare_exchange_n(
    target,
    expected,
    desired,
    false,
    __ATOMIC_SEQ_CST,
    __ATOMIC_SEQ_CST);
  // T expected_val = *expected;
  // T old_val = ::__sync_val_compare_and_swap(target, expected_val, desired);
  // if (old_val == expected_val) {
  //   return true;
  // } else {
  //   *expected = old_val;
  //   return false;
  // }
}

template <typename T>
inline bool raw_atomic_compare_exchange_weak(T* target, T* expected, T desired) {
  return ::__atomic_compare_exchange_n(
    target,
    expected,
    desired,
    true,  // weak
    __ATOMIC_SEQ_CST,
    __ATOMIC_SEQ_CST);
}

bool raw_atomic_compare_exchange_strong_uint128(
  uint64_t *ptr,
  const uint64_t *old_value,
  const uint64_t *new_value);

inline bool raw_atomic_compare_exchange_weak_uint128(
  uint64_t *ptr,
  const uint64_t *old_value,
  const uint64_t *new_value) {
  if (ptr[0] != old_value[0] || ptr[1] != old_value[1]) {
    return false;  // this comparison is fast but not atomic, thus 'weak'
  } else {
    return raw_atomic_compare_exchange_strong_uint128(ptr, old_value, new_value);
  }
}

template <typename T>
inline T raw_atomic_exchange(T* target, T desired) {
  return ::__atomic_exchange_n(target, desired, __ATOMIC_SEQ_CST);
  // Note: We must NOT use __sync_lock_test_and_set, which is only acquire-barrier for some
  // reason. We instead use GCC/Clang's __atomic_exchange() builtin.
  // return ::__sync_lock_test_and_set(target, desired);
  // see https://gcc.gnu.org/onlinedocs/gcc-4.4.3/gcc/Atomic-Builtins.html
  // and https://bugzilla.mozilla.org/show_bug.cgi?id=873799

  // BTW, __atomic_exchange_n/__ATOMIC_SEQ_CST demands a C++11-capable version of gcc/clang,
  // but FOEDUS anyway relies on C++11. It just allows the linked program to be
  // compiled without std=c++11. So, nothing lost.
}

template <typename T>
inline T raw_atomic_fetch_add(T* target, T addendum) {
  return ::__atomic_fetch_add(target, addendum, __ATOMIC_SEQ_CST);
  // Just to align with above, use __atomic_fetch_add rather than __sync_fetch_and_add.
  // It's equivalent.
  // return ::__sync_fetch_and_add(target, addendum);
}

template <typename T>
inline T raw_atomic_fetch_and_bitwise_and(T* target, T operand) {
  return ::__atomic_fetch_and(target, operand, __ATOMIC_SEQ_CST);
}
template <typename T>
inline T raw_atomic_fetch_and_bitwise_or(T* target, T operand) {
  return ::__atomic_fetch_or(target, operand, __ATOMIC_SEQ_CST);
}
template <typename T>
inline T raw_atomic_fetch_and_bitwise_xor(T* target, T operand) {
  return ::__atomic_fetch_xor(target, operand, __ATOMIC_SEQ_CST);
}
}  // namespace assorted
}  // namespace foedus

#endif  // FOEDUS_ASSORTED_RAW_ATOMICS_HPP_