components/metrics/leak_detector/call_stack_manager.h

// 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_