diff options
Diffstat (limited to 'chromium/components/metrics/leak_detector/call_stack_manager.h')
-rw-r--r-- | chromium/components/metrics/leak_detector/call_stack_manager.h | 102 |
1 files changed, 102 insertions, 0 deletions
diff --git a/chromium/components/metrics/leak_detector/call_stack_manager.h b/chromium/components/metrics/leak_detector/call_stack_manager.h new file mode 100644 index 00000000000..a411bcab8d9 --- /dev/null +++ b/chromium/components/metrics/leak_detector/call_stack_manager.h @@ -0,0 +1,102 @@ +// Copyright 2015 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef COMPONENTS_METRICS_LEAK_DETECTOR_CALL_STACK_MANAGER_H_ +#define COMPONENTS_METRICS_LEAK_DETECTOR_CALL_STACK_MANAGER_H_ + +#include <stddef.h> +#include <stdint.h> + +#include "base/containers/hash_tables.h" +#include "base/macros.h" +#include "components/metrics/leak_detector/custom_allocator.h" +#include "components/metrics/leak_detector/stl_allocator.h" + +// Summary of structures: +// +// struct CallStack: +// Represents a unique call stack, defined by its raw call stack (array of +// pointers), and hash value. All CallStack objects are owned by class +// CallStackManager. Other classes may hold pointers to them but should not +// attempt to create or modify any CallStack objects. +// +// class CallStackManager: +// Creates CallStack objects to represent unique call stacks. Owns all +// CallStack objects that it creates, storing them internally. +// +// Returns the call stacks as const pointers because no caller should take +// ownership of them and modify or delete them. The lifetime of all CallStack +// objects is limited to that of the CallStackManager object that created +// them. When the CallStackManager is destroyed, the CallStack objects will be +// invalidated. Hence the caller should make sure that it does not use +// CallStack objects beyond the lifetime of the CallStackManager that created +// them. + +namespace metrics { +namespace leak_detector { + +// Struct to represent a call stack. +struct CallStack { + // Call stack as an array of pointers, |stack|. The array length is stored in + // |depth|. There is no null terminator. + const void** stack; + size_t depth; + + // Hash of call stack. It is cached here so that it doesn not have to be + // recomputed each time. + size_t hash; +}; + +// Maintains and owns all unique call stack objects. +// Not thread-safe. +class CallStackManager { + public: + CallStackManager(); + ~CallStackManager(); + + // Returns a CallStack object for a given raw call stack. The first time a + // particular raw call stack is passed into this function, it will create a + // new CallStack object to hold the raw call stack data, and then return it. + // The CallStack object is stored internally. + // + // On subsequent calls with the same raw call stack, this function will return + // the previously created CallStack object. + const CallStack* GetCallStack(size_t depth, const void* const stack[]); + + size_t size() const { return call_stacks_.size(); } + + private: + // Allocator class for unique call stacks. Uses CustomAllocator to avoid + // recursive malloc hook invocation when analyzing allocs and frees. + using CallStackPointerAllocator = STLAllocator<CallStack*, CustomAllocator>; + + // Hash operator for call stack object given as a pointer. + // Does not actually compute the hash. Instead, returns the already computed + // hash value stored in a CallStack object. + struct CallStackPointerStoredHash { + size_t operator()(const CallStack* call_stack) const { + return call_stack->hash; + } + }; + + // Equality comparator for call stack objects given as pointers. Compares + // their stack trace contents. + struct CallStackPointerEqual { + bool operator()(const CallStack* c1, const CallStack* c2) const; + }; + + // Holds all call stack objects. Each object is allocated elsewhere and stored + // as a pointer because the container may rearrange itself internally. + base::hash_set<CallStack*, + CallStackPointerStoredHash, + CallStackPointerEqual, + CallStackPointerAllocator> call_stacks_; + + DISALLOW_COPY_AND_ASSIGN(CallStackManager); +}; + +} // namespace leak_detector +} // namespace metrics + +#endif // COMPONENTS_METRICS_LEAK_DETECTOR_CALL_STACK_MANAGER_H_ |