jdk8-mips64-public/hotspot: src/share/vm/memory/blockOffsetTable.inline.hpp@6acf14e730dd

8072725: Provide more granular levels for GC verification
Summary: Add option VerifySubSet to selectively verify the memory sub-systems
Reviewed-by: kevinw, jmasa

     1 /*

     2  * Copyright (c) 2000, 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  */

    25 #ifndef SHARE_VM_MEMORY_BLOCKOFFSETTABLE_INLINE_HPP

    26 #define SHARE_VM_MEMORY_BLOCKOFFSETTABLE_INLINE_HPP

    28 #include "memory/blockOffsetTable.hpp"

    29 #include "memory/space.hpp"

    30 #include "runtime/safepoint.hpp"

    32 //////////////////////////////////////////////////////////////////////////

    33 // BlockOffsetTable inlines

    34 //////////////////////////////////////////////////////////////////////////

    35 inline HeapWord* BlockOffsetTable::block_start(const void* addr) const {

    36   if (addr >= _bottom && addr < _end) {

    37     return block_start_unsafe(addr);

    38   } else {

    39     return NULL;

    40   }

    41 }

    43 //////////////////////////////////////////////////////////////////////////

    44 // BlockOffsetSharedArray inlines

    45 //////////////////////////////////////////////////////////////////////////

    46 inline size_t BlockOffsetSharedArray::index_for(const void* p) const {

    47   char* pc = (char*)p;

    48   assert(pc >= (char*)_reserved.start() &&

    49          pc <  (char*)_reserved.end(),

    50          "p not in range.");

    51   size_t delta = pointer_delta(pc, _reserved.start(), sizeof(char));

    52   size_t result = delta >> LogN;

    53   assert(result < _vs.committed_size(), "bad index from address");

    54   return result;

    55 }

    57 inline HeapWord* BlockOffsetSharedArray::address_for_index(size_t index) const {

    58   assert(index < _vs.committed_size(), "bad index");

    59   HeapWord* result = _reserved.start() + (index << LogN_words);

    60   assert(result >= _reserved.start() && result < _reserved.end(),

    61          "bad address from index");

    62   return result;

    63 }

    65 inline void BlockOffsetSharedArray::check_reducing_assertion(bool reducing) {

    66     assert(reducing || !SafepointSynchronize::is_at_safepoint() || init_to_zero() ||

    67            Thread::current()->is_VM_thread() ||

    68            Thread::current()->is_ConcurrentGC_thread() ||

    69            ((!Thread::current()->is_ConcurrentGC_thread()) &&

    70             ParGCRareEvent_lock->owned_by_self()), "Crack");

    71 }

    73 //////////////////////////////////////////////////////////////////////////

    74 // BlockOffsetArrayNonContigSpace inlines

    75 //////////////////////////////////////////////////////////////////////////

    76 inline void BlockOffsetArrayNonContigSpace::freed(HeapWord* blk,

    77                                                   size_t size) {

    78   freed(blk, blk + size);

    79 }

    81 inline void BlockOffsetArrayNonContigSpace::freed(HeapWord* blk_start,

    82                                                   HeapWord* blk_end) {

    83   // Verify that the BOT shows [blk_start, blk_end) to be one block.

    84   verify_single_block(blk_start, blk_end);

    85   // adjust _unallocated_block upward or downward

    86   // as appropriate

    87   if (BlockOffsetArrayUseUnallocatedBlock) {

    88     assert(_unallocated_block <= _end,

    89            "Inconsistent value for _unallocated_block");

    90     if (blk_end >= _unallocated_block && blk_start <= _unallocated_block) {

    91       // CMS-specific note: a block abutting _unallocated_block to

    92       // its left is being freed, a new block is being added or

    93       // we are resetting following a compaction

    94       _unallocated_block = blk_start;

    95     }

    96   }

    97 }

    99 #endif // SHARE_VM_MEMORY_BLOCKOFFSETTABLE_INLINE_HPP

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/memory/blockOffsetTable.inline.hpp@6acf14e730dd

src/share/vm/memory/blockOffsetTable.inline.hpp