| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| |
| #pragma once |
| |
| #include <atomic> |
| #include <memory> |
| #include <utility> |
| |
| #include "arrow/type_traits.h" |
| |
| namespace arrow { |
| namespace internal { |
| |
| // Atomic shared_ptr operations only appeared in libstdc++ since GCC 5, |
| // emulate them with unsafe ops if unavailable. |
| // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57250 |
| |
| template <typename T, typename = void> |
| struct is_atomic_load_shared_ptr_available : std::false_type {}; |
| |
| template <typename T> |
| struct is_atomic_load_shared_ptr_available< |
| T, void_t<decltype(std::atomic_load(std::declval<const std::shared_ptr<T>*>()))>> |
| : std::true_type {}; |
| |
| template <typename T> |
| using enable_if_atomic_load_shared_ptr_available = |
| enable_if_t<is_atomic_load_shared_ptr_available<T>::value, T>; |
| |
| template <typename T> |
| using enable_if_atomic_load_shared_ptr_unavailable = |
| enable_if_t<!is_atomic_load_shared_ptr_available<T>::value, T>; |
| |
| template <class T> |
| enable_if_atomic_load_shared_ptr_available<std::shared_ptr<T>> atomic_load( |
| const std::shared_ptr<T>* p) { |
| return std::atomic_load(p); |
| } |
| |
| template <class T> |
| enable_if_atomic_load_shared_ptr_unavailable<std::shared_ptr<T>> atomic_load( |
| const std::shared_ptr<T>* p) { |
| return *p; |
| } |
| |
| template <typename T, typename = void> |
| struct is_atomic_store_shared_ptr_available : std::false_type {}; |
| |
| template <typename T> |
| struct is_atomic_store_shared_ptr_available< |
| T, void_t<decltype(std::atomic_store(std::declval<std::shared_ptr<T>*>(), |
| std::declval<std::shared_ptr<T>>()))>> |
| : std::true_type {}; |
| |
| template <typename T> |
| using enable_if_atomic_store_shared_ptr_available = |
| enable_if_t<is_atomic_store_shared_ptr_available<T>::value, T>; |
| |
| template <typename T> |
| using enable_if_atomic_store_shared_ptr_unavailable = |
| enable_if_t<!is_atomic_store_shared_ptr_available<T>::value, T>; |
| |
| template <class T> |
| void atomic_store(enable_if_atomic_store_shared_ptr_available<std::shared_ptr<T>*> p, |
| std::shared_ptr<T> r) { |
| std::atomic_store(p, std::move(r)); |
| } |
| |
| template <class T> |
| void atomic_store(enable_if_atomic_store_shared_ptr_unavailable<std::shared_ptr<T>*> p, |
| std::shared_ptr<T> r) { |
| *p = r; |
| } |
| |
| template <class T> |
| bool atomic_compare_exchange_strong( |
| enable_if_atomic_store_shared_ptr_available<std::shared_ptr<T>*> p, |
| std::shared_ptr<T>* expected, std::shared_ptr<T> desired) { |
| return std::atomic_compare_exchange_strong(p, expected, std::move(desired)); |
| } |
| |
| template <class T> |
| bool atomic_compare_exchange_strong( |
| enable_if_atomic_store_shared_ptr_unavailable<std::shared_ptr<T>*> p, |
| std::shared_ptr<T>* expected, std::shared_ptr<T> desired) { |
| if (*p == *expected) { |
| *p = std::move(desired); |
| return true; |
| } else { |
| *expected = *p; |
| return false; |
| } |
| } |
| |
| } // namespace internal |
| } // namespace arrow |