Commit 79062841 authored by Nathan Bronson's avatar Nathan Bronson Committed by Jordan DeLong

AtomicStruct<T> provides atomic ops on small trivial classes

Summary:
AtomicStruct<T> acts like std::atomic<T>, but it supports any
trivial or trivially-copyable type up to 8 bytes in size.  I'm not sure
why these types weren't included in the original std::atomic standard,
since this construct removes a lot of boilerplate for some uses of
std::atomic.

Test Plan:
1. unit tests
2. this code is adapted from production use in tao/queues/LifoSem

Reviewed By: davejwatson@fb.com

FB internal diff: D1085106
parent a91e75db
/*
* Copyright 2013 Facebook, Inc.
*
* Licensed 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.
*/
#ifndef FOLLY_ATOMIC_STRUCT_H_
#define FOLLY_ATOMIC_STRUCT_H_
#include <atomic>
#include <type_traits>
#include <folly/Traits.h>
#include <string.h>
#include <stdint.h>
namespace folly {
namespace detail {
template <int N> struct AtomicStructIntPick {};
}
/// AtomicStruct<T> work like C++ atomics, but can be used on any POD
/// type <= 8 bytes.
template <
typename T,
template<typename> class Atom = std::atomic,
typename Raw = typename detail::AtomicStructIntPick<sizeof(T)>::type>
class AtomicStruct {
static_assert(alignof(T) <= alignof(Raw),
"target type can't have stricter alignment than matching int");
static_assert(sizeof(T) <= sizeof(Raw),
"underlying type isn't big enough");
static_assert(std::is_trivial<T>::value ||
folly::IsTriviallyCopyable<T>::value,
"target type must be trivially copyable");
Atom<Raw> data;
static Raw encode(T v) noexcept {
// we expect the compiler to optimize away the memcpy, but without
// it we would violate strict aliasing rules
Raw d = 0;
memcpy(&d, &v, sizeof(T));
return d;
}
static T decode(Raw d) noexcept {
T v;
memcpy(&v, &d, sizeof(T));
return v;
}
public:
AtomicStruct() = default;
~AtomicStruct() = default;
AtomicStruct(AtomicStruct<T> const &) = delete;
AtomicStruct<T>& operator= (AtomicStruct<T> const &) = delete;
constexpr /* implicit */ AtomicStruct(T v) noexcept : data(encode(v)) {}
bool is_lock_free() const noexcept {
return data.is_lock_free();
}
bool compare_exchange_strong(
T& v0, T v1,
std::memory_order mo = std::memory_order_seq_cst) noexcept {
Raw d0 = encode(v0);
bool rv = data.compare_exchange_strong(d0, encode(v1), mo);
if (!rv) {
v0 = decode(d0);
}
return rv;
}
bool compare_exchange_weak(
T& v0, T v1,
std::memory_order mo = std::memory_order_seq_cst) noexcept {
Raw d0 = encode(v0);
bool rv = data.compare_exchange_weak(d0, encode(v1), mo);
if (!rv) {
v0 = decode(d0);
}
return rv;
}
T exchange(T v, std::memory_order mo = std::memory_order_seq_cst) noexcept {
return decode(data.exchange(encode(v), mo));
}
/* implicit */ operator T () const noexcept {
return decode(data);
}
T load(std::memory_order mo = std::memory_order_seq_cst) const noexcept {
return decode(data.load(mo));
}
T operator= (T v) noexcept {
return decode(data = encode(v));
}
void store(T v, std::memory_order mo = std::memory_order_seq_cst) noexcept {
data.store(encode(v), mo);
}
// std::atomic also provides volatile versions of all of the access
// methods. These are callable on volatile objects, and also can
// theoretically have different implementations than their non-volatile
// counterpart. If someone wants them here they can easily be added
// by duplicating the above code and the corresponding unit tests.
};
namespace detail {
template <> struct AtomicStructIntPick<1> { typedef uint8_t type; };
template <> struct AtomicStructIntPick<2> { typedef uint16_t type; };
template <> struct AtomicStructIntPick<3> { typedef uint32_t type; };
template <> struct AtomicStructIntPick<4> { typedef uint32_t type; };
template <> struct AtomicStructIntPick<5> { typedef uint64_t type; };
template <> struct AtomicStructIntPick<6> { typedef uint64_t type; };
template <> struct AtomicStructIntPick<7> { typedef uint64_t type; };
template <> struct AtomicStructIntPick<8> { typedef uint64_t type; };
} // namespace detail
} // namespace folly
#endif
......@@ -25,6 +25,7 @@ nobase_follyinclude_HEADERS = \
AtomicHashArray-inl.h \
AtomicHashMap.h \
AtomicHashMap-inl.h \
AtomicStruct.h \
Benchmark.h \
Bits.h \
Chrono.h \
......
/*
* Copyright 2013 Facebook, Inc.
*
* Licensed 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.
*/
#include "folly/AtomicStruct.h"
#include <gflags/gflags.h>
#include <gtest/gtest.h>
using namespace folly;
struct TwoBy32 {
uint32_t left;
uint32_t right;
};
TEST(AtomicStruct, two_by_32) {
AtomicStruct<TwoBy32> a(TwoBy32{ 10, 20 });
TwoBy32 av = a;
EXPECT_EQ(av.left, 10);
EXPECT_EQ(av.right, 20);
EXPECT_TRUE(a.compare_exchange_strong(av, TwoBy32{ 30, 40 }));
EXPECT_FALSE(a.compare_exchange_weak(av, TwoBy32{ 31, 41 }));
EXPECT_EQ(av.left, 30);
EXPECT_TRUE(a.is_lock_free());
auto b = a.exchange(TwoBy32{ 50, 60 });
EXPECT_EQ(b.left, 30);
EXPECT_EQ(b.right, 40);
EXPECT_EQ(a.load().left, 50);
a = TwoBy32{ 70, 80 };
EXPECT_EQ(a.load().right, 80);
a.store(TwoBy32{ 90, 100 });
av = a;
EXPECT_EQ(av.left, 90);
AtomicStruct<TwoBy32> c;
c = b;
EXPECT_EQ(c.load().right, 40);
}
TEST(AtomicStruct, size_selection) {
struct S1 { char x[1]; };
struct S2 { char x[2]; };
struct S3 { char x[3]; };
struct S4 { char x[4]; };
struct S5 { char x[5]; };
struct S6 { char x[6]; };
struct S7 { char x[7]; };
struct S8 { char x[8]; };
EXPECT_EQ(sizeof(AtomicStruct<S1>), 1);
EXPECT_EQ(sizeof(AtomicStruct<S2>), 2);
EXPECT_EQ(sizeof(AtomicStruct<S3>), 4);
EXPECT_EQ(sizeof(AtomicStruct<S4>), 4);
EXPECT_EQ(sizeof(AtomicStruct<S5>), 8);
EXPECT_EQ(sizeof(AtomicStruct<S6>), 8);
EXPECT_EQ(sizeof(AtomicStruct<S7>), 8);
EXPECT_EQ(sizeof(AtomicStruct<S8>), 8);
}
int main(int argc, char** argv) {
testing::InitGoogleTest(&argc, argv);
google::ParseCommandLineFlags(&argc, &argv, true);
return RUN_ALL_TESTS();
}
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment