1 /*
   2  * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_SERVICES_MEM_PTR_HPP
  26 #define SHARE_VM_SERVICES_MEM_PTR_HPP
  27 
  28 #include "memory/allocation.hpp"
  29 #include "runtime/atomic.hpp"
  30 #include "runtime/os.hpp"
  31 #include "runtime/safepoint.hpp"
  32 
  33 /*
  34  * global sequence generator that generates sequence numbers to serialize
  35  * memory records.
  36  */
  37 class SequenceGenerator : AllStatic {
  38  public:
  39   static jint next();
  40 
  41   // peek last sequence number
  42   static jint peek() {
  43     return _seq_number;
  44   }
  45 
  46   // reset sequence number
  47   static void reset() {
  48     assert(SafepointSynchronize::is_at_safepoint(), "Safepoint required");
  49     _seq_number = 1;
  50     DEBUG_ONLY(_generation ++;)
  51   };
  52 
  53   DEBUG_ONLY(static unsigned long current_generation() { return (unsigned long)_generation; })
  54   NOT_PRODUCT(static jint max_seq_num() { return _max_seq_number; })
  55 
  56  private:
  57   static volatile jint _seq_number;
  58   NOT_PRODUCT(static jint _max_seq_number; )
  59   DEBUG_ONLY(static volatile unsigned long _generation; )
  60 };
  61 
  62 /*
  63  * followings are the classes that are used to hold memory activity records in different stages.
  64  *   MemPointer
  65  *     |--------MemPointerRecord
  66  *                     |
  67  *                     |----MemPointerRecordEx
  68  *                     |           |
  69  *                     |           |-------SeqMemPointerRecordEx
  70  *                     |
  71  *                     |----SeqMemPointerRecord
  72  *                     |
  73  *                     |----VMMemRegion
  74  *                               |
  75  *                               |-----VMMemRegionEx
  76  *
  77  *
  78  *  prefix 'Seq' - sequenced, the record contains a sequence number
  79  *  surfix 'Ex'  - extension, the record contains a caller's pc
  80  *
  81  *  per-thread recorder : SeqMemPointerRecord(Ex)
  82  *  snapshot staging    : SeqMemPointerRecord(Ex)
  83  *  snapshot            : MemPointerRecord(Ex) and VMMemRegion(Ex)
  84  *
  85  */
  86 
  87 /*
  88  * class that wraps an address to a memory block,
  89  * the memory pointer either points to a malloc'd
  90  * memory block, or a mmap'd memory block
  91  */
  92 class MemPointer : public _ValueObj {
  93  public:
  94   MemPointer(): _addr(0) { }
  95   MemPointer(address addr): _addr(addr) { }
  96 
  97   MemPointer(const MemPointer& copy_from) {
  98     _addr = copy_from.addr();
  99   }
 100 
 101   inline address addr() const {
 102     return _addr;
 103   }
 104 
 105   inline operator address() const {
 106     return addr();
 107   }
 108 
 109   inline bool operator == (const MemPointer& other) const {
 110     return addr() == other.addr();
 111   }
 112 
 113   inline MemPointer& operator = (const MemPointer& other) {
 114     _addr = other.addr();
 115     return *this;
 116   }
 117 
 118  protected:
 119   inline void set_addr(address addr) { _addr = addr; }
 120 
 121  protected:
 122   // memory address
 123   address    _addr;
 124 };
 125 
 126 /* MemPointerRecord records an activityand associated
 127  * attributes on a memory block.
 128  */
 129 class MemPointerRecord : public MemPointer {
 130  private:
 131   MEMFLAGS       _flags;
 132   size_t         _size;
 133 
 134 public:
 135   /* extension of MemoryType enum
 136    * see share/vm/memory/allocation.hpp for details.
 137    *
 138    * The tag values are associated to sorting orders, so be
 139    * careful if changes are needed.
 140    * The allocation records should be sorted ahead of tagging
 141    * records, which in turn ahead of deallocation records
 142    */
 143   enum MemPointerTags {
 144     tag_alloc            = 0x0001, // malloc or reserve record
 145     tag_commit           = 0x0002, // commit record
 146     tag_type             = 0x0003, // tag virtual memory to a memory type
 147     tag_uncommit         = 0x0004, // uncommit record
 148     tag_release          = 0x0005, // free or release record
 149     tag_size             = 0x0006, // arena size
 150     tag_masks            = 0x0007, // all tag bits
 151     vmBit                = 0x0008
 152   };
 153 
 154   /* helper functions to interpret the tagging flags */
 155 
 156   inline static bool is_allocation_record(MEMFLAGS flags) {
 157     return (flags & tag_masks) == tag_alloc;
 158   }
 159 
 160   inline static bool is_deallocation_record(MEMFLAGS flags) {
 161     return (flags & tag_masks) == tag_release;
 162   }
 163 
 164   inline static bool is_arena_record(MEMFLAGS flags) {
 165     return (flags & (otArena | tag_size)) == otArena;
 166   }
 167 
 168   inline static bool is_arena_size_record(MEMFLAGS flags) {
 169     return (flags & (otArena | tag_size)) == (otArena | tag_size);
 170   }
 171 
 172   inline static bool is_virtual_memory_record(MEMFLAGS flags) {
 173     return (flags & vmBit) != 0;
 174   }
 175 
 176   inline static bool is_virtual_memory_reserve_record(MEMFLAGS flags) {
 177     return (flags & 0x0F) == (tag_alloc | vmBit);
 178   }
 179 
 180   inline static bool is_virtual_memory_commit_record(MEMFLAGS flags) {
 181     return (flags & 0x0F) == (tag_commit | vmBit);
 182   }
 183 
 184   inline static bool is_virtual_memory_uncommit_record(MEMFLAGS flags) {
 185     return (flags & 0x0F) == (tag_uncommit | vmBit);
 186   }
 187 
 188   inline static bool is_virtual_memory_release_record(MEMFLAGS flags) {
 189     return (flags & 0x0F) == (tag_release | vmBit);
 190   }
 191 
 192   inline static bool is_virtual_memory_type_record(MEMFLAGS flags) {
 193     return (flags & 0x0F) == (tag_type | vmBit);
 194   }
 195 
 196   /* tagging flags */
 197   inline static MEMFLAGS malloc_tag()                 { return tag_alloc;   }
 198   inline static MEMFLAGS free_tag()                   { return tag_release; }
 199   inline static MEMFLAGS arena_size_tag()             { return tag_size | otArena; }
 200   inline static MEMFLAGS virtual_memory_tag()         { return vmBit; }
 201   inline static MEMFLAGS virtual_memory_reserve_tag() { return (tag_alloc | vmBit); }
 202   inline static MEMFLAGS virtual_memory_commit_tag()  { return (tag_commit | vmBit); }
 203   inline static MEMFLAGS virtual_memory_uncommit_tag(){ return (tag_uncommit | vmBit); }
 204   inline static MEMFLAGS virtual_memory_release_tag() { return (tag_release | vmBit); }
 205   inline static MEMFLAGS virtual_memory_type_tag()    { return (tag_type | vmBit); }
 206 
 207  public:
 208   MemPointerRecord(): _size(0), _flags(mtNone) { }
 209 
 210   MemPointerRecord(address addr, MEMFLAGS memflags, size_t size = 0):
 211       MemPointer(addr), _flags(memflags), _size(size) { }
 212 
 213   MemPointerRecord(const MemPointerRecord& copy_from):
 214     MemPointer(copy_from), _flags(copy_from.flags()),
 215     _size(copy_from.size()) {
 216   }
 217 
 218   /* MemPointerRecord is not sequenced, it always return
 219    * 0 to indicate non-sequenced
 220    */
 221   virtual jint seq() const               { return 0; }
 222 
 223   inline size_t   size()  const          { return _size; }
 224   inline void set_size(size_t size)      { _size = size; }
 225 
 226   inline MEMFLAGS flags() const          { return _flags; }
 227   inline void set_flags(MEMFLAGS flags)  { _flags = flags; }
 228 
 229   MemPointerRecord& operator= (const MemPointerRecord& ptr) {
 230     MemPointer::operator=(ptr);
 231     _flags = ptr.flags();
 232 #ifdef ASSERT
 233     if (IS_ARENA_OBJ(_flags)) {
 234       assert(!is_vm_pointer(), "wrong flags");
 235       assert((_flags & ot_masks) == otArena, "wrong flags");
 236     }
 237 #endif
 238     _size = ptr.size();
 239     return *this;
 240   }
 241 
 242   // if the pointer represents a malloc-ed memory address
 243   inline bool is_malloced_pointer() const {
 244     return !is_vm_pointer();
 245   }
 246 
 247   // if the pointer represents a virtual memory address
 248   inline bool is_vm_pointer() const {
 249     return is_virtual_memory_record(_flags);
 250   }
 251 
 252   // if this record records a 'malloc' or virtual memory
 253   // 'reserve' call
 254   inline bool is_allocation_record() const {
 255     return is_allocation_record(_flags);
 256   }
 257 
 258   // if this record records a size information of an arena
 259   inline bool is_arena_size_record() const {
 260     return is_arena_size_record(_flags);
 261   }
 262 
 263   // if this pointer represents an address to an arena object
 264   inline bool is_arena_record() const {
 265     return is_arena_record(_flags);
 266   }
 267 
 268   // if this record represents a size information of specific arena
 269   inline bool is_size_record_of_arena(const MemPointerRecord* arena_rc) {
 270     assert(is_arena_size_record(), "not size record");
 271     assert(arena_rc->is_arena_record(), "not arena record");
 272     return (arena_rc->addr() + sizeof(void*)) == addr();
 273   }
 274 
 275   // if this record records a 'free' or virtual memory 'free' call
 276   inline bool is_deallocation_record() const {
 277     return is_deallocation_record(_flags);
 278   }
 279 
 280   // if this record records a virtual memory 'commit' call
 281   inline bool is_commit_record() const {
 282     return is_virtual_memory_commit_record(_flags);
 283   }
 284 
 285   // if this record records a virtual memory 'uncommit' call
 286   inline bool is_uncommit_record() const {
 287     return is_virtual_memory_uncommit_record(_flags);
 288   }
 289 
 290   // if this record is a tagging record of a virtual memory block
 291   inline bool is_type_tagging_record() const {
 292     return is_virtual_memory_type_record(_flags);
 293   }
 294 
 295   // if the two memory pointer records actually represent the same
 296   // memory block
 297   inline bool is_same_region(const MemPointerRecord* other) const {
 298     return (addr() == other->addr() && size() == other->size());
 299   }
 300 
 301   // if this memory region fully contains another one
 302   inline bool contains_region(const MemPointerRecord* other) const {
 303     return contains_region(other->addr(), other->size());
 304   }
 305 
 306   // if this memory region fully contains specified memory range
 307   inline bool contains_region(address add, size_t sz) const {
 308     return (addr() <= add && addr() + size() >= add + sz);
 309   }
 310 
 311   inline bool contains_address(address add) const {
 312     return (addr() <= add && addr() + size() > add);
 313   }











 314 };
 315 
 316 // MemPointerRecordEx also records callsite pc, from where
 317 // the memory block is allocated
 318 class MemPointerRecordEx : public MemPointerRecord {
 319  private:
 320   address      _pc;  // callsite pc
 321 
 322  public:
 323   MemPointerRecordEx(): _pc(0) { }
 324 
 325   MemPointerRecordEx(address addr, MEMFLAGS memflags, size_t size = 0, address pc = 0):
 326     MemPointerRecord(addr, memflags, size), _pc(pc) {}
 327 
 328   MemPointerRecordEx(const MemPointerRecordEx& copy_from):
 329     MemPointerRecord(copy_from), _pc(copy_from.pc()) {}
 330 
 331   inline address pc() const { return _pc; }
 332 
 333   void init(const MemPointerRecordEx* mpe) {
 334     MemPointerRecord::operator=(*mpe);
 335     _pc = mpe->pc();
 336   }
 337 
 338   void init(const MemPointerRecord* mp) {
 339     MemPointerRecord::operator=(*mp);
 340     _pc = 0;
 341   }
 342 };
 343 
 344 // a virtual memory region. The region can represent a reserved
 345 // virtual memory region or a committed memory region
 346 class VMMemRegion : public MemPointerRecord {
 347 public:
 348   VMMemRegion() { }
 349 
 350   void init(const MemPointerRecord* mp) {
 351     assert(mp->is_vm_pointer(), "Sanity check");
 352     _addr = mp->addr();
 353       set_size(mp->size());
 354     set_flags(mp->flags());
 355   }
 356 
 357   VMMemRegion& operator=(const VMMemRegion& other) {
 358     MemPointerRecord::operator=(other);
 359     return *this;
 360   }
 361 
 362   inline bool is_reserved_region() const {
 363     return is_allocation_record();
 364   }
 365 
 366   inline bool is_committed_region() const {
 367     return is_commit_record();
 368   }
 369 
 370   /* base address of this virtual memory range */
 371   inline address base() const {
 372     return addr();
 373   }
 374 
 375   /* tag this virtual memory range to the specified memory type */
 376   inline void tag(MEMFLAGS f) {
 377     set_flags(flags() | (f & mt_masks));
 378   }
 379 
 380   // expand this region to also cover specified range.
 381   // The range has to be on either end of the memory region.
 382   void expand_region(address addr, size_t sz) {
 383     if (addr < base()) {
 384       assert(addr + sz == base(), "Sanity check");
 385       _addr = addr;
 386       set_size(size() + sz);
 387     } else {
 388       assert(base() + size() == addr, "Sanity check");
 389       set_size(size() + sz);
 390     }
 391   }
 392 
 393   // exclude the specified address range from this region.
 394   // The excluded memory range has to be on either end of this memory
 395   // region.
 396   inline void exclude_region(address add, size_t sz) {
 397     assert(is_reserved_region() || is_committed_region(), "Sanity check");
 398     assert(addr() != NULL && size() != 0, "Sanity check");
 399     assert(add >= addr() && add < addr() + size(), "Sanity check");
 400     assert(add == addr() || (add + sz) == (addr() + size()),
 401       "exclude in the middle");
 402     if (add == addr()) {
 403       set_addr(add + sz);
 404       set_size(size() - sz);
 405     } else {
 406       set_size(size() - sz);
 407     }
 408   }
 409 };
 410 
 411 class VMMemRegionEx : public VMMemRegion {
 412  private:
 413   jint   _seq;  // sequence number
 414 
 415  public:
 416   VMMemRegionEx(): _pc(0) { }
 417 
 418   void init(const MemPointerRecordEx* mpe) {
 419     VMMemRegion::init(mpe);
 420     _pc = mpe->pc();
 421   }
 422 
 423   void init(const MemPointerRecord* mpe) {
 424     VMMemRegion::init(mpe);
 425     _pc = 0;
 426   }
 427 
 428   VMMemRegionEx& operator=(const VMMemRegionEx& other) {
 429     VMMemRegion::operator=(other);
 430     _pc = other.pc();
 431     return *this;
 432   }
 433 
 434   inline address pc() const { return _pc; }
 435  private:
 436   address   _pc;
 437 };
 438 
 439 /*
 440  * Sequenced memory record
 441  */
 442 class SeqMemPointerRecord : public MemPointerRecord {
 443  private:
 444    jint _seq;  // sequence number
 445 
 446  public:
 447   SeqMemPointerRecord(): _seq(0){ }
 448 
 449   SeqMemPointerRecord(address addr, MEMFLAGS flags, size_t size)
 450     : MemPointerRecord(addr, flags, size) {
 451     _seq = SequenceGenerator::next();
 452   }
 453 
 454   SeqMemPointerRecord(const SeqMemPointerRecord& copy_from)
 455     : MemPointerRecord(copy_from) {
 456     _seq = copy_from.seq();
 457   }
 458 
 459   SeqMemPointerRecord& operator= (const SeqMemPointerRecord& ptr) {
 460     MemPointerRecord::operator=(ptr);
 461     _seq = ptr.seq();
 462     return *this;
 463   }
 464 
 465   inline jint seq() const {
 466     return _seq;
 467   }
 468 };
 469 
 470 
 471 
 472 class SeqMemPointerRecordEx : public MemPointerRecordEx {
 473  private:
 474   jint    _seq;  // sequence number
 475 
 476  public:
 477   SeqMemPointerRecordEx(): _seq(0) { }
 478 
 479   SeqMemPointerRecordEx(address addr, MEMFLAGS flags, size_t size,
 480     address pc): MemPointerRecordEx(addr, flags, size, pc) {
 481     _seq = SequenceGenerator::next();
 482   }
 483 
 484   SeqMemPointerRecordEx(const SeqMemPointerRecordEx& copy_from)
 485     : MemPointerRecordEx(copy_from) {
 486     _seq = copy_from.seq();
 487   }
 488 
 489   SeqMemPointerRecordEx& operator= (const SeqMemPointerRecordEx& ptr) {
 490     MemPointerRecordEx::operator=(ptr);
 491     _seq = ptr.seq();
 492     return *this;
 493   }
 494 
 495   inline jint seq() const {
 496     return _seq;
 497   }
 498 };
 499 
 500 #endif // SHARE_VM_SERVICES_MEM_PTR_HPP
--- EOF ---