/*
 * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#ifndef SHARE_VM_SERVICES_MEM_BASELINE_HPP
#define SHARE_VM_SERVICES_MEM_BASELINE_HPP

#if INCLUDE_NMT

#include "memory/allocation.hpp"
#include "runtime/mutex.hpp"
#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 {
 public:
  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;

 public:
  // 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();
  }

  // reset the baseline for reuse
  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

#endif // SHARE_VM_SERVICES_MEM_BASELINE_HPP