// Copyright (c) 2005, Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // --- // Author: Sanjay Ghemawat // // Extra extensions exported by some malloc implementations. These // extensions are accessed through a virtual base class so an // application can link against a malloc that does not implement these // extensions, and it will get default versions that do nothing. #ifndef BASE_MALLOC_EXTENSION_H__ #define BASE_MALLOC_EXTENSION_H__ #include #include // Annoying stuff for windows -- makes sure clients can import these functions #ifndef PERFTOOLS_DLL_DECL # ifdef WIN32 # define PERFTOOLS_DLL_DECL __declspec(dllimport) # else # define PERFTOOLS_DLL_DECL # endif #endif static const int kMallocHistogramSize = 64; // The default implementations of the following routines do nothing. class PERFTOOLS_DLL_DECL MallocExtension { public: virtual ~MallocExtension(); // Call this very early in the program execution -- say, in a global // constructor -- to set up parameters and state needed by all // instrumented malloc implemenatations. One example: this routine // sets environemnt variables to tell STL to use libc's malloc() // instead of doing its own memory management. This is safe to call // multiple times, as long as each time is before threads start up. static void Initialize(); // See "verify_memory.h" to see what these routines do virtual bool VerifyAllMemory(); virtual bool VerifyNewMemory(void* p); virtual bool VerifyArrayNewMemory(void* p); virtual bool VerifyMallocMemory(void* p); virtual bool MallocMemoryStats(int* blocks, size_t* total, int histogram[kMallocHistogramSize]); // Get a human readable description of the current state of the malloc // data structures. The state is stored as a null-terminated string // in a prefix of "buffer[0,buffer_length-1]". // REQUIRES: buffer_length > 0. virtual void GetStats(char* buffer, int buffer_length); // Get a string that contains a sample of live objects and the stack // traces that allocated these objects. The format of the returned // string is equivalent to the output of the heap profiler and can // therefore be passed to "pprof". // // The generated data is *appended* to "*result". I.e., the old // contents of "*result" are preserved. virtual void GetHeapSample(std::string* result); // Get a string that contains the stack traces that caused growth in // the addres sspace size. The format of the returned string is // equivalent to the output of the heap profiler and can therefore // be passed to "pprof". // // The generated data is *appended* to "*result". I.e., the old // contents of "*result" are preserved. virtual void GetHeapGrowthStacks(std::string* result); // ------------------------------------------------------------------- // Control operations for getting and setting malloc implementation // specific parameters. Some currently useful properties: // // generic // ------- // "generic.current_allocated_bytes" // Number of bytes currently allocated by application // This property is not writable. // // "generic.heap_size" // Number of bytes in the heap == // current_allocated_bytes + // fragmentation + // freed memory regions // This property is not writable. // // tcmalloc // -------- // "tcmalloc.max_total_thread_cache_bytes" // Upper limit on total number of bytes stored across all // per-thread caches. Default: 16MB. // // "tcmalloc.current_total_thread_cache_bytes" // Number of bytes used across all thread caches. // This property is not writable. // // "tcmalloc.slack_bytes" // Number of bytes allocated from system, but not currently // in use by malloced objects. I.e., bytes available for // allocation without needing more bytes from system. // This property is not writable. // // TODO: Add more properties as necessary // ------------------------------------------------------------------- // Get the named "property"'s value. Returns true if the property // is known. Returns false if the property is not a valid property // name for the current malloc implementation. // REQUIRES: property != NULL; value != NULL virtual bool GetNumericProperty(const char* property, size_t* value); // Set the named "property"'s value. Returns true if the property // is known and writable. Returns false if the property is not a // valid property name for the current malloc implementation, or // is not writable. // REQUIRES: property != NULL virtual bool SetNumericProperty(const char* property, size_t value); // Mark the current thread as "idle". This routine may optionally // be called by threads as a hint to the malloc implementation that // any thread-specific resources should be released. Note: this may // be an expensive routine, so it should not be called too often. // // Also, if the code that calls this routine will go to sleep for // a while, it should take care to not allocate anything between // the call to this routine and the beginning of the sleep. // // Most malloc implementations ignore this routine. virtual void MarkThreadIdle(); // Try to free memory back to the operating system for reuse. Only // use this extension if the application has recently freed a lot of // memory, and does not anticipate using it again for a long time -- // to get this memory back may require faulting pages back in by the // OS, and that may be slow. (Currently only implemented in // tcmalloc.) virtual void ReleaseFreeMemory(); // The current malloc implementation. Always non-NULL. static MallocExtension* instance(); // Change the malloc implementation. Typically called by the // malloc implementation during initialization. static void Register(MallocExtension* implementation); protected: // Get a list of stack traces of sampled allocation points. // Returns a pointer to a "new[]-ed" result array. // // The state is stored as a sequence of adjacent entries // in the returned array. Each entry has the following form: // uintptr_t count; // Number of objects with following trace // uintptr_t size; // Size of object // uintptr_t depth; // Number of PC values in stack trace // void* stack[depth]; // PC values that form the stack trace // // The list of entries is terminated by a "count" of 0. // // It is the responsibility of the caller to "delete[]" the returned array. // // May return NULL to indicate no results. // // This is an internal extension. Callers should use the more // convenient "GetHeapSample(string*)" method defined above. virtual void** ReadStackTraces(); // Like ReadStackTraces(), but returns stack traces that caused growth // in the address space size. virtual void** ReadHeapGrowthStackTraces(); }; #endif // BASE_MALLOC_EXTENSION_H__