1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
// 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.
#include "components/metrics/leak_detector/call_stack_manager.h"
#include <algorithm> // For std::copy.
#include <new>
#include "base/hash.h"
#include "components/metrics/leak_detector/custom_allocator.h"
namespace metrics {
namespace leak_detector {
CallStackManager::CallStackManager() {}
CallStackManager::~CallStackManager() {
// Free all call stack objects and clear |call_stacks_|. Make sure to save the
// CallStack object pointer and remove it from the container before freeing
// the CallStack memory.
while (!call_stacks_.empty()) {
CallStack* call_stack = *call_stacks_.begin();
call_stacks_.erase(call_stacks_.begin());
CustomAllocator::Free(call_stack->stack,
call_stack->depth * sizeof(*call_stack->stack));
call_stack->stack = nullptr;
call_stack->depth = 0;
CustomAllocator::Free(call_stack, sizeof(CallStack));
}
}
const CallStack* CallStackManager::GetCallStack(size_t depth,
const void* const stack[]) {
// Temporarily create a call stack object for lookup in |call_stacks_|.
CallStack temp;
temp.depth = depth;
temp.stack = const_cast<const void**>(stack);
// This is the only place where the call stack's hash is computed. This value
// can be reused in the created object to avoid further hash computation.
temp.hash =
base::Hash(reinterpret_cast<const char*>(stack), sizeof(*stack) * depth);
auto iter = call_stacks_.find(&temp);
if (iter != call_stacks_.end())
return *iter;
// Since |call_stacks_| stores CallStack pointers rather than actual objects,
// create new call objects manually here.
CallStack* call_stack =
new (CustomAllocator::Allocate(sizeof(CallStack))) CallStack;
call_stack->depth = depth;
call_stack->hash = temp.hash; // Don't run the hash function again.
call_stack->stack = reinterpret_cast<const void**>(
CustomAllocator::Allocate(sizeof(*stack) * depth));
std::copy(stack, stack + depth, call_stack->stack);
call_stacks_.insert(call_stack);
return call_stack;
}
bool CallStackManager::CallStackPointerEqual::operator()(
const CallStack* c1,
const CallStack* c2) const {
return c1->depth == c2->depth && c1->hash == c2->hash &&
std::equal(c1->stack, c1->stack + c1->depth, c2->stack);
}
} // namespace leak_detector
} // namespace metrics
|
