Mercurial > hg > truffle
view src/share/vm/services/memoryPool.hpp @ 452:00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery.
Reviewed-by: apetrusenko, jcoomes
author | ysr |
---|---|
date | Thu, 20 Nov 2008 12:27:41 -0800 |
parents | a61af66fc99e |
children | c18cbe5936b8 |
line wrap: on
line source
/* * Copyright 2003-2004 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, * CA 95054 USA or visit www.sun.com if you need additional information or * have any questions. * */ // A memory pool represents the memory area that the VM manages. // The Java virtual machine has at least one memory pool // and it may create or remove memory pools during execution. // A memory pool can belong to the heap or the non-heap memory. // A Java virtual machine may also have memory pools belonging to // both heap and non-heap memory. // Forward declaration class MemoryManager; class SensorInfo; class Generation; class DefNewGeneration; class PSPermGen; class PermGen; class ThresholdSupport; class MemoryPool : public CHeapObj { friend class MemoryManager; public: enum PoolType { Heap = 1, NonHeap = 2 }; private: enum { max_num_managers = 5 }; // We could make some of the following as performance counters // for external monitoring. const char* _name; PoolType _type; size_t _initial_size; size_t _max_size; bool _available_for_allocation; // Default is true MemoryManager* _managers[max_num_managers]; int _num_managers; MemoryUsage _peak_usage; // Peak memory usage MemoryUsage _after_gc_usage; // After GC memory usage ThresholdSupport* _usage_threshold; ThresholdSupport* _gc_usage_threshold; SensorInfo* _usage_sensor; SensorInfo* _gc_usage_sensor; volatile instanceOop _memory_pool_obj; void add_manager(MemoryManager* mgr); public: MemoryPool(const char* name, PoolType type, size_t init_size, size_t max_size, bool support_usage_threshold, bool support_gc_threshold); const char* name() { return _name; } bool is_heap() { return _type == Heap; } bool is_non_heap() { return _type == NonHeap; } size_t initial_size() const { return _initial_size; } int num_memory_managers() const { return _num_managers; } // max size could be changed virtual size_t max_size() const { return _max_size; } bool is_pool(instanceHandle pool) { return (pool() == _memory_pool_obj); } bool available_for_allocation() { return _available_for_allocation; } bool set_available_for_allocation(bool value) { bool prev = _available_for_allocation; _available_for_allocation = value; return prev; } MemoryManager* get_memory_manager(int index) { assert(index >= 0 && index < _num_managers, "Invalid index"); return _managers[index]; } // Records current memory usage if it's a peak usage void record_peak_memory_usage(); MemoryUsage get_peak_memory_usage() { // check current memory usage first and then return peak usage record_peak_memory_usage(); return _peak_usage; } void reset_peak_memory_usage() { _peak_usage = get_memory_usage(); } ThresholdSupport* usage_threshold() { return _usage_threshold; } ThresholdSupport* gc_usage_threshold() { return _gc_usage_threshold; } SensorInfo* usage_sensor() { return _usage_sensor; } SensorInfo* gc_usage_sensor() { return _gc_usage_sensor; } void set_usage_sensor_obj(instanceHandle s); void set_gc_usage_sensor_obj(instanceHandle s); void set_last_collection_usage(MemoryUsage u) { _after_gc_usage = u; } virtual instanceOop get_memory_pool_instance(TRAPS); virtual MemoryUsage get_memory_usage() = 0; virtual size_t used_in_bytes() = 0; virtual bool is_collected_pool() { return false; } virtual MemoryUsage get_last_collection_usage() { return _after_gc_usage; } // GC support void oops_do(OopClosure* f); }; class CollectedMemoryPool : public MemoryPool { public: CollectedMemoryPool(const char* name, PoolType type, size_t init_size, size_t max_size, bool support_usage_threshold) : MemoryPool(name, type, init_size, max_size, support_usage_threshold, true) {}; bool is_collected_pool() { return true; } }; class ContiguousSpacePool : public CollectedMemoryPool { private: ContiguousSpace* _space; public: ContiguousSpacePool(ContiguousSpace* space, const char* name, PoolType type, size_t max_size, bool support_usage_threshold); ContiguousSpace* space() { return _space; } MemoryUsage get_memory_usage(); size_t used_in_bytes() { return space()->used(); } }; class SurvivorContiguousSpacePool : public CollectedMemoryPool { private: DefNewGeneration* _gen; public: SurvivorContiguousSpacePool(DefNewGeneration* gen, const char* name, PoolType type, size_t max_size, bool support_usage_threshold); MemoryUsage get_memory_usage(); size_t used_in_bytes() { return _gen->from()->used(); } size_t committed_in_bytes() { return _gen->from()->capacity(); } }; #ifndef SERIALGC class CompactibleFreeListSpacePool : public CollectedMemoryPool { private: CompactibleFreeListSpace* _space; public: CompactibleFreeListSpacePool(CompactibleFreeListSpace* space, const char* name, PoolType type, size_t max_size, bool support_usage_threshold); MemoryUsage get_memory_usage(); size_t used_in_bytes() { return _space->used(); } }; #endif // SERIALGC class GenerationPool : public CollectedMemoryPool { private: Generation* _gen; public: GenerationPool(Generation* gen, const char* name, PoolType type, bool support_usage_threshold); MemoryUsage get_memory_usage(); size_t used_in_bytes() { return _gen->used(); } }; class CodeHeapPool: public MemoryPool { private: CodeHeap* _codeHeap; public: CodeHeapPool(CodeHeap* codeHeap, const char* name, bool support_usage_threshold); MemoryUsage get_memory_usage(); size_t used_in_bytes() { return _codeHeap->allocated_capacity(); } };