Skip to content

Commit e4b2cf4

Browse files
David-HaimDavid-Haim
authored
atomic_wait improvements (#163)
1 parent 33c4da9 commit e4b2cf4

File tree

14 files changed

+587
-89
lines changed

14 files changed

+587
-89
lines changed

‎CMakeLists.txt‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,8 @@ set(concurrencpp_sources
3232
source/threads/async_condition_variable.cpp
3333
source/threads/thread.cpp
3434
source/timers/timer.cpp
35-
source/timers/timer_queue.cpp)
35+
source/timers/timer_queue.cpp
36+
source/utils/math_helper.cpp)
3637

3738
set(concurrencpp_headers
3839
include/concurrencpp/concurrencpp.h
@@ -81,7 +82,9 @@ set(concurrencpp_headers
8182
include/concurrencpp/timers/timer.h
8283
include/concurrencpp/timers/timer_queue.h
8384
include/concurrencpp/utils/bind.h
84-
include/concurrencpp/utils/slist.h)
85+
include/concurrencpp/utils/math_helper.h
86+
include/concurrencpp/utils/slist.h
87+
include/concurrencpp/utils/dlist.h)
8588

8689
add_library(concurrencpp ${concurrencpp_headers} ${concurrencpp_sources})
8790
add_library(concurrencpp::concurrencpp ALIAS concurrencpp)

‎include/concurrencpp/results/impl/result_state.h‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ namespace concurrencpp::details {
1515
class CRCPP_API result_state_base {
1616

1717
public:
18-
enum class pc_status : int32_t { idle, consumer_set, consumer_waiting, consumer_done, producer_done };
18+
enum class pc_status : uint32_t { idle, consumer_set, consumer_waiting, consumer_done, producer_done };
1919

2020
protected:
2121
std::atomic<pc_status> m_pc_status {pc_status::idle};
@@ -42,6 +42,8 @@ namespace concurrencpp::details {
4242
producer_context<type> m_producer;
4343

4444
static void delete_self(result_state<type>* state) noexcept {
45+
assert(state != nullptr);
46+
4547
auto done_handle = state->m_done_handle;
4648
if (static_cast<bool>(done_handle)) {
4749
assert(done_handle.done());
@@ -151,7 +153,7 @@ namespace concurrencpp::details {
151153
}
152154

153155
case pc_status::consumer_waiting: {
154-
return atomic_notify_all(m_pc_status);
156+
return atomic_notify_one(m_pc_status);
155157
}
156158

157159
case pc_status::consumer_done: {

‎include/concurrencpp/results/impl/shared_result_state.h‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@
55
#include "concurrencpp/results/impl/result_state.h"
66

77
#include <atomic>
8-
#include <semaphore>
98

109
#include <cassert>
1110

‎include/concurrencpp/results/result_fwd_declarations.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ namespace concurrencpp {
3030

3131
struct null_result {};
3232

33-
enum class result_status : int32_t { idle, value, exception };
33+
enum class result_status : uint32_t { idle, value, exception };
3434
} // namespace concurrencpp
3535

3636
namespace concurrencpp::details {

‎include/concurrencpp/threads/atomic_wait.h‎

Lines changed: 122 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -3,35 +3,61 @@
33

44
#include "concurrencpp/platform_defs.h"
55

6-
#include <thread>
76
#include <atomic>
87
#include <chrono>
8+
#include <type_traits>
99

1010
#include <cassert>
1111

1212
namespace concurrencpp::details {
13-
void CRCPP_API atomic_wait_native(void* atom, int32_t old) noexcept;
14-
void CRCPP_API atomic_wait_for_native(void* atom, int32_t old, std::chrono::milliseconds ms) noexcept;
15-
void CRCPP_API atomic_notify_all_native(void* atom) noexcept;
1613

1714
enum class atomic_wait_status { ok, timeout };
1815

16+
template<class type>
17+
void atomic_wait(std::atomic<type>& atom, type old, std::memory_order order) noexcept;
18+
19+
template<class type>
20+
atomic_wait_status atomic_wait_for(std::atomic<type>& atom,
21+
type old,
22+
std::chrono::milliseconds ms,
23+
std::memory_order order) noexcept;
24+
25+
template<class type>
26+
void atomic_notify_one(std::atomic<type>& atom) noexcept;
27+
28+
template<class type>
29+
void atomic_notify_all(std::atomic<type>& atom) noexcept;
30+
31+
template<class type>
32+
void assert_atomic_type_waitable() noexcept {
33+
static_assert(std::is_integral_v<type> || std::is_enum_v<type>,
34+
"atomic_wait/atomic_notify - <<type>> must be integeral or enumeration type");
35+
static_assert(sizeof(type) == sizeof(uint32_t), "atomic_wait/atomic_notify - <<type>> must be 4 bytes.");
36+
static_assert(std::is_standard_layout_v<std::atomic<type>>,
37+
"atomic_wait/atomic_notify - std::atom<type> is not standard-layout");
38+
static_assert(std::atomic<type>::is_always_lock_free, "atomic_wait/atomic_notify - std::atom<type> is not lock free");
39+
}
40+
} // namespace concurrencpp::details
41+
42+
#if !defined(CRCPP_MAC_OS)
43+
44+
namespace concurrencpp::details {
45+
void CRCPP_API atomic_wait_native(void* atom, uint32_t old) noexcept;
46+
void CRCPP_API atomic_wait_for_native(void* atom, uint32_t old, std::chrono::milliseconds ms) noexcept;
47+
void CRCPP_API atomic_notify_one_native(void* atom) noexcept;
48+
void CRCPP_API atomic_notify_all_native(void* atom) noexcept;
49+
1950
template<class type>
2051
void atomic_wait(std::atomic<type>& atom, type old, std::memory_order order) noexcept {
21-
static_assert(std::is_standard_layout_v<std::atomic<type>>, "atomic_wait - std::atom<type> is not standard-layout");
22-
static_assert(sizeof(type) == sizeof(int32_t), "atomic_wait - <<type>> must be 4 bytes.");
52+
assert_atomic_type_waitable<type>();
2353

2454
while (true) {
2555
const auto val = atom.load(order);
2656
if (val != old) {
2757
return;
2858
}
2959

30-
#if defined(CRCPP_MAC_OS)
31-
atom.wait(old, order);
32-
#else
33-
atomic_wait_native(&atom, static_cast<int32_t>(old));
34-
#endif
60+
atomic_wait_native(&atom, static_cast<uint32_t>(old));
3561
}
3662
}
3763

@@ -40,14 +66,10 @@ namespace concurrencpp::details {
4066
type old,
4167
std::chrono::milliseconds ms,
4268
std::memory_order order) noexcept {
43-
static_assert(std::is_standard_layout_v<std::atomic<type>>, "atomic_wait_for - std::atom<type> is not standard-layout");
44-
static_assert(sizeof(type) == sizeof(int32_t), "atomic_wait_for - <<type>> must be 4 bytes.");
69+
assert_atomic_type_waitable<type>();
4570

4671
const auto deadline = std::chrono::system_clock::now() + ms;
4772

48-
#if defined(CRCPP_MAC_OS)
49-
size_t polling_cycle = 0;
50-
#endif
5173
while (true) {
5274
if (atom.load(order) != old) {
5375
return atomic_wait_status::ok;
@@ -62,45 +84,100 @@ namespace concurrencpp::details {
6284
return atomic_wait_status::timeout;
6385
}
6486

65-
#if defined(CRCPP_MAC_OS)
66-
if (polling_cycle < 64) {
67-
std::this_thread::yield();
68-
++polling_cycle;
69-
continue;
70-
}
71-
72-
if (polling_cycle < 5'000) {
73-
std::this_thread::sleep_for(std::chrono::milliseconds(1));
74-
++polling_cycle;
75-
continue;
76-
}
77-
78-
if (polling_cycle < 10'000) {
79-
std::this_thread::sleep_for(std::chrono::milliseconds(2));
80-
++polling_cycle;
81-
continue;
82-
}
83-
84-
std::this_thread::sleep_for(std::chrono::milliseconds(5));
85-
++polling_cycle;
86-
87-
#else
8887
const auto time_diff = std::chrono::duration_cast<std::chrono::milliseconds>(deadline - now);
8988
assert(time_diff.count() >= 0);
90-
atomic_wait_for_native(&atom, static_cast<int32_t>(old), time_diff);
91-
#endif
89+
atomic_wait_for_native(&atom, static_cast<uint32_t>(old), time_diff);
9290
}
9391
}
9492

93+
template<class type>
94+
void atomic_notify_one(std::atomic<type>& atom) noexcept {
95+
atomic_notify_one_native(&atom);
96+
}
97+
9598
template<class type>
9699
void atomic_notify_all(std::atomic<type>& atom) noexcept {
97-
#if defined(CRCPP_MAC_OS)
100+
atomic_notify_all_native(&atom);
101+
}
102+
} // namespace concurrencpp::details
98103

99-
atom.notify_all();
100104
#else
101-
atomic_notify_all_native(&atom);
102-
#endif
105+
106+
#include <memory>
107+
108+
namespace concurrencpp::details {
109+
class atomic_wait_bucket;
110+
111+
using atomic_comp_fn = bool (*)(void*, const uint32_t, std::memory_order) noexcept;
112+
113+
class CRCPP_API atomic_wait_table {
114+
115+
private:
116+
std::unique_ptr<atomic_wait_bucket[]> m_buckets;
117+
const size_t m_size;
118+
119+
static size_t calc_table_size() noexcept;
120+
size_t index_for(const void* atom) const noexcept;
121+
122+
public:
123+
atomic_wait_table();
124+
125+
void wait(void* atom, const uint32_t old, std::memory_order order, atomic_comp_fn comp);
126+
atomic_wait_status wait_for(void* atom,
127+
const uint32_t old,
128+
std::chrono::milliseconds ms,
129+
std::memory_order order,
130+
atomic_comp_fn comp);
131+
132+
void notify_one(const void* atom) noexcept;
133+
void notify_all(const void* atom) noexcept;
134+
135+
static atomic_wait_table& instance();
136+
};
137+
138+
template<class type>
139+
void atomic_wait(std::atomic<type>& atom, type old, std::memory_order order) noexcept {
140+
assert_atomic_type_waitable<type>();
141+
142+
auto comp = [](void* atom_, const uint32_t old_, std::memory_order order_) noexcept -> bool {
143+
auto& original_atom = *static_cast<std::atomic<type>*>(atom_);
144+
const auto original_old = static_cast<type>(old_);
145+
146+
return original_atom.load(order_) == original_old;
147+
};
148+
149+
atomic_wait_table::instance().wait(&atom, static_cast<uint32_t>(old), order, comp);
150+
}
151+
152+
template<class type>
153+
atomic_wait_status atomic_wait_for(std::atomic<type>& atom,
154+
type old,
155+
std::chrono::milliseconds ms,
156+
std::memory_order order) noexcept {
157+
assert_atomic_type_waitable<type>();
158+
159+
auto comp = [](void* atom_, const uint32_t old_, std::memory_order order_) noexcept -> bool {
160+
auto& original_atom = *static_cast<std::atomic<type>*>(atom_);
161+
const auto original_old = static_cast<type>(old_);
162+
163+
return original_atom.load(order_) == original_old;
164+
};
165+
166+
return atomic_wait_table::instance().wait_for(&atom, static_cast<uint32_t>(old), ms, order, comp);
103167
}
168+
169+
template<class type>
170+
void atomic_notify_one(std::atomic<type>& atom) noexcept {
171+
atomic_wait_table::instance().notify_one(&atom);
172+
}
173+
174+
template<class type>
175+
void atomic_notify_all(std::atomic<type>& atom) noexcept {
176+
atomic_wait_table::instance().notify_all(&atom);
177+
}
178+
104179
} // namespace concurrencpp::details
105180

106181
#endif
182+
183+
#endif

‎include/concurrencpp/utils/dlist.h‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
#ifndef CONCURRENCPP_DLIST_H
2+
#define CONCURRENCPP_DLIST_H
3+
4+
#include "concurrencpp/platform_defs.h"
5+
6+
#include <cassert>
7+
8+
namespace concurrencpp::details {
9+
template<class node_type>
10+
class dlist {
11+
12+
private:
13+
node_type* m_head = nullptr;
14+
15+
public:
16+
void push_front(node_type& new_node) noexcept {
17+
assert(new_node.next == nullptr);
18+
assert(new_node.prev == nullptr);
19+
20+
if (m_head != nullptr) {
21+
m_head->prev = &new_node;
22+
new_node.next = m_head;
23+
}
24+
25+
m_head = &new_node;
26+
}
27+
28+
void remove_node(node_type& old_node) noexcept {
29+
assert(m_head != nullptr);
30+
assert(old_node.prev != nullptr || old_node.next != nullptr);
31+
32+
if (old_node.prev != nullptr) {
33+
old_node.prev->next = old_node.next;
34+
} else {
35+
m_head = old_node.next;
36+
}
37+
38+
if (old_node.next != nullptr) {
39+
old_node.next->prev = old_node.prev;
40+
}
41+
}
42+
43+
bool empty() const noexcept {
44+
return m_head != nullptr;
45+
}
46+
47+
template<class functor_type>
48+
void for_each(functor_type f) {
49+
auto cursor = m_head;
50+
while (cursor != nullptr) {
51+
const bool should_continue_iteration = f(*cursor);
52+
if (!should_continue_iteration) {
53+
return;
54+
}
55+
56+
cursor = cursor->next;
57+
}
58+
}
59+
};
60+
} // namespace concurrencpp::details
61+
62+
#endif

‎include/concurrencpp/utils/math_helper.h‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
#ifndef CONCURRENCPP_MATH_H
2+
#define CONCURRENCPP_MATH_H
3+
4+
#include "concurrencpp/platform_defs.h"
5+
6+
#include <cstddef>
7+
8+
namespace concurrencpp::details {
9+
struct CRCPP_API math_helper {
10+
static bool is_prime(size_t n) noexcept;
11+
static size_t next_prime(size_t n) noexcept;
12+
};
13+
} // namespace concurrencpp::details
14+
15+
#endif

0 commit comments

Comments
 (0)