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
   73
   74
   75


base / allocator / dispatcher / dispatcher.h [blame]

// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef BASE_ALLOCATOR_DISPATCHER_DISPATCHER_H_
#define BASE_ALLOCATOR_DISPATCHER_DISPATCHER_H_

#include "base/allocator/dispatcher/internal/dispatcher_internal.h"
#include "base/base_export.h"

#include <memory>

namespace base::allocator::dispatcher {

namespace internal {
struct DispatchData;
}

// Dispatcher serves as the top level instance for managing the dispatch
// mechanism. The class instance manages connections to the various memory
// subsystems such as PartitionAlloc. To keep the public interface as lean as
// possible it uses a pimpl pattern.
class BASE_EXPORT Dispatcher {
 public:
  static Dispatcher& GetInstance();

  Dispatcher();

  // Initialize the dispatch mechanism with the given tuple of observers. The
  // observers must be valid (it is only DCHECKed internally at initialization,
  // but not verified further)
  // If Initialize is called multiple times, the first one wins. All later
  // invocations are silently ignored. Initialization is protected from
  // concurrent invocations. In case of concurrent accesses, the first one to
  // get the lock wins.
  // The dispatcher invokes following functions on the observers:
  // void OnAllocation(void* address,
  //                   size_t size,
  //                   AllocationSubsystem sub_system,
  //                   const char* type_name);
  // void OnFree(void* address);
  //
  // Note: The dispatcher mechanism does NOT bring systematic protection against
  // recursive invocations. That is, observers which allocate memory on the
  // heap, i.e. through dynamically allocated containers or by using the
  // CHECK-macro, are responsible to break these recursions!
  template <typename... ObserverTypes>
  void Initialize(const std::tuple<ObserverTypes...>& observers) {
    // Get the hooks for running these observers and pass them to further
    // initialization
    Initialize(internal::GetNotificationHooks(observers));
  }

  // The following functions provide an interface to setup and tear down the
  // dispatcher when testing. This must NOT be used from production code since
  // the hooks cannot be removed reliably under all circumstances.
  template <typename ObserverType>
  void InitializeForTesting(ObserverType* observer) {
    Initialize(std::make_tuple(observer));
  }

  void ResetForTesting();

 private:
  // structure and pointer to the private implementation.
  struct Impl;
  std::unique_ptr<Impl> const impl_;

  ~Dispatcher();

  void Initialize(const internal::DispatchData& dispatch_data);
};
}  // namespace base::allocator::dispatcher

#endif  // BASE_ALLOCATOR_DISPATCHER_DISPATCHER_H_