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
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
// **********************************************************************
//
// Copyright (c) 2003-2004 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
#include <IceUtil/GC.h>
#include <IceUtil/Time.h>
#include <IceUtil/GCRecMutex.h>
#include <IceUtil/GCShared.h>
#include <map>
namespace IceUtil
{
void
recursivelyReachable(GCShared* p, GCObjectSet& o)
{
if(o.find(p) == o.end())
{
assert(p);
o.insert(p);
GCObjectMultiSet tmp;
p->__gcReachable(tmp);
for(GCObjectMultiSet::const_iterator i = tmp.begin(); i != tmp.end(); ++i)
{
recursivelyReachable(*i, o);
}
}
}
}
using namespace std;
int IceUtil::GC::_numCollectors = 0;
IceUtil::GC::GC(int interval, StatsCallback cb)
{
Monitor<Mutex>::Lock sync(*this);
if(_numCollectors++ > 0)
{
abort(); // Enforce singleton.
}
_state = NotStarted;
_collecting = false;
_interval = interval;
_statsCallback = cb;
}
IceUtil::GC::~GC()
{
Monitor<Mutex>::Lock sync(*this);
--_numCollectors;
}
void
IceUtil::GC::run()
{
assert(_interval > 0);
{
Monitor<Mutex>::Lock sync(*this);
_state = Started;
notify();
}
Time waitTime = Time::seconds(_interval);
while(true)
{
bool collect = false;
{
Monitor<Mutex>::Lock sync(*this);
if(_state == Stopping)
{
_state = Stopped;
return;
}
if(!timedWait(waitTime))
{
collect = true;
}
}
if(collect)
{
collectGarbage();
}
}
}
void
IceUtil::GC::stop()
{
{
Monitor<Mutex>::Lock sync(*this);
if(_state >= Stopping)
{
return; // Don't attempt to stop the thread twice.
}
//
// Wait until the thread is actually started. (If we don't do this, we
// can get a problem if a call to stop() immediately follows a call to start():
// the call to stop() may happen before pthread_create() has scheduled the thread's run()
// function, and then the notify() that is used to tell the thread to stop can be lost.
//
while(_state < Started)
{
wait();
}
}
//
// Tell the thread to stop.
//
{
Monitor<Mutex>::Lock sync(*this);
_state = Stopping;
notify();
}
getThreadControl().join();
assert(_state == Stopped);
}
void
IceUtil::GC::collectGarbage()
{
{
Monitor<Mutex>::Lock sync(*this);
if(_collecting)
{
return;
}
_collecting = true;
}
typedef map<GCShared*, int> ObjectCounts;
ObjectCounts counts;
Time t;
GCStats stats;
RecMutex::Lock sync(*gcRecMutex._m); // Prevent any further class reference count activity.
if(_statsCallback)
{
t = Time::now();
}
//
// Initialize a set of pairs <GCShared*, ref count> for all class instances.
//
{
for(GCObjectSet::const_iterator i = gcObjects.begin(); i != gcObjects.end(); ++i)
{
assert(*i);
counts[*i] = (*i)->_ref;
}
}
if(_statsCallback)
{
stats.examined = counts.size();
}
//
// For each class instance in the set, find which class instances can be reached from that instance.
// For each reachable instance, decrement the reachable instance's ref count.
//
{
for(GCObjectSet::const_iterator i = gcObjects.begin(); i != gcObjects.end(); ++i)
{
GCObjectMultiSet reachable;
(*i)->__gcReachable(reachable);
for(GCObjectMultiSet::const_iterator j = reachable.begin(); j != reachable.end(); ++j)
{
--(counts.find(*j)->second);
}
}
}
//
// Any instances with a ref count > 0 are referenced from outside the set of class instances (and therefore
// reachable from the program, for example, via Ptr variable on the stack). Remove these reachable instances
// (and all instances reachable from them) from the overall set of objects.
//
{
GCObjectSet reachable;
for(ObjectCounts::const_iterator i = counts.begin(); i != counts.end(); ++i)
{
if(i->second > 0)
{
recursivelyReachable(i->first, reachable);
}
}
for(GCObjectSet::const_iterator j = reachable.begin(); j != reachable.end(); ++j)
{
counts.erase(*j);
}
}
//
// What is left in the counts set can be garbage collected.
//
{
ObjectCounts::const_iterator i;
for(i = counts.begin(); i != counts.end(); ++i)
{
i->first->__gcClear(); // Decrement ref count of objects pointed at by this object.
}
for(i = counts.begin(); i != counts.end(); ++i)
{
gcObjects.erase(i->first); // Remove this object from candidate set.
delete i->first; // Delete this object.
}
}
if(_statsCallback)
{
stats.msec = (Time::now() - t) * 1000.0L;
stats.collected = counts.size();
_statsCallback(stats);
}
//
// We clear explicitly under protection of the lock, instead of waiting for the
// counts destructor. This avoids lots of lock contention later because, otherwise,
// the destructor of each object in the counts set would acquire and release
// gcRecMutex._m.
//
counts.clear();
{
Monitor<Mutex>::Lock sync(*this);
_collecting = false;
}
}
|
