-
Notifications
You must be signed in to change notification settings - Fork 284
/
reference_counter.h
231 lines (176 loc) · 5.6 KB
/
reference_counter.h
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
// The libMesh Finite Element Library.
// Copyright (C) 2002-2024 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#ifndef LIBMESH_REFERENCE_COUNTER_H
#define LIBMESH_REFERENCE_COUNTER_H
// Local includes
#include "libmesh/libmesh_config.h"
#include "libmesh/threads.h"
#include "libmesh/libmesh.h" // libMesh::on_command_line
#include "libmesh/libmesh_exceptions.h" // libmesh_try, libmesh_catch
// C++ includes
#include <iostream>
#include <string>
#include <map>
#include <exception> // std::terminate
namespace libMesh
{
/**
* This is the base class for enabling reference counting. It
* should not be used by the user, thus it has a private constructor.
*
* \author Benjamin S. Kirk
* \date 2002-2007
* \brief Common base for all objects whose creations/destructions are counted.
*/
class ReferenceCounter
{
protected:
/**
* Constructors. Protected so that you cannot
* instantiate a \p ReferenceCounter, only derive
* from it.
*/
ReferenceCounter ();
ReferenceCounter (const ReferenceCounter &);
/**
* Move constructor, must be declared noexcept.
*/
ReferenceCounter(ReferenceCounter && other) noexcept;
public:
/**
* Destructor.
*/
~ReferenceCounter ();
/**
* Gets a string containing the reference information.
*/
static std::string get_info ();
/**
* Prints the reference information, by default to \p libMesh::out.
*/
static void print_info (std::ostream & out_stream = libMesh::out);
/**
* Prints the number of outstanding (created, but not yet
* destroyed) objects.
*/
static unsigned int n_objects ()
{ return _n_objects; }
/**
* Methods to enable/disable the reference counter output
* from print_info()
*/
static void enable_print_counter_info();
static void disable_print_counter_info();
protected:
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
/**
* Increments the construction counter. Should be called in
* the constructor of any derived class that will be
* reference counted.
*/
void increment_constructor_count (const std::string & name) noexcept;
/**
* Increments the destruction counter. Should be called in
* the destructor of any derived class that will be
* reference counted.
*/
void increment_destructor_count (const std::string & name) noexcept;
/**
* Data structure to log the information. The log is
* identified by the class name.
*/
typedef std::map<std::string, std::pair<unsigned int,
unsigned int>> Counts;
/**
* Actually holds the data.
*/
static Counts _counts;
#endif
/**
* The number of objects. Print the reference count
* information when the number returns to 0.
*/
static Threads::atomic<unsigned int> _n_objects;
/**
* Mutual exclusion object to enable thread-safe reference counting.
*/
static Threads::spin_mutex _mutex;
/**
* Flag to control whether reference count information
* is printed when print_info is called.
*/
static bool _enable_print_counter;
};
// ------------------------------------------------------------
// ReferenceCounter class inline methods
inline ReferenceCounter::ReferenceCounter()
{
++_n_objects;
}
inline ReferenceCounter::ReferenceCounter(const ReferenceCounter & /*other*/)
{
++_n_objects;
}
inline ReferenceCounter::ReferenceCounter(ReferenceCounter && /*other*/) noexcept
{
++_n_objects;
}
inline ReferenceCounter::~ReferenceCounter()
{
--_n_objects;
}
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
inline
void ReferenceCounter::increment_constructor_count (const std::string & name) noexcept
{
libmesh_try
{
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
std::pair<unsigned int, unsigned int> & p = _counts[name];
p.first++;
}
libmesh_catch (...)
{
auto stream = libMesh::err.get();
stream->exceptions(stream->goodbit); // stream must not throw
libMesh::err << "Encountered unrecoverable error while calling "
<< "ReferenceCounter::increment_constructor_count() "
<< "for a(n) " << name << " object." << std::endl;
std::terminate();
}
}
#endif
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
inline
void ReferenceCounter::increment_destructor_count (const std::string & name) noexcept
{
libmesh_try
{
Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
std::pair<unsigned int, unsigned int> & p = _counts[name];
p.second++;
}
libmesh_catch (...)
{
auto stream = libMesh::err.get();
stream->exceptions(stream->goodbit); // stream must not throw
libMesh::err << "Encountered unrecoverable error while calling "
<< "ReferenceCounter::increment_destructor_count() "
<< "for a(n) " << name << " object." << std::endl;
std::terminate();
}
}
#endif
} // namespace libMesh
#endif // LIBMESH_REFERENCE_COUNTER_H