refPtrTracker.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache 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 <boost/noncopyable.hpp>
#include <iosfwd>
#include <mutex>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

class TfRefBase;
template <class T> class TfRefPtr;

class TfRefPtrTracker : public TfWeakBase, boost::noncopyable {
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*, T* obj);                 \
inline void Tf_RefPtrTracker_LastRef(const void*, T* obj);                  \
inline void Tf_RefPtrTracker_New(const void* owner, T* obj);                \
inline void Tf_RefPtrTracker_Delete(const void* owner, T* obj);             \
inline void Tf_RefPtrTracker_Assign(const void* owner, T* obj, T* oldObj);

#define TF_DEFINE_REFPTR_TRACK(T, COND)                                     \
inline void Tf_RefPtrTracker_FirstRef(const void*, T* obj) {                \
    if (obj && COND(obj)) Tf_RefPtrTrackerUtil::Watch(obj);                \
}                                                                           \
inline void Tf_RefPtrTracker_LastRef(const void*, T* obj) {                 \
    Tf_RefPtrTrackerUtil::Unwatch(obj);                                     \
}                                                                           \
inline void Tf_RefPtrTracker_New(const void* owner, T* obj) {               \
    Tf_RefPtrTrackerUtil::AddTrace(owner, obj);                             \
}                                                                           \
inline void Tf_RefPtrTracker_Delete(const void* owner, T* obj) {            \
    Tf_RefPtrTrackerUtil::RemoveTraces(owner);                              \
}                                                                           \
inline void Tf_RefPtrTracker_Assign(const void* owner, T* obj, T* oldObj) { \
    if (oldObj != obj) {                                                    \
        Tf_RefPtrTrackerUtil::AddTrace(owner, obj, TfRefPtrTracker::Assign);\
    }                                                                       \
}

PXR_NAMESPACE_CLOSE_SCOPE

#endif