blob: 6d9586cb3c6bfc68b7be43b762d8da92f2f3c834 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
#ifndef __pbd_rcu_h__
#define __pbd_rcu_h__
#include "boost/shared_ptr.hpp"
#include "glibmm/thread.h"
#include <list>
template<class T>
class RCUManager
{
public:
RCUManager (T* new_rcu_value)
: m_rcu_value(new_rcu_value)
{
}
virtual ~RCUManager() { }
boost::shared_ptr<T> reader () const { return m_rcu_value; }
// should be private
virtual boost::shared_ptr<T> write_copy () = 0;
// should be private
virtual void update (boost::shared_ptr<T> new_value) = 0;
protected:
boost::shared_ptr<T> m_rcu_value;
};
template<class T>
class SerializedRCUManager : public RCUManager<T>
{
public:
SerializedRCUManager(T* new_rcu_value)
: RCUManager<T>(new_rcu_value)
{
}
virtual boost::shared_ptr<T> write_copy ()
{
m_lock.lock();
// I hope this is doing what I think it is doing :)
boost::shared_ptr<T> new_copy(new T(*RCUManager<T>::m_rcu_value));
// XXX todo remove old copies with only 1 reference from the list.
return new_copy;
}
virtual void update (boost::shared_ptr<T> new_value)
{
// So a current reader doesn't hold the only reference to
// the existing value when we assign it a new value which
// should ensure that deletion of old values doesn't
// occur in a reader thread.
boost::shared_ptr<T> old_copy = RCUManager<T>::m_rcu_value;
// we hold the lock at this point effectively blocking
// other writers.
RCUManager<T>::m_rcu_value = new_value;
// XXX add the old value to the list of old copies.
m_lock.unlock();
}
private:
Glib::Mutex m_lock;
std::list<boost::shared_ptr<T> > m_old_values;
};
template<class T>
class RCUWriter
{
public:
RCUWriter(RCUManager<T>& manager)
: m_manager(manager)
{
m_copy = m_manager.write_copy();
}
~RCUWriter()
{
// we can check here that the refcount of m_copy is 1
if(m_copy.use_count() == 1) {
m_manager.update(m_copy);
} else {
// critical error.
}
}
// or operator boost::shared_ptr<T> ();
boost::shared_ptr<T> get_copy() { return m_copy; }
private:
RCUManager<T>& m_manager;
// preferably this holds a pointer to T
boost::shared_ptr<T> m_copy;
};
#endif /* __pbd_rcu_h__ */
|
