mallocTag.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_MALLOC_TAG_H
#define PXR_BASE_TF_MALLOC_TAG_H

#include "pxr/pxr.h"
#include "pxr/base/tf/api.h"

#include <cstdlib>
#include <iosfwd>
#include <stdint.h>
#include <string>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE


struct Tf_MallocPathNode;

class TfMallocTag {
public:
    struct CallStackInfo;

    struct CallTree {
        struct PathNode {
            size_t nBytes,          
                   nBytesDirect;    
            size_t nAllocations;    
            std::string siteName;   
            std::vector<PathNode>
                        children;   
        };

        struct CallSite {
            std::string name;       
            size_t nBytes;          
        };

        // Note: enum below must be kept in sync with tfmodule/mallocCallTree.h

        enum PrintSetting {
            TREE = 0,                   
            CALLSITES,                  
            BOTH                        
        };

        TF_API
        std::string GetPrettyPrintString(PrintSetting setting = BOTH,
                                         size_t maxPrintedNodes = 100000) const;

        TF_API
        void Report(
            std::ostream &out,
            const std::string &rootName) const;

        TF_API
        void Report(
            std::ostream &out) const;

        std::vector<CallSite> callSites;

        PathNode root;

        std::vector<CallStackInfo> capturedCallStacks;
    };

    struct CallStackInfo
    {
        std::vector<uintptr_t> stack;

        size_t size;

        size_t numAllocations;
    };

    TF_API static bool Initialize(std::string* errMsg);

    static bool IsInitialized() {
        return TfMallocTag::_doTagging;
    }

    TF_API static size_t GetTotalBytes();

    TF_API static size_t GetMaxTotalBytes();

    TF_API static bool GetCallTree(CallTree* tree, bool skipRepeated = true);

private:
    // Enum describing whether allocations are being tagged in an associated
    // thread.
    enum _Tagging {
        _TaggingEnabled,   // Allocations are being tagged
        _TaggingDisabled,  // Allocations are not being tagged

        _TaggingDormant    // Tagging has not been initialized in this
                           // thread as no malloc tags have been pushed onto
                           // the stack.
    };

    struct _ThreadData;

public:

    class Auto {
    public:
        Auto(const Auto &) = delete;
        Auto& operator=(const Auto &) = delete;

        Auto(Auto &&) = delete;
        Auto& operator=(Auto &&) = delete;

        Auto(const char* name) : _threadData(0) {
            if (TfMallocTag::_doTagging)
                _Begin(name);
        }

        Auto(const std::string& name) : _threadData(0) {
            if (TfMallocTag::_doTagging)
                _Begin(name);
        }

        inline void Release() {
            if (_threadData) {
                _End();
                _threadData = NULL;
            }
        }

        inline ~Auto() {
            Release();
        }

    private:
        TF_API void _Begin(const char* name);
        TF_API void _Begin(const std::string& name);
        TF_API void _End();

        _ThreadData* _threadData;

        friend class TfMallocTag;
    };

    class Auto2 {
    public:
        Auto2(const char* name1, const char* name2) :
            _tag1(name1),
            _tag2(name2)
        {
        }

        Auto2(const std::string& name1, const std::string& name2) :
            _tag1(name1),
            _tag2(name2)
        {
        }

        void Release() {
            _tag2.Release();
            _tag1.Release();
        }

    private:
        Auto _tag1;
        Auto _tag2;
    };

    static void Push(const std::string& name) {
        TfMallocTag::Auto noname(name);
        noname._threadData = NULL;  // disable destructor
    }

    static void Push(const char* name) {
        TfMallocTag::Auto noname(name);
        noname._threadData = NULL;  // disable destructor
    }

    TF_API static void Pop(const char* name = NULL);

    static void Pop(const std::string& name) {
        Pop(name.c_str());
    }

    TF_API static void SetDebugMatchList(const std::string& matchList);

    TF_API static void SetCapturedMallocStacksMatchList(const std::string& matchList);

    TF_API static std::vector<std::vector<uintptr_t> > GetCapturedMallocStacks();

private:
    friend struct Tf_MallocGlobalData;
    
    class _TemporaryTaggingState {
    public:
        explicit _TemporaryTaggingState(_Tagging state);
        ~_TemporaryTaggingState();

        _TemporaryTaggingState(const _TemporaryTaggingState &);
        _TemporaryTaggingState& operator=(const _TemporaryTaggingState &);

        _TemporaryTaggingState(_TemporaryTaggingState &&);
        _TemporaryTaggingState& operator=(_TemporaryTaggingState &&);

    private:
        _Tagging _oldState;
    };

    static void _SetTagging(_Tagging state);
    static _Tagging _GetTagging();

    static bool _Initialize(std::string* errMsg);

    static inline bool _ShouldNotTag(_ThreadData**, _Tagging* t = NULL);
    static inline Tf_MallocPathNode* _GetCurrentPathNodeNoLock(
        const _ThreadData* threadData);

    static void* _MallocWrapper_ptmalloc(size_t, const void*);
    static void* _ReallocWrapper_ptmalloc(void*, size_t, const void*);
    static void* _MemalignWrapper_ptmalloc(size_t, size_t, const void*);
    static void  _FreeWrapper_ptmalloc(void*, const void*);

    static void* _MallocWrapper(size_t, const void*);
    static void* _ReallocWrapper(void*, size_t, const void*);
    static void* _MemalignWrapper(size_t, size_t, const void*);
    static void  _FreeWrapper(void*, const void*);

    friend class TfMallocTag::Auto;
    class Tls;
    friend class TfMallocTag::Tls;
    TF_API static bool _doTagging;
};

typedef TfMallocTag::Auto TfAutoMallocTag;

typedef TfMallocTag::Auto2 TfAutoMallocTag2;

//
PXR_NAMESPACE_CLOSE_SCOPE                                                 

#define TF_MALLOC_TAG_NEW(name1, name2)                                       \
    /* this is for STL purposes */                                            \
    inline void* operator new(::std::size_t, void* ptr) {                     \
        return ptr;                                                           \
    }                                                                         \
                                                                              \
    inline void* operator new(::std::size_t s) {                              \
        PXR_NS::TfAutoMallocTag tag1(name1);                                  \
        PXR_NS::TfAutoMallocTag tag2(name2);                                  \
        return malloc(s);                                                     \
    }                                                                         \
                                                                              \
    inline void* operator new[](::std::size_t s) {                            \
        PXR_NS::TfAutoMallocTag tag1(name1);                                  \
        PXR_NS::TfAutoMallocTag tag2(name2);                                  \
        return malloc(s);                                                     \
    }                                                                         \
                                                                              \
    /* Required due to the placement-new override above. */                   \
    inline void operator delete(void* ptr, void* place) {}                    \
                                                                              \
    inline void operator delete(void* ptr, size_t) {                          \
        free(ptr);                                                            \
    }                                                                         \
                                                                              \
    inline void operator delete[] (void* ptr, size_t) {                       \
        free(ptr);                                                            \
    }                                                                         \

#endif