* Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.

#if INCLUDE_NMT

#include "services/mallocSiteTable.hpp"

#include "services/mallocTracker.hpp"

#include "services/nmtCommon.hpp"

#include "services/virtualMemoryTracker.hpp"

#include "utilities/linkedlist.hpp"

typedef LinkedListIterator<MallocSite>                   MallocSiteIterator;

typedef LinkedListIterator<VirtualMemoryAllocationSite>  VirtualMemorySiteIterator;

typedef LinkedListIterator<ReservedMemoryRegion>         VirtualMemoryAllocationIterator;

 * Baseline a memory snapshot

class MemBaseline VALUE_OBJ_CLASS_SPEC {

  enum BaselineThreshold {

    SIZE_THRESHOLD = K        // Only allocation size over this threshold will be baselined.

  };

  enum BaselineType {

    Not_baselined,

    Summary_baselined,

    Detail_baselined

  };

  enum SortingOrder {

    by_address,   // by memory address

    by_size,      // by memory size

    by_site       // by call site where the memory is allocated from

 private:

  // All baseline data is stored in this arena

  Arena*                  _arena;

  // Summary information

  MallocMemorySnapshot*   _malloc_memory_snapshot;

  VirtualMemorySnapshot*  _virtual_memory_snapshot;

  size_t               _class_count;

  // Allocation sites information

  // Malloc allocation sites

  LinkedListImpl<MallocSite, ResourceObj::ARENA>

                       _malloc_sites;

  // All virtual memory allocations

  LinkedListImpl<ReservedMemoryRegion, ResourceObj::ARENA>

                       _virtual_memory_allocations;

  // Virtual memory allocations by allocation sites, always in by_address

  // order

  LinkedListImpl<VirtualMemoryAllocationSite, ResourceObj::ARENA>

                       _virtual_memory_sites;

  SortingOrder         _malloc_sites_order;

  SortingOrder         _virtual_memory_sites_order;

  BaselineType         _baseline_type;

  // create a memory baseline

  MemBaseline():

    _baseline_type(Not_baselined),

    _class_count(0),

    _arena(NULL),

    _malloc_memory_snapshot(NULL),

    _virtual_memory_snapshot(NULL),

    _malloc_sites(NULL) {

  ~MemBaseline() {

    reset();

    if (_arena != NULL) {

      delete _arena;

    }

  bool baseline(bool summaryOnly = true);

  BaselineType baseline_type() const { return _baseline_type; }

  MallocMemorySnapshot* malloc_memory_snapshot() const {

    return _malloc_memory_snapshot;

  VirtualMemorySnapshot* virtual_memory_snapshot() const {

    return _virtual_memory_snapshot;

  MallocSiteIterator malloc_sites(SortingOrder order);

  VirtualMemorySiteIterator virtual_memory_sites(SortingOrder order);

  // Virtual memory allocation iterator always returns in virtual memory

  // base address order.

  VirtualMemoryAllocationIterator virtual_memory_allocations() {

    assert(!_virtual_memory_allocations.is_empty(), "Not detail baseline");

    return VirtualMemoryAllocationIterator(_virtual_memory_allocations.head());

  // Total reserved memory = total malloc'd memory + total reserved virtual

  // memory

  size_t total_reserved_memory() const {

    assert(baseline_type() != Not_baselined, "Not yet baselined");

    assert(_virtual_memory_snapshot != NULL, "No virtual memory snapshot");

    assert(_malloc_memory_snapshot != NULL,  "No malloc memory snapshot");

    size_t amount = _malloc_memory_snapshot->total() +

           _virtual_memory_snapshot->total_reserved();

    return amount;

  // Total committed memory = total malloc'd memory + total committed

  // virtual memory

  size_t total_committed_memory() const {

    assert(baseline_type() != Not_baselined, "Not yet baselined");

    assert(_virtual_memory_snapshot != NULL,

      "Not a snapshot");

    size_t amount = _malloc_memory_snapshot->total() +

           _virtual_memory_snapshot->total_committed();

    return amount;

  size_t total_arena_memory() const {

    assert(baseline_type() != Not_baselined, "Not yet baselined");

    assert(_malloc_memory_snapshot != NULL, "Not yet baselined");

    return _malloc_memory_snapshot->total_arena();

  size_t malloc_tracking_overhead() const {

    assert(baseline_type() != Not_baselined, "Not yet baselined");

    return _malloc_memory_snapshot->malloc_overhead()->size();

  const MallocMemory* malloc_memory(MEMFLAGS flag) const {

    assert(_malloc_memory_snapshot != NULL, "Not a snapshot");

    return _malloc_memory_snapshot->by_type(flag);

  const VirtualMemory* virtual_memory(MEMFLAGS flag) const {

    assert(_virtual_memory_snapshot != NULL, "Not a snapshot");

    return _virtual_memory_snapshot->by_type(flag);

  size_t class_count() const {

    assert(baseline_type() != Not_baselined, "Not yet baselined");

    return _class_count;

  size_t thread_count() const {

    assert(baseline_type() != Not_baselined, "Not yet baselined");

    assert(_malloc_memory_snapshot != NULL, "Baselined?");

    return _malloc_memory_snapshot->thread_count();

  void reset() {

    _baseline_type = Not_baselined;

    _malloc_memory_snapshot = NULL;

    _virtual_memory_snapshot = NULL;

    _class_count  = 0;

    _malloc_sites = NULL;

    _virtual_memory_sites = NULL;

    _virtual_memory_allocations = NULL;

    if (_arena != NULL) {

      _arena->destruct_contents();

    }

 private:

  // Baseline summary information

  bool baseline_summary();

  // Baseline allocation sites (detail tracking only)

  bool baseline_allocation_sites();

  // Aggregate virtual memory allocation by allocation sites

  bool aggregate_virtual_memory_allocation_sites();

  Arena* arena() { return _arena; }

  // Sorting allocation sites in different orders

  // Sort allocation sites in size order

  void malloc_sites_to_size_order();

  // Sort allocation sites in call site address order

  void malloc_sites_to_allocation_site_order();

  // Sort allocation sites in reserved size order

  void virtual_memory_sites_to_size_order();

  // Sort allocation sites in call site address order

  void virtual_memory_sites_to_reservation_site_order();

#endif // INCLUDE_NMT