truffle: src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 2181:d25d4ca69222

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Wed, 16 Feb 2011 13:47:20 +0100
parents	97ba643ea3ed
children	c33825b68624

comparison

equal deleted inserted replaced

-:50b45e2d9725
+:d25d4ca69222
 /*
-* Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2011, 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.
 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
 #include "gc_implementation/g1/concurrentMark.hpp"
 #include "gc_implementation/g1/g1RemSet.hpp"
-#include "gc_implementation/g1/heapRegion.hpp"
+#include "gc_implementation/g1/heapRegionSets.hpp"
 #include "gc_implementation/parNew/parGCAllocBuffer.hpp"
 #include "memory/barrierSet.hpp"
 #include "memory/memRegion.hpp"
 #include "memory/sharedHeap.hpp"
 // may combine concurrent marking with parallel, incremental compaction of
 // heap subsets that will yield large amounts of garbage.
 class HeapRegion;
 class HeapRegionSeq;
+class HRRSCleanupTask;
 class PermanentGenerationSpec;
 class GenerationSpec;
 class OopsInHeapRegionClosure;
 class G1ScanHeapEvacClosure;
 class ObjectClosure;
 typedef int CardIdx_t;     // needs to hold [ 0..CardsPerRegion )
 enum G1GCThreadGroups {
 G1CRGroup = 0,
 G1ZFGroup = 1,
-G1CMGroup = 2,
+G1CMGroup = 2
-G1CLGroup = 3
 };
 enum GCAllocPurpose {
 GCAllocForTenured,
 GCAllocForSurvived,
 friend class G1ParTask;
 friend class G1FreeGarbageRegionClosure;
 friend class RefineCardTableEntryClosure;
 friend class G1PrepareCompactClosure;
 friend class RegionSorter;
+friend class RegionResetter;
 friend class CountRCClosure;
 friend class EvacPopObjClosure;
 friend class G1ParCleanupCTTask;
 // Other related classes.
 MemRegion _g1_committed;
 // The maximum part of _g1_storage that has ever been committed.
 MemRegion _g1_max_committed;
-// The number of regions that are completely free.
+// The master free list. It will satisfy all new region allocations.
-size_t _free_regions;
+MasterFreeRegionList      _free_list;
+// The secondary free list which contains regions that have been
+// freed up during the cleanup process. This will be appended to the
+// master free list when appropriate.
+SecondaryFreeRegionList   _secondary_free_list;
+// It keeps track of the humongous regions.
+MasterHumongousRegionSet  _humongous_set;
 // The number of regions we could create by expansion.
 size_t _expansion_regions;
-// Return the number of free regions in the heap (by direct counting.)
-size_t count_free_regions();
-// Return the number of free regions on the free and unclean lists.
-size_t count_free_regions_list();
 // The block offset table for the G1 heap.
 G1BlockOffsetSharedArray* _bot_shared;
 // Move all of the regions off the free lists, then rebuild those free
 // lists, before and after full GC.
 void tear_down_region_lists();
 void rebuild_region_lists();
-// This sets all non-empty regions to need zero-fill (which they will if
-// they are empty after full collection.)
-void set_used_regions_to_need_zero_fill();
 // The sequence of all heap regions in the heap.
 HeapRegionSeq* _hrs;
 // The region from which normal-sized objects are currently being
 HeapRegion* _gc_alloc_region_list;
 // Determines PLAB size for a particular allocation purpose.
 static size_t desired_plab_sz(GCAllocPurpose purpose);
-// When called by par thread, require par_alloc_during_gc_lock() to be held.
+// When called by par thread, requires the FreeList_lock to be held.
 void push_gc_alloc_region(HeapRegion* hr);
 // This should only be called single-threaded.  Undeclares all GC alloc
 // regions.
 void forget_alloc_region_list();
 // These are macros so that, if the assert fires, we get the correct
 // line number, file, etc.
 #define heap_locking_asserts_err_msg(__extra_message)                         \
-err_msg("%s : Heap_lock %slocked, %sat a safepoint",                        \
+err_msg("%s : Heap_lock locked: %s, at safepoint: %s, is VM thread: %s",    \
 (__extra_message),                                                  \
-(!Heap_lock->owned_by_self()) ? "NOT " : "",                        \
+BOOL_TO_STR(Heap_lock->owned_by_self()),                            \
-(!SafepointSynchronize::is_at_safepoint()) ? "NOT " : "")
+BOOL_TO_STR(SafepointSynchronize::is_at_safepoint()),               \
+BOOL_TO_STR(Thread::current()->is_VM_thread()))
 #define assert_heap_locked()                                                  \
 do {                                                                        \
 assert(Heap_lock->owned_by_self(),                                        \
 heap_locking_asserts_err_msg("should be holding the Heap_lock"));  \
 } while (0)
-#define assert_heap_locked_or_at_safepoint()                                  \
+#define assert_heap_locked_or_at_safepoint(__should_be_vm_thread)             \
 do {                                                                        \
 assert(Heap_lock->owned_by_self() ||                                      \
-SafepointSynchronize::is_at_safepoint(), \
+(SafepointSynchronize::is_at_safepoint() &&                        \
+((__should_be_vm_thread) == Thread::current()->is_VM_thread())), \
 heap_locking_asserts_err_msg("should be holding the Heap_lock or " \
 "should be at a safepoint"));         \
 } while (0)
 #define assert_heap_locked_and_not_at_safepoint()                             \
 !SafepointSynchronize::is_at_safepoint(), \
 heap_locking_asserts_err_msg("should not be holding the Heap_lock and " \
 "should not be at a safepoint"));          \
 } while (0)
-#define assert_at_safepoint()                                                 \
+#define assert_at_safepoint(__should_be_vm_thread)                            \
 do {                                                                        \
-assert(SafepointSynchronize::is_at_safepoint(),                           \
+assert(SafepointSynchronize::is_at_safepoint() &&                         \
+((__should_be_vm_thread) == Thread::current()->is_VM_thread()), \
 heap_locking_asserts_err_msg("should be at a safepoint"));         \
 } while (0)
 #define assert_not_at_safepoint()                                             \
 do {                                                                        \
 YoungList*  _young_list;
 // The current policy object for the collector.
 G1CollectorPolicy* _g1_policy;
-// Parallel allocation lock to protect the current allocation region.
+// This is the second level of trying to allocate a new region. If
-Mutex  _par_alloc_during_gc_lock;
+// new_region_work didn't find a region in the free_list, this call
-Mutex* par_alloc_during_gc_lock() { return &_par_alloc_during_gc_lock; }
+// will check whether there's anything available in the
+// secondary_free_list and/or wait for more regions to appear in that
-// If possible/desirable, allocate a new HeapRegion for normal object
+// list, if _free_regions_coming is set.
-// allocation sufficient for an allocation of the given "word_size".
+HeapRegion* new_region_try_secondary_free_list(size_t word_size);
-// If "do_expand" is true, will attempt to expand the heap if necessary
-// to to satisfy the request.  If "zero_filled" is true, requires a
+// It will try to allocate a single non-humongous HeapRegion
-// zero-filled region.
+// sufficient for an allocation of the given word_size.  If
-// (Returning NULL will trigger a GC.)
+// do_expand is true, it will attempt to expand the heap if
-virtual HeapRegion* newAllocRegion_work(size_t word_size,
+// necessary to satisfy the allocation request. Note that word_size
-bool do_expand,
+// is only used to make sure that we expand sufficiently but, given
-bool zero_filled);
+// that the allocation request is assumed not to be humongous,
+// having word_size is not strictly necessary (expanding by a single
-virtual HeapRegion* newAllocRegion(size_t word_size,
+// region will always be sufficient). But let's keep that parameter
-bool zero_filled = true) {
+// in case we need it in the future.
-return newAllocRegion_work(word_size, false, zero_filled);
+HeapRegion* new_region_work(size_t word_size, bool do_expand);
-}
-virtual HeapRegion* newAllocRegionWithExpansion(int purpose,
+// It will try to allocate a new region to be used for allocation by
-size_t word_size,
+// mutator threads. It will not try to expand the heap if not region
-bool zero_filled = true);
+// is available.
+HeapRegion* new_alloc_region(size_t word_size) {
+return new_region_work(word_size, false /* do_expand */);
+}
+// It will try to allocate a new region to be used for allocation by
+// a GC thread. It will try to expand the heap if no region is
+// available.
+HeapRegion* new_gc_alloc_region(int purpose, size_t word_size);
+int humongous_obj_allocate_find_first(size_t num_regions, size_t word_size);
 // Attempt to allocate an object of the given (very large) "word_size".
 // Returns "NULL" on failure.
-virtual HeapWord* humongous_obj_allocate(size_t word_size);
+HeapWord* humongous_obj_allocate(size_t word_size);
 // The following two methods, allocate_new_tlab() and
 // mem_allocate(), are the two main entry points from the runtime
 // into the G1's allocation routines. They have the following
 // assumptions:
 bool   is_noref,
 bool   is_tlab, /* expected to be false */
 bool*  gc_overhead_limit_was_exceeded);
 // The following methods, allocate_from_cur_allocation_region(),
-// attempt_allocation(), replace_cur_alloc_region_and_allocate(),
+// attempt_allocation(), attempt_allocation_locked(),
+// replace_cur_alloc_region_and_allocate(),
 // attempt_allocation_slow(), and attempt_allocation_humongous()
 // have very awkward pre- and post-conditions with respect to
 // locking:
 //
 // If they are called outside a safepoint they assume the caller
 //
 // They all return either the address of the block, if they
 // successfully manage to allocate it, or NULL.
 // It tries to satisfy an allocation request out of the current
-// allocating region, which is passed as a parameter. It assumes
+// alloc region, which is passed as a parameter. It assumes that the
-// that the caller has checked that the current allocating region is
+// caller has checked that the current alloc region is not NULL.
-// not NULL. Given that the caller has to check the current
+// Given that the caller has to check the current alloc region for
-// allocating region for at least NULL, it might as well pass it as
+// at least NULL, it might as well pass it as the first parameter so
-// the first parameter so that the method doesn't have to read it
+// that the method doesn't have to read it from the
-// from the _cur_alloc_region field again.
+// _cur_alloc_region field again. It is called from both
+// attempt_allocation() and attempt_allocation_locked() and the
+// with_heap_lock parameter indicates whether the caller was holding
+// the heap lock when it called it or not.
 inline HeapWord* allocate_from_cur_alloc_region(HeapRegion* cur_alloc_region,
-size_t word_size);
+size_t word_size,
+bool with_heap_lock);
-// It attempts to allocate out of the current alloc region. If that
-// fails, it retires the current alloc region (if there is one),
+// First-level of allocation slow path: it attempts to allocate out
-// tries to get a new one and retries the allocation.
+// of the current alloc region in a lock-free manner using a CAS. If
+// that fails it takes the Heap_lock and calls
+// attempt_allocation_locked() for the second-level slow path.
 inline HeapWord* attempt_allocation(size_t word_size);
+// Second-level of allocation slow path: while holding the Heap_lock
+// it tries to allocate out of the current alloc region and, if that
+// fails, tries to allocate out of a new current alloc region.
+inline HeapWord* attempt_allocation_locked(size_t word_size);
 // It assumes that the current alloc region has been retired and
 // tries to allocate a new one. If it's successful, it performs the
 // allocation out of the new current alloc region and updates
 // _cur_alloc_region. Normally, it would try to allocate a new
 HeapWord* replace_cur_alloc_region_and_allocate(size_t word_size,
 bool at_safepoint,
 bool do_dirtying,
 bool can_expand);
-// The slow path when we are unable to allocate a new current alloc
+// Third-level of allocation slow path: when we are unable to
-// region to satisfy an allocation request (i.e., when
+// allocate a new current alloc region to satisfy an allocation
-// attempt_allocation() fails). It will try to do an evacuation
+// request (i.e., when attempt_allocation_locked() fails). It will
-// pause, which might stall due to the GC locker, and retry the
+// try to do an evacuation pause, which might stall due to the GC
-// allocation attempt when appropriate.
+// locker, and retry the allocation attempt when appropriate.
 HeapWord* attempt_allocation_slow(size_t word_size);
 // The method that tries to satisfy a humongous allocation
 // request. If it cannot satisfy it it will try to do an evacuation
 // pause to perhaps reclaim enough space to be able to satisfy the
 OopClosure* non_root_closure);
 // Invoke "save_marks" on all heap regions.
 void save_marks();
-// Free a heap region.
+// It frees a non-humongous region by initializing its contents and
-void free_region(HeapRegion* hr);
+// adding it to the free list that's passed as a parameter (this is
-// A component of "free_region", exposed for 'batching'.
+// usually a local list which will be appended to the master free
-// All the params after "hr" are out params: the used bytes of the freed
+// list later). The used bytes of freed regions are accumulated in
-// region(s), the number of H regions cleared, the number of regions
+// pre_used. If par is true, the region's RSet will not be freed
-// freed, and pointers to the head and tail of a list of freed contig
+// up. The assumption is that this will be done later.
-// regions, linked throught the "next_on_unclean_list" field.
+void free_region(HeapRegion* hr,
-void free_region_work(HeapRegion* hr,
+size_t* pre_used,
-size_t& pre_used,
+FreeRegionList* free_list,
-size_t& cleared_h,
+bool par);
-size_t& freed_regions,
-UncleanRegionList* list,
+// It frees a humongous region by collapsing it into individual
-bool par = false);
+// regions and calling free_region() for each of them. The freed
+// regions will be added to the free list that's passed as a parameter
+// (this is usually a local list which will be appended to the
+// master free list later). The used bytes of freed regions are
+// accumulated in pre_used. If par is true, the region's RSet will
+// not be freed up. The assumption is that this will be done later.
+void free_humongous_region(HeapRegion* hr,
+size_t* pre_used,
+FreeRegionList* free_list,
+HumongousRegionSet* humongous_proxy_set,
+bool par);
 // The concurrent marker (and the thread it runs in.)
 ConcurrentMark* _cm;
 ConcurrentMarkThread* _cmThread;
 bool _mark_in_progress;
 // The concurrent refiner.
 ConcurrentG1Refine* _cg1r;
-// The concurrent zero-fill thread.
-ConcurrentZFThread* _czft;
 // The parallel task queues
 RefToScanQueueSet *_task_queues;
 // True iff a evacuation has failed in the current collection.
 // Do any necessary cleanup for evacuation-failure handling data
 // structures.
 void finalize_for_evac_failure();
 // An attempt to evacuate "obj" has failed; take necessary steps.
-void handle_evacuation_failure(oop obj);
 oop handle_evacuation_failure_par(OopsInHeapRegionClosure* cl, oop obj);
 void handle_evacuation_failure_common(oop obj, markOop m);
 // Ensure that the relevant gc_alloc regions are set.
 G1H_PS_NumElements
 };
 SubTasksDone* _process_strong_tasks;
-// List of regions which require zero filling.
+volatile bool _free_regions_coming;
-UncleanRegionList _unclean_region_list;
-bool _unclean_regions_coming;
 public:
 SubTasksDone* process_strong_tasks() { return _process_strong_tasks; }
 // The number of regions that are completely free.
 size_t max_regions();
 // The number of regions that are completely free.
-size_t free_regions();
+size_t free_regions() {
+return _free_list.length();
+}
 // The number of regions that are not completely free.
 size_t used_regions() { return n_regions() - free_regions(); }
-// True iff the ZF thread should run.
-bool should_zf();
 // The number of regions available for "regular" expansion.
 size_t expansion_regions() { return _expansion_regions; }
-#ifndef PRODUCT
+// verify_region_sets() performs verification over the region
-bool regions_accounted_for();
+// lists. It will be compiled in the product code to be used when
-bool print_region_accounting_info();
+// necessary (i.e., during heap verification).
-void print_region_counts();
+void verify_region_sets();
-#endif
+// verify_region_sets_optional() is planted in the code for
-HeapRegion* alloc_region_from_unclean_list(bool zero_filled);
+// list verification in non-product builds (and it can be enabled in
-HeapRegion* alloc_region_from_unclean_list_locked(bool zero_filled);
+// product builds by definning HEAP_REGION_SET_FORCE_VERIFY to be 1).
+#if HEAP_REGION_SET_FORCE_VERIFY
-void put_region_on_unclean_list(HeapRegion* r);
+void verify_region_sets_optional() {
-void put_region_on_unclean_list_locked(HeapRegion* r);
+verify_region_sets();
+}
-void prepend_region_list_on_unclean_list(UncleanRegionList* list);
+#else // HEAP_REGION_SET_FORCE_VERIFY
-void prepend_region_list_on_unclean_list_locked(UncleanRegionList* list);
+void verify_region_sets_optional() { }
+#endif // HEAP_REGION_SET_FORCE_VERIFY
-void set_unclean_regions_coming(bool b);
-void set_unclean_regions_coming_locked(bool b);
+#ifdef ASSERT
-// Wait for cleanup to be complete.
+bool is_on_free_list(HeapRegion* hr) {
-void wait_for_cleanup_complete();
+return hr->containing_set() == &_free_list;
-// Like above, but assumes that the calling thread owns the Heap_lock.
+}
-void wait_for_cleanup_complete_locked();
+bool is_on_humongous_set(HeapRegion* hr) {
-// Return the head of the unclean list.
+return hr->containing_set() == &_humongous_set;
-HeapRegion* peek_unclean_region_list_locked();
+}
-// Remove and return the head of the unclean list.
+#endif // ASSERT
-HeapRegion* pop_unclean_region_list_locked();
+// Wrapper for the region list operations that can be called from
-// List of regions which are zero filled and ready for allocation.
+// methods outside this class.
-HeapRegion* _free_region_list;
-// Number of elements on the free list.
+void secondary_free_list_add_as_tail(FreeRegionList* list) {
-size_t _free_region_list_size;
+_secondary_free_list.add_as_tail(list);
+}
-// If the head of the unclean list is ZeroFilled, move it to the free
-// list.
+void append_secondary_free_list() {
-bool move_cleaned_region_to_free_list_locked();
+_free_list.add_as_tail(&_secondary_free_list);
-bool move_cleaned_region_to_free_list();
+}
-void put_free_region_on_list_locked(HeapRegion* r);
+void append_secondary_free_list_if_not_empty() {
-void put_free_region_on_list(HeapRegion* r);
+if (!_secondary_free_list.is_empty()) {
+MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
-// Remove and return the head element of the free list.
+append_secondary_free_list();
-HeapRegion* pop_free_region_list_locked();
+}
+}
-// If "zero_filled" is true, we first try the free list, then we try the
-// unclean list, zero-filling the result.  If "zero_filled" is false, we
+void set_free_regions_coming();
-// first try the unclean list, then the zero-filled list.
+void reset_free_regions_coming();
-HeapRegion* alloc_free_region_from_lists(bool zero_filled);
+bool free_regions_coming() { return _free_regions_coming; }
+void wait_while_free_regions_coming();
-// Verify the integrity of the region lists.
-void remove_allocated_regions_from_lists();
-bool verify_region_lists();
-bool verify_region_lists_locked();
-size_t unclean_region_list_length();
-size_t free_region_list_length();
 // Perform a collection of the heap; intended for use in implementing
 // "System.gc".  This probably implies as full a collection as the
 // "CollectedHeap" supports.
 virtual void collect(GCCause::Cause cause);
 virtual void collect_as_vm_thread(GCCause::Cause cause);
 // True iff a evacuation has failed in the most-recent collection.
 bool evacuation_failed() { return _evacuation_failed; }
-// Free a region if it is totally full of garbage.  Returns the number of
+// It will free a region if it has allocated objects in it that are
-// bytes freed (0 ==> didn't free it).
+// all dead. It calls either free_region() or
-size_t free_region_if_totally_empty(HeapRegion *hr);
+// free_humongous_region() depending on the type of the region that
-void free_region_if_totally_empty_work(HeapRegion *hr,
+// is passed to it.
-size_t& pre_used,
+void free_region_if_empty(HeapRegion* hr,
-size_t& cleared_h_regions,
+size_t* pre_used,
-size_t& freed_regions,
+FreeRegionList* free_list,
-UncleanRegionList* list,
+HumongousRegionSet* humongous_proxy_set,
-bool par = false);
+HRRSCleanupTask* hrrs_cleanup_task,
+bool par);
-// If we've done free region work that yields the given changes, update
-// the relevant global variables.
+// It appends the free list to the master free list and updates the
-void finish_free_region_work(size_t pre_used,
+// master humongous list according to the contents of the proxy
-size_t cleared_h_regions,
+// list. It also adjusts the total used bytes according to pre_used
-size_t freed_regions,
+// (if par is true, it will do so by taking the ParGCRareEvent_lock).
-UncleanRegionList* list);
+void update_sets_after_freeing_regions(size_t pre_used,
+FreeRegionList* free_list,
+HumongousRegionSet* humongous_proxy_set,
+bool par);
 // Returns "TRUE" iff "p" points into the allocated area of the heap.
 virtual bool is_in(const void* p) const;
 // Return "TRUE" iff the given object address is within the collection
 // At least until perm gen collection is also G1-ified, at
 // which point this should return false.
 return true;
 }
-virtual bool allocs_are_zero_filled();
 // The boundary between a "large" and "small" array of primitives, in
 // words.
 virtual size_t large_typearray_limit();
 // Returns "true" iff the given word_size is "very large".
 // </NEW PREDICTION>
 protected:
 size_t _max_heap_capacity;
-public:
-// Temporary: call to mark things unimplemented for the G1 heap (e.g.,
-// MemoryService).  In productization, we can make this assert false
-// to catch such places (as well as searching for calls to this...)
-static void g1_unimplemented();
 };
 #define use_local_bitmaps         1
 #define verify_local_bitmaps      0
 #define oop_buffer_length       256

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp @ 2181:d25d4ca69222