Mercurial > hg > graal-compiler
view src/share/vm/gc_implementation/concurrentMarkSweep/freeChunk.hpp @ 8002:8391fdd36e1f
Merge
author | dlong |
---|---|
date | Sun, 27 Jan 2013 01:07:09 -0800 |
parents | 685df3c6f84b |
children |
line wrap: on
line source
/* * Copyright (c) 2001, 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_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_FREECHUNK_HPP #define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_FREECHUNK_HPP #include "memory/allocation.hpp" #include "memory/memRegion.hpp" #include "oops/markOop.hpp" #include "runtime/mutex.hpp" #include "utilities/debug.hpp" #include "utilities/globalDefinitions.hpp" #include "utilities/ostream.hpp" // // Free block maintenance for Concurrent Mark Sweep Generation // // The main data structure for free blocks are // . an indexed array of small free blocks, and // . a dictionary of large free blocks // // No virtuals in FreeChunk (don't want any vtables). // A FreeChunk is merely a chunk that can be in a doubly linked list // and has a size field. NOTE: FreeChunks are distinguished from allocated // objects in two ways (by the sweeper), depending on whether the VM is 32 or // 64 bits. // In 32 bits or 64 bits without CompressedOops, the second word (prev) has the // LSB set to indicate a free chunk; allocated objects' klass() pointers // don't have their LSB set. The corresponding bit in the CMSBitMap is // set when the chunk is allocated. There are also blocks that "look free" // but are not part of the free list and should not be coalesced into larger // free blocks. These free blocks have their two LSB's set. class FreeChunk VALUE_OBJ_CLASS_SPEC { friend class VMStructs; // For 64 bit compressed oops, the markOop encodes both the size and the // indication that this is a FreeChunk and not an object. volatile size_t _size; FreeChunk* _prev; FreeChunk* _next; markOop mark() const volatile { return (markOop)_size; } void set_mark(markOop m) { _size = (size_t)m; } public: NOT_PRODUCT(static const size_t header_size();) // Returns "true" if the address indicates that the block represents // a free chunk. static bool indicatesFreeChunk(const HeapWord* addr) { // Force volatile read from addr because value might change between // calls. We really want the read of _mark and _prev from this pointer // to be volatile but making the fields volatile causes all sorts of // compilation errors. return ((volatile FreeChunk*)addr)->is_free(); } bool is_free() const volatile { LP64_ONLY(if (UseCompressedOops) return mark()->is_cms_free_chunk(); else) return (((intptr_t)_prev) & 0x1) == 0x1; } bool cantCoalesce() const { assert(is_free(), "can't get coalesce bit on not free"); return (((intptr_t)_prev) & 0x2) == 0x2; } void dontCoalesce() { // the block should be free assert(is_free(), "Should look like a free block"); _prev = (FreeChunk*)(((intptr_t)_prev) | 0x2); } FreeChunk* prev() const { return (FreeChunk*)(((intptr_t)_prev) & ~(0x3)); } debug_only(void* prev_addr() const { return (void*)&_prev; }) debug_only(void* next_addr() const { return (void*)&_next; }) debug_only(void* size_addr() const { return (void*)&_size; }) size_t size() const volatile { LP64_ONLY(if (UseCompressedOops) return mark()->get_size(); else ) return _size; } void set_size(size_t sz) { LP64_ONLY(if (UseCompressedOops) set_mark(markOopDesc::set_size_and_free(sz)); else ) _size = sz; } FreeChunk* next() const { return _next; } void link_after(FreeChunk* ptr) { link_next(ptr); if (ptr != NULL) ptr->link_prev(this); } void link_next(FreeChunk* ptr) { _next = ptr; } void link_prev(FreeChunk* ptr) { LP64_ONLY(if (UseCompressedOops) _prev = ptr; else) _prev = (FreeChunk*)((intptr_t)ptr | 0x1); } void clear_next() { _next = NULL; } void markNotFree() { // Set _prev (klass) to null before (if) clearing the mark word below _prev = NULL; #ifdef _LP64 if (UseCompressedOops) { OrderAccess::storestore(); set_mark(markOopDesc::prototype()); } #endif assert(!is_free(), "Error"); } // Return the address past the end of this chunk uintptr_t* end() const { return ((uintptr_t*) this) + size(); } // debugging void verify() const PRODUCT_RETURN; void verifyList() const PRODUCT_RETURN; void mangleAllocated(size_t size) PRODUCT_RETURN; void mangleFreed(size_t size) PRODUCT_RETURN; void print_on(outputStream* st); }; extern size_t MinChunkSize; #endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_FREECHUNK_HPP