1 /*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef RS_REF_BASE_H
18 #define RS_REF_BASE_H
19
20
21 #include <stdint.h>
22 #include <sys/types.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "StrongPointer.h"
27 #include "TypeHelpers.h"
28
29 // ---------------------------------------------------------------------------
30 namespace android{
31 namespace RSC {
32
33 class TextOutput;
34 TextOutput& printWeakPointer(TextOutput& to, const void* val);
35
36 // ---------------------------------------------------------------------------
37
38 #define COMPARE_WEAK(_op_) \
39 inline bool operator _op_ (const sp<T>& o) const { \
40 return m_ptr _op_ o.m_ptr; \
41 } \
42 inline bool operator _op_ (const T* o) const { \
43 return m_ptr _op_ o; \
44 } \
45 template<typename U> \
46 inline bool operator _op_ (const sp<U>& o) const { \
47 return m_ptr _op_ o.m_ptr; \
48 } \
49 template<typename U> \
50 inline bool operator _op_ (const U* o) const { \
51 return m_ptr _op_ o; \
52 }
53
54 // ---------------------------------------------------------------------------
55 class ReferenceMover;
56 class ReferenceConverterBase {
57 public:
58 virtual size_t getReferenceTypeSize() const = 0;
59 virtual void* getReferenceBase(void const*) const = 0;
~ReferenceConverterBase()60 inline virtual ~ReferenceConverterBase() { }
61 };
62
63 // ---------------------------------------------------------------------------
64
65 class RefBase
66 {
67 public:
68 void incStrong(const void* id) const;
69 void decStrong(const void* id) const;
70
71 void forceIncStrong(const void* id) const;
72
73 //! DEBUGGING ONLY: Get current strong ref count.
74 int32_t getStrongCount() const;
75
76 class weakref_type
77 {
78 public:
79 RefBase* refBase() const;
80
81 void incWeak(const void* id);
82 void decWeak(const void* id);
83
84 // acquires a strong reference if there is already one.
85 bool attemptIncStrong(const void* id);
86
87 // acquires a weak reference if there is already one.
88 // This is not always safe. see ProcessState.cpp and BpBinder.cpp
89 // for proper use.
90 bool attemptIncWeak(const void* id);
91
92 //! DEBUGGING ONLY: Get current weak ref count.
93 int32_t getWeakCount() const;
94
95 //! DEBUGGING ONLY: Print references held on object.
96 void printRefs() const;
97
98 //! DEBUGGING ONLY: Enable tracking for this object.
99 // enable -- enable/disable tracking
100 // retain -- when tracking is enable, if true, then we save a stack trace
101 // for each reference and dereference; when retain == false, we
102 // match up references and dereferences and keep only the
103 // outstanding ones.
104
105 void trackMe(bool enable, bool retain);
106 };
107
108 weakref_type* createWeak(const void* id) const;
109
110 weakref_type* getWeakRefs() const;
111
112 //! DEBUGGING ONLY: Print references held on object.
printRefs()113 inline void printRefs() const { getWeakRefs()->printRefs(); }
114
115 //! DEBUGGING ONLY: Enable tracking of object.
trackMe(bool enable,bool retain)116 inline void trackMe(bool enable, bool retain)
117 {
118 getWeakRefs()->trackMe(enable, retain);
119 }
120
121 typedef RefBase basetype;
122
123 protected:
124 RefBase();
125 virtual ~RefBase();
126
127 //! Flags for extendObjectLifetime()
128 enum {
129 OBJECT_LIFETIME_STRONG = 0x0000,
130 OBJECT_LIFETIME_WEAK = 0x0001,
131 OBJECT_LIFETIME_MASK = 0x0001
132 };
133
134 void extendObjectLifetime(int32_t mode);
135
136 //! Flags for onIncStrongAttempted()
137 enum {
138 FIRST_INC_STRONG = 0x0001
139 };
140
141 virtual void onFirstRef();
142 virtual void onLastStrongRef(const void* id);
143 virtual bool onIncStrongAttempted(uint32_t flags, const void* id);
144 virtual void onLastWeakRef(const void* id);
145
146 private:
147 friend class ReferenceMover;
148 static void moveReferences(void* d, void const* s, size_t n,
149 const ReferenceConverterBase& caster);
150
151 private:
152 friend class weakref_type;
153 class weakref_impl;
154
155 RefBase(const RefBase& o);
156 RefBase& operator=(const RefBase& o);
157
158 weakref_impl* const mRefs;
159 };
160
161 // ---------------------------------------------------------------------------
162
163 template <class T>
164 class LightRefBase
165 {
166 public:
LightRefBase()167 inline LightRefBase() : mCount(0) { }
incStrong(const void * id)168 inline void incStrong(__attribute__((unused)) const void* id) const {
169 __sync_fetch_and_add(&mCount, 1);
170 }
decStrong(const void * id)171 inline void decStrong(__attribute__((unused)) const void* id) const {
172 if (__sync_fetch_and_sub(&mCount, 1) == 1) {
173 delete static_cast<const T*>(this);
174 }
175 }
176 //! DEBUGGING ONLY: Get current strong ref count.
getStrongCount()177 inline int32_t getStrongCount() const {
178 return mCount;
179 }
180
181 typedef LightRefBase<T> basetype;
182
183 protected:
~LightRefBase()184 inline ~LightRefBase() { }
185
186 private:
187 friend class ReferenceMover;
moveReferences(void *,void const *,size_t,const ReferenceConverterBase &)188 inline static void moveReferences(void*, void const*, size_t,
189 const ReferenceConverterBase&) { }
190
191 private:
192 mutable volatile int32_t mCount;
193 };
194
195 // ---------------------------------------------------------------------------
196
197 template <typename T>
198 class wp
199 {
200 public:
201 typedef typename RefBase::weakref_type weakref_type;
202
wp()203 inline wp() : m_ptr(0) { }
204
205 explicit wp(T* other);
206 wp(const wp<T>& other);
207 explicit wp(const sp<T>& other);
208 template<typename U> explicit wp(U* other);
209 template<typename U> explicit wp(const sp<U>& other);
210 template<typename U> explicit wp(const wp<U>& other);
211
212 ~wp();
213
214 // Assignment
215
216 wp& operator = (T* other);
217 wp& operator = (const wp<T>& other);
218 wp& operator = (const sp<T>& other);
219
220 template<typename U> wp& operator = (U* other);
221 template<typename U> wp& operator = (const wp<U>& other);
222 template<typename U> wp& operator = (const sp<U>& other);
223
224 void set_object_and_refs(T* other, weakref_type* refs);
225
226 // promotion to sp
227
228 sp<T> promote() const;
229
230 // Reset
231
232 void clear();
233
234 // Accessors
235
get_refs()236 inline weakref_type* get_refs() const { return m_refs; }
237
unsafe_get()238 inline T* unsafe_get() const { return m_ptr; }
239
240 // Operators
241
242 COMPARE_WEAK(==)
243 COMPARE_WEAK(!=)
244 COMPARE_WEAK(>)
245 COMPARE_WEAK(<)
246 COMPARE_WEAK(<=)
247 COMPARE_WEAK(>=)
248
249 inline bool operator == (const wp<T>& o) const {
250 return (m_ptr == o.m_ptr) && (m_refs == o.m_refs);
251 }
252 template<typename U>
253 inline bool operator == (const wp<U>& o) const {
254 return m_ptr == o.m_ptr;
255 }
256
257 inline bool operator > (const wp<T>& o) const {
258 return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
259 }
260 template<typename U>
261 inline bool operator > (const wp<U>& o) const {
262 return (m_ptr == o.m_ptr) ? (m_refs > o.m_refs) : (m_ptr > o.m_ptr);
263 }
264
265 inline bool operator < (const wp<T>& o) const {
266 return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
267 }
268 template<typename U>
269 inline bool operator < (const wp<U>& o) const {
270 return (m_ptr == o.m_ptr) ? (m_refs < o.m_refs) : (m_ptr < o.m_ptr);
271 }
272 inline bool operator != (const wp<T>& o) const { return m_refs != o.m_refs; }
273 template<typename U> inline bool operator != (const wp<U>& o) const { return !operator == (o); }
274 inline bool operator <= (const wp<T>& o) const { return !operator > (o); }
275 template<typename U> inline bool operator <= (const wp<U>& o) const { return !operator > (o); }
276 inline bool operator >= (const wp<T>& o) const { return !operator < (o); }
277 template<typename U> inline bool operator >= (const wp<U>& o) const { return !operator < (o); }
278
279 private:
280 template<typename Y> friend class sp;
281 template<typename Y> friend class wp;
282
283 T* m_ptr;
284 weakref_type* m_refs;
285 };
286
287 template <typename T>
288 TextOutput& operator<<(TextOutput& to, const wp<T>& val);
289
290 #undef COMPARE_WEAK
291
292 // ---------------------------------------------------------------------------
293 // No user serviceable parts below here.
294
295 template<typename T>
wp(T * other)296 wp<T>::wp(T* other)
297 : m_ptr(other)
298 {
299 if (other) m_refs = other->createWeak(this);
300 }
301
302 template<typename T>
wp(const wp<T> & other)303 wp<T>::wp(const wp<T>& other)
304 : m_ptr(other.m_ptr), m_refs(other.m_refs)
305 {
306 if (m_ptr) m_refs->incWeak(this);
307 }
308
309 template<typename T>
wp(const sp<T> & other)310 wp<T>::wp(const sp<T>& other)
311 : m_ptr(other.m_ptr)
312 {
313 if (m_ptr) {
314 m_refs = m_ptr->createWeak(this);
315 }
316 }
317
318 template<typename T> template<typename U>
wp(U * other)319 wp<T>::wp(U* other)
320 : m_ptr(other)
321 {
322 if (other) m_refs = other->createWeak(this);
323 }
324
325 template<typename T> template<typename U>
wp(const wp<U> & other)326 wp<T>::wp(const wp<U>& other)
327 : m_ptr(other.m_ptr)
328 {
329 if (m_ptr) {
330 m_refs = other.m_refs;
331 m_refs->incWeak(this);
332 }
333 }
334
335 template<typename T> template<typename U>
wp(const sp<U> & other)336 wp<T>::wp(const sp<U>& other)
337 : m_ptr(other.m_ptr)
338 {
339 if (m_ptr) {
340 m_refs = m_ptr->createWeak(this);
341 }
342 }
343
344 template<typename T>
~wp()345 wp<T>::~wp()
346 {
347 if (m_ptr) m_refs->decWeak(this);
348 }
349
350 template<typename T>
351 wp<T>& wp<T>::operator = (T* other)
352 {
353 weakref_type* newRefs =
354 other ? other->createWeak(this) : 0;
355 if (m_ptr) m_refs->decWeak(this);
356 m_ptr = other;
357 m_refs = newRefs;
358 return *this;
359 }
360
361 template<typename T>
362 wp<T>& wp<T>::operator = (const wp<T>& other)
363 {
364 weakref_type* otherRefs(other.m_refs);
365 T* otherPtr(other.m_ptr);
366 if (otherPtr) otherRefs->incWeak(this);
367 if (m_ptr) m_refs->decWeak(this);
368 m_ptr = otherPtr;
369 m_refs = otherRefs;
370 return *this;
371 }
372
373 template<typename T>
374 wp<T>& wp<T>::operator = (const sp<T>& other)
375 {
376 weakref_type* newRefs =
377 other != NULL ? other->createWeak(this) : NULL;
378 T* otherPtr(other.m_ptr);
379 if (m_ptr) m_refs->decWeak(this);
380 m_ptr = otherPtr;
381 m_refs = newRefs;
382 return *this;
383 }
384
385 template<typename T> template<typename U>
386 wp<T>& wp<T>::operator = (U* other)
387 {
388 weakref_type* newRefs =
389 other ? other->createWeak(this) : NULL;
390 if (m_ptr) m_refs->decWeak(this);
391 m_ptr = other;
392 m_refs = newRefs;
393 return *this;
394 }
395
396 template<typename T> template<typename U>
397 wp<T>& wp<T>::operator = (const wp<U>& other)
398 {
399 weakref_type* otherRefs(other.m_refs);
400 U* otherPtr(other.m_ptr);
401 if (otherPtr) otherRefs->incWeak(this);
402 if (m_ptr) m_refs->decWeak(this);
403 m_ptr = otherPtr;
404 m_refs = otherRefs;
405 return *this;
406 }
407
408 template<typename T> template<typename U>
409 wp<T>& wp<T>::operator = (const sp<U>& other)
410 {
411 weakref_type* newRefs =
412 other != NULL ? other->createWeak(this) : NULL;
413 U* otherPtr(other.m_ptr);
414 if (m_ptr) m_refs->decWeak(this);
415 m_ptr = otherPtr;
416 m_refs = newRefs;
417 return *this;
418 }
419
420 template<typename T>
set_object_and_refs(T * other,weakref_type * refs)421 void wp<T>::set_object_and_refs(T* other, weakref_type* refs)
422 {
423 if (other) refs->incWeak(this);
424 if (m_ptr) m_refs->decWeak(this);
425 m_ptr = other;
426 m_refs = refs;
427 }
428
429 template<typename T>
promote()430 sp<T> wp<T>::promote() const
431 {
432 sp<T> result;
433 if (m_ptr && m_refs->attemptIncStrong(&result)) {
434 result.set_pointer(m_ptr);
435 }
436 return result;
437 }
438
439 template<typename T>
clear()440 void wp<T>::clear()
441 {
442 if (m_ptr) {
443 m_refs->decWeak(this);
444 m_ptr = 0;
445 }
446 }
447
448 template <typename T>
449 inline TextOutput& operator<<(TextOutput& to, const wp<T>& val)
450 {
451 return printWeakPointer(to, val.unsafe_get());
452 }
453
454 // ---------------------------------------------------------------------------
455
456 // this class just serves as a namespace so TYPE::moveReferences can stay
457 // private.
458
459 class ReferenceMover {
460 // StrongReferenceCast and WeakReferenceCast do the impedance matching
461 // between the generic (void*) implementation in Refbase and the strongly typed
462 // template specializations below.
463
464 template <typename TYPE>
465 struct StrongReferenceCast : public ReferenceConverterBase {
getReferenceTypeSizeStrongReferenceCast466 virtual size_t getReferenceTypeSize() const { return sizeof( sp<TYPE> ); }
getReferenceBaseStrongReferenceCast467 virtual void* getReferenceBase(void const* p) const {
468 sp<TYPE> const* sptr(reinterpret_cast<sp<TYPE> const*>(p));
469 return static_cast<typename TYPE::basetype *>(sptr->get());
470 }
471 };
472
473 template <typename TYPE>
474 struct WeakReferenceCast : public ReferenceConverterBase {
getReferenceTypeSizeWeakReferenceCast475 virtual size_t getReferenceTypeSize() const { return sizeof( wp<TYPE> ); }
getReferenceBaseWeakReferenceCast476 virtual void* getReferenceBase(void const* p) const {
477 wp<TYPE> const* sptr(reinterpret_cast<wp<TYPE> const*>(p));
478 return static_cast<typename TYPE::basetype *>(sptr->unsafe_get());
479 }
480 };
481
482 public:
483 template<typename TYPE> static inline
move_references(sp<TYPE> * d,sp<TYPE> const * s,size_t n)484 void move_references(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
485 memmove(d, s, n*sizeof(sp<TYPE>));
486 StrongReferenceCast<TYPE> caster;
487 TYPE::moveReferences(d, s, n, caster);
488 }
489 template<typename TYPE> static inline
move_references(wp<TYPE> * d,wp<TYPE> const * s,size_t n)490 void move_references(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
491 memmove(d, s, n*sizeof(wp<TYPE>));
492 WeakReferenceCast<TYPE> caster;
493 TYPE::moveReferences(d, s, n, caster);
494 }
495 };
496
497 // specialization for moving sp<> and wp<> types.
498 // these are used by the [Sorted|Keyed]Vector<> implementations
499 // sp<> and wp<> need to be handled specially, because they do not
500 // have trivial copy operation in the general case (see RefBase.cpp
501 // when DEBUG ops are enabled), but can be implemented very
502 // efficiently in most cases.
503
504 template<typename TYPE> inline
move_forward_type(sp<TYPE> * d,sp<TYPE> const * s,size_t n)505 void move_forward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
506 ReferenceMover::move_references(d, s, n);
507 }
508
509 template<typename TYPE> inline
move_backward_type(sp<TYPE> * d,sp<TYPE> const * s,size_t n)510 void move_backward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
511 ReferenceMover::move_references(d, s, n);
512 }
513
514 template<typename TYPE> inline
move_forward_type(wp<TYPE> * d,wp<TYPE> const * s,size_t n)515 void move_forward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
516 ReferenceMover::move_references(d, s, n);
517 }
518
519 template<typename TYPE> inline
move_backward_type(wp<TYPE> * d,wp<TYPE> const * s,size_t n)520 void move_backward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
521 ReferenceMover::move_references(d, s, n);
522 }
523
524
525 }; // namespace RSC
526 }; // namespace android
527 // ---------------------------------------------------------------------------
528
529 #endif // RS_REF_BASE_H
530