skia2/include/core/SkInstCnt.h
2015-02-02 13:24:37 -08:00

83 lines
2.9 KiB
C++

/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkInstCnt_DEFINED
#define SkInstCnt_DEFINED
/* To count all instances of T, including all subclasses of T,
* add SK_DECLARE_INST_COUNT(T) to T's class definition.
* If you want to print out counts of leaked instances, set gPrintInstCount to true in main().
*
* E.g.
* struct Base { SK_DECLARE_INST_COUNT(Base) };
* struct A : public Base {};
* struct SubBase : public Base { SK_DECLARE_INST_COUNT(SubBase); }
* struct B : public SubBase {};
*
* If gPrintInstCount is true, at the program exit you will see something like:
* Base: <N> leaked instances
* SubBase: <M> leaked instances
* where N >= M. Leaked instances of A count against Base; leaked instances of B count against
* both SubBase and Base.
*
* If SK_ENABLE_INST_COUNT is not defined or defined to 0, or we're in a shared library build,
* this entire system is compiled away to a noop.
*/
#include "SkTypes.h"
#if SK_ENABLE_INST_COUNT && !defined(SKIA_DLL) // See skia:2058 for why we noop on shared builds.
#include "SkThread.h"
#include <stdlib.h>
#define SK_DECLARE_INST_COUNT(T) \
static const char* InstCountClassName() { return #T; } \
SkInstCount<T, T::InstCountClassName> fInstCnt; \
static int32_t GetInstanceCount() { return SkInstCount<T, InstCountClassName>::Count(); }
extern bool gPrintInstCount;
template <typename T, const char*(Name)()>
class SkInstCount {
public:
SkInstCount() { Inc(); }
SkInstCount(const SkInstCount&) { Inc(); }
~SkInstCount() { sk_atomic_dec(&gCount); }
SkInstCount& operator==(const SkInstCount&) { return *this; } // == can't change the count.
static void Inc() {
// If it's the first time we go from 0 to 1, register to print leaks at process exit.
if (0 == sk_atomic_inc(&gCount) && sk_atomic_cas(&gRegistered, 0, 1)) {
atexit(PrintAtExit);
}
}
static void PrintAtExit() {
int32_t leaks = Count();
if (gPrintInstCount && leaks > 0) {
SkDebugf("Leaked %s: %d\n", Name(), leaks);
}
}
// FIXME: Used publicly by unit tests. Seems like a bad idea in a DM world.
static int32_t Count() { return sk_acquire_load(&gCount); }
private:
static int32_t gCount, gRegistered;
};
// As template values, these will be deduplicated. (No one-definition rule problems.)
template <typename T, const char*(Name)()> int32_t SkInstCount<T, Name>::gCount = 0;
template <typename T, const char*(Name)()> int32_t SkInstCount<T, Name>::gRegistered = 0;
#else
#define SK_DECLARE_INST_COUNT(T)
#endif
void SkInstCountPrintLeaksOnExit();
#endif // SkInstCnt_DEFINED