/*

 * Copyright (c) 2012, 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_PTR_HPP

#define SHARE_VM_SERVICES_MEM_PTR_HPP

#include "memory/allocation.hpp"

#include "runtime/atomic.hpp"

#include "runtime/os.hpp"

#include "runtime/safepoint.hpp"

/*

 * global sequence generator that generates sequence numbers to serialize

 * memory records.

 */

class SequenceGenerator : AllStatic {

 public:

  static jint next();

  // peek last sequence number

  static jint peek() {

    return _seq_number;

  }

  // reset sequence number

  static void reset() {

    assert(SafepointSynchronize::is_at_safepoint(), "Safepoint required");

    _seq_number = 1;

    DEBUG_ONLY(_generation ++;)

  };

  DEBUG_ONLY(static unsigned long current_generation() { return (unsigned long)_generation; })

  DEBUG_ONLY(static jint max_seq_num() { return _max_seq_number; })

 private:

  static volatile jint _seq_number;

  DEBUG_ONLY(static jint _max_seq_number; )

  DEBUG_ONLY(static volatile unsigned long _generation; )

};

/*

 * followings are the classes that are used to hold memory activity records in different stages.

 *   MemPointer

 *     |--------MemPointerRecord

 *                     |

 *                     |----MemPointerRecordEx

 *                     |           |

 *                     |           |-------SeqMemPointerRecordEx

 *                     |

 *                     |----SeqMemPointerRecord

 *                     |

 *                     |----VMMemRegion

 *                               |

 *                               |-----VMMemRegionEx

 *

 *

 *  prefix 'Seq' - sequenced, the record contains a sequence number

 *  surfix 'Ex'  - extension, the record contains a caller's pc

 *

 *  per-thread recorder : SeqMemPointerRecord(Ex)

 *  snapshot staging    : SeqMemPointerRecord(Ex)

 *  snapshot            : MemPointerRecord(Ex) and VMMemRegion(Ex)

 *

 */

/*

 * class that wraps an address to a memory block,

 * the memory pointer either points to a malloc'd

 * memory block, or a mmap'd memory block

 */

class MemPointer : public _ValueObj {

 public:

  MemPointer(): _addr(0) { }

  MemPointer(address addr): _addr(addr) { }

  MemPointer(const MemPointer& copy_from) {

    _addr = copy_from.addr();

  }

  inline address addr() const {

    return _addr;

  }

  inline operator address() const {

    return addr();

  }

  inline bool operator == (const MemPointer& other) const {

    return addr() == other.addr();

  }

  inline MemPointer& operator = (const MemPointer& other) {

    _addr = other.addr();

    return *this;

  }

 protected:

  inline void set_addr(address addr) { _addr = addr; }

 protected:

  // memory address

  address    _addr;

};

/* MemPointerRecord records an activityand associated

 * attributes on a memory block.

 */

class MemPointerRecord : public MemPointer {

 private:

  MEMFLAGS       _flags;

  size_t         _size;

public:

  /* extension of MemoryType enum

   * see share/vm/memory/allocation.hpp for details.

   *

   * The tag values are associated to sorting orders, so be

   * careful if changes are needed.

   * The allocation records should be sorted ahead of tagging

   * records, which in turn ahead of deallocation records

   */

  enum MemPointerTags {

    tag_alloc            = 0x0001, // malloc or reserve record

    tag_commit           = 0x0002, // commit record

    tag_type             = 0x0003, // tag virtual memory to a memory type

    tag_uncommit         = 0x0004, // uncommit record

    tag_release          = 0x0005, // free or release record

    tag_size             = 0x0006, // arena size

    tag_masks            = 0x0007, // all tag bits

    vmBit                = 0x0008

  };

  /* helper functions to interpret the tagging flags */

  inline static bool is_allocation_record(MEMFLAGS flags) {

    return (flags & tag_masks) == tag_alloc;

  }

  inline static bool is_deallocation_record(MEMFLAGS flags) {

    return (flags & tag_masks) == tag_release;

  }

  inline static bool is_arena_record(MEMFLAGS flags) {

    return (flags & (otArena | tag_size)) == otArena;

  }

  inline static bool is_arena_size_record(MEMFLAGS flags) {

    return (flags & (otArena | tag_size)) == (otArena | tag_size);

  }

  inline static bool is_virtual_memory_record(MEMFLAGS flags) {

    return (flags & vmBit) != 0;

  }

  inline static bool is_virtual_memory_reserve_record(MEMFLAGS flags) {

    return (flags & 0x0F) == (tag_alloc | vmBit);

  }

  inline static bool is_virtual_memory_commit_record(MEMFLAGS flags) {

    return (flags & 0x0F) == (tag_commit | vmBit);

  }

  inline static bool is_virtual_memory_uncommit_record(MEMFLAGS flags) {

    return (flags & 0x0F) == (tag_uncommit | vmBit);

  }

  inline static bool is_virtual_memory_release_record(MEMFLAGS flags) {

    return (flags & 0x0F) == (tag_release | vmBit);

  }

  inline static bool is_virtual_memory_type_record(MEMFLAGS flags) {

    return (flags & 0x0F) == (tag_type | vmBit);

  }

  /* tagging flags */

  inline static MEMFLAGS malloc_tag()                 { return tag_alloc;   }

  inline static MEMFLAGS free_tag()                   { return tag_release; }

  inline static MEMFLAGS arena_size_tag()             { return tag_size | otArena; }

  inline static MEMFLAGS virtual_memory_tag()         { return vmBit; }

  inline static MEMFLAGS virtual_memory_reserve_tag() { return (tag_alloc | vmBit); }

  inline static MEMFLAGS virtual_memory_commit_tag()  { return (tag_commit | vmBit); }

  inline static MEMFLAGS virtual_memory_uncommit_tag(){ return (tag_uncommit | vmBit); }

  inline static MEMFLAGS virtual_memory_release_tag() { return (tag_release | vmBit); }

  inline static MEMFLAGS virtual_memory_type_tag()    { return (tag_type | vmBit); }

 public:

  MemPointerRecord(): _size(0), _flags(mtNone) { }

  MemPointerRecord(address addr, MEMFLAGS memflags, size_t size = 0):

      MemPointer(addr), _flags(memflags), _size(size) { }

  MemPointerRecord(const MemPointerRecord& copy_from):

    MemPointer(copy_from), _flags(copy_from.flags()),

    _size(copy_from.size()) {

  }

  /* MemPointerRecord is not sequenced, it always return

   * 0 to indicate non-sequenced

   */

  virtual jint seq() const               { return 0; }

  inline size_t   size()  const          { return _size; }

  inline void set_size(size_t size)      { _size = size; }

  inline MEMFLAGS flags() const          { return _flags; }

  inline void set_flags(MEMFLAGS flags)  { _flags = flags; }

  MemPointerRecord& operator= (const MemPointerRecord& ptr) {

    MemPointer::operator=(ptr);

    _flags = ptr.flags();

#ifdef ASSERT

    if (IS_ARENA_OBJ(_flags)) {

      assert(!is_vm_pointer(), "wrong flags");

      assert((_flags & ot_masks) == otArena, "wrong flags");

    }

#endif

    _size = ptr.size();

    return *this;

  }

  // if the pointer represents a malloc-ed memory address

  inline bool is_malloced_pointer() const {

    return !is_vm_pointer();

  }

  // if the pointer represents a virtual memory address

  inline bool is_vm_pointer() const {

    return is_virtual_memory_record(_flags);

  }

  // if this record records a 'malloc' or virtual memory

  // 'reserve' call

  inline bool is_allocation_record() const {

    return is_allocation_record(_flags);

  }

  // if this record records a size information of an arena

  inline bool is_arena_size_record() const {

    return is_arena_size_record(_flags);

  }

  // if this pointer represents an address to an arena object

  inline bool is_arena_record() const {

    return is_arena_record(_flags);

  }

  // if this record represents a size information of specific arena

  inline bool is_size_record_of_arena(const MemPointerRecord* arena_rc) {

    assert(is_arena_size_record(), "not size record");

    assert(arena_rc->is_arena_record(), "not arena record");

    return (arena_rc->addr() + sizeof(void*)) == addr();

  }

  // if this record records a 'free' or virtual memory 'free' call

  inline bool is_deallocation_record() const {

    return is_deallocation_record(_flags);

  }

  // if this record records a virtual memory 'commit' call

  inline bool is_commit_record() const {

    return is_virtual_memory_commit_record(_flags);

  }

  // if this record records a virtual memory 'uncommit' call

  inline bool is_uncommit_record() const {

    return is_virtual_memory_uncommit_record(_flags);

  }

  // if this record is a tagging record of a virtual memory block

  inline bool is_type_tagging_record() const {

    return is_virtual_memory_type_record(_flags);

  }

};

// MemPointerRecordEx also records callsite pc, from where

// the memory block is allocated

class MemPointerRecordEx : public MemPointerRecord {

 private:

  address      _pc;  // callsite pc

 public:

  MemPointerRecordEx(): _pc(0) { }

  MemPointerRecordEx(address addr, MEMFLAGS memflags, size_t size = 0, address pc = 0):

    MemPointerRecord(addr, memflags, size), _pc(pc) {}

  MemPointerRecordEx(const MemPointerRecordEx& copy_from):

    MemPointerRecord(copy_from), _pc(copy_from.pc()) {}

  inline address pc() const { return _pc; }

  void init(const MemPointerRecordEx* mpe) {

    MemPointerRecord::operator=(*mpe);

    _pc = mpe->pc();

  }

  void init(const MemPointerRecord* mp) {

    MemPointerRecord::operator=(*mp);

    _pc = 0;

  }

};

// a virtual memory region

class VMMemRegion : public MemPointerRecord {

 private:

  // committed size

  size_t       _committed_size;

public:

  VMMemRegion(): _committed_size(0) { }

  void init(const MemPointerRecord* mp) {

    assert(mp->is_vm_pointer(), "not virtual memory pointer");

    _addr = mp->addr();

    if (mp->is_commit_record() || mp->is_uncommit_record()) {

      _committed_size = mp->size();

      set_size(_committed_size);

    } else {

      set_size(mp->size());

      _committed_size = 0;

    }

    set_flags(mp->flags());

  }

  VMMemRegion& operator=(const VMMemRegion& other) {

    MemPointerRecord::operator=(other);

    _committed_size = other.committed_size();

    return *this;

  }

  inline bool is_reserve_record() const {

    return is_virtual_memory_reserve_record(flags());

  }

  inline bool is_release_record() const {

    return is_virtual_memory_release_record(flags());

  }

  // resize reserved VM range

  inline void set_reserved_size(size_t new_size) {

    assert(new_size >= committed_size(), "resize");

    set_size(new_size);

  }

  inline void commit(size_t size) {

    _committed_size += size;

  }

  inline void uncommit(size_t size) {

    if (_committed_size >= size) {

      _committed_size -= size;

    } else {

      _committed_size = 0;

    }

  }

  /*

   * if this virtual memory range covers whole range of

   * the other VMMemRegion

   */

  bool contains(const VMMemRegion* mr) const;

  /* base address of this virtual memory range */

  inline address base() const {

    return addr();

  }

  /* tag this virtual memory range to the specified memory type */

  inline void tag(MEMFLAGS f) {

    set_flags(flags() | (f & mt_masks));

  }

  // release part of memory range

  inline void partial_release(address add, size_t sz) {

    assert(add >= addr() && add < addr() + size(), "not valid address");

    // for now, it can partially release from the both ends,

    // but not in the middle

    assert(add == addr() || (add + sz) == (addr() + size()),

      "release in the middle");

    if (add == addr()) {

      set_addr(add + sz);

      set_size(size() - sz);

    } else {

      set_size(size() - sz);

    }

  }

  // the committed size of the virtual memory block

  inline size_t committed_size() const {

    return _committed_size;

  }

  // the reserved size of the virtual memory block

  inline size_t reserved_size() const {

    return size();

  }

};

class VMMemRegionEx : public VMMemRegion {

 private:

  jint   _seq;  // sequence number

 public:

  VMMemRegionEx(): _pc(0) { }

  void init(const MemPointerRecordEx* mpe) {

    VMMemRegion::init(mpe);

    _pc = mpe->pc();

  }

  void init(const MemPointerRecord* mpe) {

    VMMemRegion::init(mpe);

    _pc = 0;

  }

  VMMemRegionEx& operator=(const VMMemRegionEx& other) {

    VMMemRegion::operator=(other);

    _pc = other.pc();

    return *this;

  }

  inline address pc() const { return _pc; }

 private:

  address   _pc;

};

/*

 * Sequenced memory record

 */

class SeqMemPointerRecord : public MemPointerRecord {

 private:

   jint _seq;  // sequence number

 public:

  SeqMemPointerRecord(): _seq(0){ }

  SeqMemPointerRecord(address addr, MEMFLAGS flags, size_t size)

    : MemPointerRecord(addr, flags, size) {

    _seq = SequenceGenerator::next();

  }

  SeqMemPointerRecord(const SeqMemPointerRecord& copy_from)

    : MemPointerRecord(copy_from) {

    _seq = copy_from.seq();

  }

  SeqMemPointerRecord& operator= (const SeqMemPointerRecord& ptr) {

    MemPointerRecord::operator=(ptr);

    _seq = ptr.seq();

    return *this;

  }

  inline jint seq() const {

    return _seq;

  }

};

class SeqMemPointerRecordEx : public MemPointerRecordEx {

 private:

  jint    _seq;  // sequence number

 public:

  SeqMemPointerRecordEx(): _seq(0) { }

  SeqMemPointerRecordEx(address addr, MEMFLAGS flags, size_t size,

    address pc): MemPointerRecordEx(addr, flags, size, pc) {

    _seq = SequenceGenerator::next();

  }

  SeqMemPointerRecordEx(const SeqMemPointerRecordEx& copy_from)

    : MemPointerRecordEx(copy_from) {

    _seq = copy_from.seq();

  }

  SeqMemPointerRecordEx& operator= (const SeqMemPointerRecordEx& ptr) {

    MemPointerRecordEx::operator=(ptr);

    _seq = ptr.seq();

    return *this;

  }

  inline jint seq() const {

    return _seq;

  }

};

#endif // SHARE_VM_SERVICES_MEM_PTR_HPP