refPtrTracker.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_BASE_TF_REF_PTR_TRACKER_H
#define PXR_BASE_TF_REF_PTR_TRACKER_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/base/tf/api.h"
#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/hashmap.h"
#include "pxr/base/tf/weakBase.h"
#include "pxr/base/tf/singleton.h"
#include <iosfwd>
#include <mutex>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class TfRefBase;
template <class T> class TfRefPtr;
 
class TfRefPtrTracker : public TfWeakBase {
    TfRefPtrTracker(const TfRefPtrTracker&) = delete;
    TfRefPtrTracker& operator=(const TfRefPtrTracker&) = delete;
public:
    enum TraceType { Add, Assign };
 
    TF_API static TfRefPtrTracker& GetInstance()
    {
         return TfSingleton<TfRefPtrTracker>::GetInstance();
    }
 
    TF_API
    size_t GetStackTraceMaxDepth() const;
 
    TF_API
    void SetStackTraceMaxDepth(size_t);
 
    struct Trace {
        std::vector<uintptr_t> trace;
 
        const TfRefBase* obj;
 
        TraceType type;
    };
 
    typedef TfHashMap<const void*, Trace, TfHash> OwnerTraces;
 
    typedef TfHashMap<const TfRefBase*, size_t, TfHash> WatchedCounts;
 
    TF_API
    WatchedCounts GetWatchedCounts() const;
 
    TF_API
    OwnerTraces GetAllTraces() const;
 
    TF_API
    void ReportAllWatchedCounts(std::ostream& stream) const;
 
    TF_API
    void ReportAllTraces(std::ostream& stream) const;
 
    TF_API
    void ReportTracesForWatched(std::ostream& stream,
                                const TfRefBase* watched) const;
 
    static bool WatchNone(const void*)
    {
        return false;
    }
 
    static bool WatchAll(const void*)
    {
        return true;
    }
 
private:
    TfRefPtrTracker();
    ~TfRefPtrTracker();
 
    void _Watch(const TfRefBase* obj);
 
    void _Unwatch(const TfRefBase* obj);
 
    void _AddTrace(const void* owner, const TfRefBase* obj, TraceType = Add);
 
    void _RemoveTraces(const void* owner);
 
private:
    typedef std::mutex _Mutex;
    typedef std::lock_guard<std::mutex> _Lock;
    mutable _Mutex _mutex;
    size_t _maxDepth;
    WatchedCounts _watched;
    OwnerTraces _traces;
 
    friend class Tf_RefPtrTrackerUtil;
    friend class TfSingleton<TfRefPtrTracker>;
};
 
TF_API_TEMPLATE_CLASS(TfSingleton<TfRefPtrTracker>);
 
// For internal use only.
class Tf_RefPtrTrackerUtil {
public:
    static void Watch(const TfRefBase* obj)
    {
        TfRefPtrTracker::GetInstance()._Watch(obj);
    }
 
    static void Unwatch(const TfRefBase* obj)
    {
        TfRefPtrTracker::GetInstance()._Unwatch(obj);
    }
 
    static void AddTrace(const void* owner, const TfRefBase* obj,
                         TfRefPtrTracker::TraceType type = TfRefPtrTracker::Add)
    {
        TfRefPtrTracker::GetInstance()._AddTrace(owner, obj, type);
    }
 
    static void RemoveTraces(const void* owner)
    {
        TfRefPtrTracker::GetInstance()._RemoveTraces(owner);
    }
};
 
#define TF_DECLARE_REFPTR_TRACK(T)                                             \
    inline void                                                                \
    Tf_RefPtrTracker_FirstRef(const void*, const TfRefBase *obj, T*);          \
    inline void                                                                \
    Tf_RefPtrTracker_LastRef(const void*, const TfRefBase *obj, T*);           \
    inline void                                                                \
    Tf_RefPtrTracker_New(const void* owner, const TfRefBase *obj, T*);         \
    inline void                                                                \
    Tf_RefPtrTracker_Delete(const void* owner, const TfRefBase *obj, T*);      \
    inline void                                                                \
    Tf_RefPtrTracker_Assign(const void* owner,                                 \
                            const TfRefBase *obj, const TfRefBase *oldObj, T*);
 
#define TF_DEFINE_REFPTR_TRACK(T, COND)                                        \
    inline void                                                                \
    Tf_RefPtrTracker_FirstRef(const void*, const TfRefBase *obj, T*) {         \
        if (obj && COND(obj)) Tf_RefPtrTrackerUtil::Watch(obj);                \
    }                                                                          \
    inline void                                                                \
    Tf_RefPtrTracker_LastRef(const void*, const TfRefBase *obj, T*) {          \
        Tf_RefPtrTrackerUtil::Unwatch(obj);                                    \
    }                                                                          \
    inline void                                                                \
    Tf_RefPtrTracker_New(const void* owner, const TfRefBase *obj, T*) {        \
        Tf_RefPtrTrackerUtil::AddTrace(owner, obj);                            \
    }                                                                          \
    inline void                                                                \
    Tf_RefPtrTracker_Delete(const void* owner, const TfRefBase *obj, T*) {     \
        Tf_RefPtrTrackerUtil::RemoveTraces(owner);                             \
    }                                                                          \
    inline void                                                                \
    Tf_RefPtrTracker_Assign(const void* owner, const TfRefBase *obj,           \
                            const TfRefBase *oldObj, T*) {                     \
        if (oldObj != obj) {                                                   \
            Tf_RefPtrTrackerUtil::AddTrace(                                    \
                owner, obj, TfRefPtrTracker::Assign);                          \
        }                                                                      \
    }
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif