@@ -43,8 +43,8 @@ namespace util
43
43
// / restrictions on the operations that can be
44
44
// / performed. Specifically, tree nodes can only be added, but not
45
45
// / moved or removed.
46
-
47
- template <typename T>
46
+
47
+ template <typename T>
48
48
class LockfreeIntrusiveTree {
49
49
public:
50
50
@@ -60,7 +60,7 @@ class LockfreeIntrusiveTree {
60
60
61
61
private:
62
62
63
- // --- private data
63
+ // --- private data
64
64
65
65
T* m_me;
66
66
LockfreeIntrusiveTree<T>::Node T::*m_node;
@@ -74,7 +74,7 @@ class LockfreeIntrusiveTree {
74
74
75
75
public:
76
76
77
- LockfreeIntrusiveTree (T* me, LockfreeIntrusiveTree<T>::Node T::*nodeptr)
77
+ LockfreeIntrusiveTree (T* me, LockfreeIntrusiveTree<T>::Node T::*nodeptr)
78
78
: m_me(me), m_node(nodeptr)
79
79
{ }
80
80
@@ -84,70 +84,13 @@ class LockfreeIntrusiveTree {
84
84
85
85
void append (T* sub) {
86
86
LockfreeIntrusiveTree<T>::Node& n = node (m_me);
87
-
88
- node (sub).parent = m_me;
89
-
90
- // do "conservative" loop update instead of
91
- // while(!n.head.compare_exchange_weak(node(sub).next, sub,
92
- // std::memory_order_release,
93
- // std::memory_order_relaxed))
94
- // ;
95
- // because that is not safe on some pre-2014 compilers according to
96
- // http://en.cppreference.com/w/cpp/atomic/atomic/compare_exchange
97
-
98
- T* old_head = n.head .load (std::memory_order_relaxed);
99
-
100
- do {
101
- node (sub).next = old_head;
102
- } while (!n.head .compare_exchange_weak (old_head, sub,
103
- std::memory_order_release,
104
- std::memory_order_relaxed));
105
- }
106
-
107
- //
108
- // --- Iterators ---------------------------------------------------------
109
- //
110
-
111
- class depthfirst_iterator : public std ::iterator<std::input_iterator_tag, T> {
112
- T* m_t ;
113
- LockfreeIntrusiveTree<T>::Node T::*m_n;
114
-
115
- public:
116
-
117
- depthfirst_iterator (T* t, LockfreeIntrusiveTree<T>::Node T::*n)
118
- : m_t (t), m_n(n) { }
119
87
120
- depthfirst_iterator& operator ++() {
121
- if (node (m_t , m_n).head )
122
- m_t = node (m_t , m_n).head ;
123
- else if (node (m_t , m_n).next )
124
- m_t = node (m_t , m_n).next ;
125
- else {
126
- // find first parent node with a sibling
127
- while (node (m_t , m_n).parent && !node (m_t , m_n).next )
128
- m_t = node (m_t , m_n).parent ;
129
-
130
- m_t = node (m_t , m_n).next ;
131
- }
132
-
133
- return *this ;
134
- }
135
-
136
- depthfirst_iterator operator ++(int ) {
137
- depthfirst_iterator tmp (*this ); ++(*this ); return tmp;
138
- }
139
-
140
- bool operator == (const depthfirst_iterator& rhs) { return m_t == rhs.m_t ; }
141
- bool operator != (const depthfirst_iterator& rhs) { return m_t != rhs.m_t ; }
142
- T& operator * () { return *m_t ; }
143
- };
144
-
145
- LockfreeIntrusiveTree<T>::depthfirst_iterator begin () {
146
- return depthfirst_iterator (m_me, m_node);
147
- }
88
+ node (sub).parent = m_me;
148
89
149
- LockfreeIntrusiveTree<T>::depthfirst_iterator end () {
150
- return LockfreeIntrusiveTree<T>::depthfirst_iterator (0 , m_node);
90
+ while (!n.head .compare_exchange_weak (node (sub).next , sub,
91
+ std::memory_order_release,
92
+ std::memory_order_relaxed))
93
+ ;
151
94
}
152
95
};
153
96
0 commit comments