g1RemSet.cpp revision 2819
2069N/A * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. 342N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 342N/A * This code is free software; you can redistribute it and/or modify it 342N/A * under the terms of the GNU General Public License version 2 only, as 342N/A * published by the Free Software Foundation. 342N/A * This code is distributed in the hope that it will be useful, but WITHOUT 342N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 342N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 342N/A * version 2 for more details (a copy is included in the LICENSE file that 342N/A * accompanied this code). 342N/A * You should have received a copy of the GNU General Public License version 342N/A * 2 along with this work; if not, write to the Free Software Foundation, 342N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 1472N/A * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 342N/A // Set the "from" region in the closure. 2414N/A // We make the card as "claimed" lazily (so races are possible 2414N/A // but they're benign), which reduces the number of duplicate 2414N/A // scans (the rsets of the regions in the cset can intersect). 2414N/A // If we ever free the collection set concurrently, we should also 2414N/A // clear the card table concurrently therefore we won't need to 2414N/A // add regions of the collection set to the dirty cards region. 342N/A // If we didn't return above, then 342N/A // _try_claimed || r->claim_iter() 342N/A // is true: either we're supposed to work on claimed-but-not-complete 342N/A // regions, or we successfully claimed the region. 1261N/A // We claim cards in block so as to recude the contention. The block size is determined by 1261N/A // the G1RSetScanBlockSize parameter. 2414N/A // If the card is dirty, then we will scan it during updateRS. 342N/A// We want the parallel threads to start their scanning at 342N/A// different collection set regions to avoid contention. 342N/A// n collection set regions 342N/A// Then thread t will start at region t * floor (n/p) 1625N/A// Closure used for updating RSets and recording references that 1625N/A// point into the collection set. Only called during an 1625N/A // The only time we care about recording cards that 1625N/A // contain references that point into the collection set 1625N/A // is during RSet updating within an evacuation pause. 1625N/A // In this case worker_i should be the id of a GC worker thread. 1625N/A // 'card_ptr' contains references that point into the collection 1625N/A // set. We need to record the card in the DCQS 1625N/A // (G1CollectedHeap::into_cset_dirty_card_queue_set()) 1625N/A // that's used for that purpose. 1625N/A // Apply the given closure to all remaining log entries. 794N/A // Now there should be no dirty cards. 794N/A // XXX This isn't true any more: keeping cards of young regions 794N/A // marked dirty broke it. Need some reasonable fix. 342N/A // Fit it into a histo bin. 342N/A // Make this into a command-line flag... 1625N/A // We cache the value of 'oc' closure into the appropriate slot in the 1625N/A // _cset_rs_update_cl for this worker 1625N/A // A DirtyCardQueue that is used to hold cards containing references 1625N/A // that point into the collection set. This DCQ is associated with a 1625N/A // circumstances (i.e. the pause successfully completes), these cards 1625N/A // are just discarded (there's no need to update the RSets of regions 1625N/A // that were in the collection set - after the pause these regions 1625N/A // are wholly 'free' of live objects. In the event of an evacuation 1625N/A // * passed to the DirtyCardQueueSet that is used to manage deferred 1625N/A // * scanned for references that point into the collection set 1625N/A // and the RSet of the corresponding region in the collection set 1628N/A // The two flags below were introduced temporarily to serialize 1628N/A // the updating and scanning of remembered sets. There are some 1628N/A // race conditions when these two operations are done in parallel 1628N/A // and they are causing failures. When we resolve said race 1628N/A // conditions, we'll revert back to parallel remembered set 1628N/A // updating and scanning. See CRs 6677707 and 6677708. 1625N/A // We now clear the cached values of _cset_rs_update_cl for this worker 1625N/A// This closure, applied to a DirtyCardQueueSet, is used to immediately 1625N/A// update the RSets for the regions in the CSet. For each card it iterates 1625N/A// through the oops which coincide with that card. It scans the reference 1625N/A// fields in each oop; when it finds an oop that points into the collection 1625N/A// set, the RSet for the region containing the referenced object is updated. 1625N/A // Construct the region representing the card. 1625N/A // And find the region containing it. 1625N/A // Scan oops in the card looking for references into the collection set 1625N/A // We can pass false as the "filter_young" parameter here as: 1625N/A // * we should be in a STW pause, 1625N/A // * the DCQS to which this closure is applied is used to hold 1625N/A // references that point into the collection set from the prior 1625N/A // * the post-write barrier shouldn't be logging updates to young 1625N/A // regions (but there is a situation where this can happen - see 1781N/A // the comment in G1RemSet::concurrentRefineOneCard below - 1625N/A // that should not be applicable here), and 1625N/A // * during actual RSet updating, the filtering of cards in young 1625N/A // regions in HeapRegion::oops_on_card_seq_iterate_careful is 1625N/A // As a result, when this closure is applied to "refs into cset" 1625N/A // DCQS, we shouldn't see any cards in young regions. 1625N/A // Since this is performed in the event of an evacuation failure, we 1625N/A // we shouldn't see a non-null stop point 342N/A // Set all cards back to clean. 1625N/A // Restore remembered sets for the regions pointing into the collection set. 1625N/A // If deferred RS updates are enabled then we just need to transfer 1625N/A // the completed buffers from (a) the DirtyCardQueueSet used to hold 1625N/A // cards that contain references that point into the collection set 1625N/A // to (b) the DCQS used to hold the deferred RS updates 1625N/A // Free any completed buffers in the DirtyCardQueueSet used to hold cards 1625N/A // which contain references that point into the collection. 1625N/A "all buffers should be freed");
890N/A // Construct the region representing the card. 890N/A // And find the region containing it. 1586N/A // The region for the current card may be a young region. The 1586N/A // current card may have been a card that was evicted from the 1586N/A // card cache. When the card was inserted into the cache, we had 1586N/A // determined that its region was non-young. While in the cache, 1586N/A // the region may have been freed during a cleanup pause, reallocated 1586N/A // We wish to filter out cards for such a region but the current 2414N/A // thread, if we're running concurrently, may "see" the young type 1586N/A // change at any time (so an earlier "is_young" check may pass or 1586N/A // fail arbitrarily). We tell the iteration code to perform this 1586N/A // filtering when it has been determined that there has been an actual 1586N/A // allocation in this region and making it safe to check the young type. 890N/A // If stop_point is non-null, then we encountered an unallocated region 890N/A // (perhaps the unfilled portion of a TLAB.) For now, we'll dirty the 890N/A // card and re-enqueue: if we put off the card until a GC pause, then the 890N/A // unallocated portion will be filled in. Alternatively, we might try 890N/A // the full complexity of the technique used in "regular" precleaning. 890N/A // The card might have gotten re-dirtied and re-enqueued while we 890N/A // worked. (In fact, it's pretty likely.) 342N/A // If the card is no longer dirty, nothing to do. 1625N/A // No need to return that this card contains refs that point 1625N/A // into the collection set. 342N/A // Construct the region representing the card. 342N/A // And find the region containing it. 1625N/A // Again no need to return that this card contains refs that 1625N/A // point into the collection set. 1625N/A return false;
// Not in the G1 heap (might be in perm, for example.) 342N/A // Why do we have to check here whether a card is on a young region, 342N/A // given that we dirty young regions and, as a result, the 342N/A // post-barrier is supposed to filter them out and never to enqueue 342N/A // them? When we allocate a new region as the "allocation region" we 342N/A // actually dirty its cards after we release the lock, since card 342N/A // dirtying while holding the lock was a performance bottleneck. So, 342N/A // as a result, it is possible for other threads to actually 342N/A // allocate objects in the region (after the acquire the lock) 342N/A // before all the cards on the region are dirtied. This is unlikely, 342N/A // and it doesn't happen often, but it can happen. So, the extra 342N/A // check below filters out those cards. 342N/A // While we are processing RSet buffers during the collection, we 342N/A // actually don't want to scan any cards on the collection set, 342N/A // since we don't want to update remebered sets with entries that 342N/A // point into the collection set, given that live objects from the 342N/A // collection set are about to move and such entries will be stale 342N/A // very soon. This change also deals with a reliability issue which 342N/A // involves scanning a card in the collection set and coming across 342N/A // an array that was being chunked and looking malformed. Note, 342N/A // however, that if evacuation fails, we have to scan any objects 342N/A // that were not moved and create any missing entries. 890N/A // Should we defer processing the card? 890N/A // Previously the result from the insert_cache call would be 890N/A // either card_ptr (implying that card_ptr was currently "cold"), 890N/A // null (meaning we had inserted the card ptr into the "hot" 890N/A // cache, which had some headroom), or a "hot" card ptr 890N/A // extracted from the "hot" cache. 890N/A // Now that the _card_counts cache in the ConcurrentG1Refine 890N/A // instance is an evicting hash table, the result we get back 890N/A // could be from evicting the card ptr in an already occupied 890N/A // bucket (in which case we have replaced the card ptr in the 890N/A // bucket with card_ptr and "defer" is set to false). To avoid 890N/A // having a data structure (updates to which would need a lock) 890N/A // to hold these unprocessed dirty cards, we need to immediately 890N/A // process card_ptr. The actions needed to be taken on return 890N/A // from cache_insert are summarized in the following table: 890N/A // -------------------------------------------------------------- 890N/A // null false card evicted from _card_counts & replaced with 890N/A // card_ptr; evicted ptr added to hot cache. 890N/A // No need to process res; immediately process card_ptr 890N/A // null true card not evicted from _card_counts; card_ptr added 890N/A // non-null false card evicted from _card_counts & replaced with 890N/A // card_ptr; evicted ptr is currently "cold" or 890N/A // caused an eviction from the hot cache. 890N/A // Immediately process res; process card_ptr. 890N/A // non-null true card not evicted from _card_counts; card_ptr is 890N/A // currently cold, or caused an eviction from hot 890N/A // Immediately process res; no need to process card_ptr. 1625N/A // This gets set to true if the card being refined has references 1625N/A // that point into the collection set. 1586N/A // Checking whether the region we got back from the cache 1586N/A // is young here is inappropriate. The region could have been 1586N/A // freed, reallocated and tagged as young while in the cache. 1586N/A // Hence we could see its young type change at any time. 1586N/A // Process card pointer we get back from the hot card cache. This 1586N/A // will check whether the region containing the card is young 1586N/A // _after_ checking that the region has been allocated from. 1625N/A false /* check_for_refs_into_cset */);
1625N/A // The above call to concurrentRefineOneCard_impl is only 1625N/A // performed if the hot card cache is enabled. This cache is 1625N/A // disabled during an evacuation pause - which is the only 1625N/A // time when we need know if the card contains references 1625N/A // that point into the collection set. Also when the hot card 1625N/A // cache is enabled, this code is executed by the concurrent 1625N/A // refine threads - rather than the GC worker threads - and 1625N/A // concurrentRefineOneCard_impl will return false. 1625N/A // We should only be detecting that the card contains references 1625N/A // that point into the collection set if the current thread is 1625N/A "invalid result at non safepoint");