--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.inline.hpp Tue Jan 10 20:02:41 2012 +0100
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.inline.hpp Tue Jan 10 18:58:13 2012 -0500
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
+ * 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
@@ -55,4 +55,71 @@
return _offsets.block_start_const(p);
}
+inline void HeapRegion::note_start_of_marking() {
+ init_top_at_conc_mark_count();
+ _next_marked_bytes = 0;
+ _next_top_at_mark_start = top();
+}
+
+inline void HeapRegion::note_end_of_marking() {
+ _prev_top_at_mark_start = _next_top_at_mark_start;
+ _prev_marked_bytes = _next_marked_bytes;
+ _next_marked_bytes = 0;
+
+ assert(_prev_marked_bytes <=
+ (size_t) pointer_delta(prev_top_at_mark_start(), bottom()) *
+ HeapWordSize, "invariant");
+}
+
+inline void HeapRegion::note_start_of_copying(bool during_initial_mark) {
+ if (during_initial_mark) {
+ if (is_survivor()) {
+ assert(false, "should not allocate survivors during IM");
+ } else {
+ // During initial-mark we'll explicitly mark any objects on old
+ // regions that are pointed to by roots. Given that explicit
+ // marks only make sense under NTAMS it'd be nice if we could
+ // check that condition if we wanted to. Given that we don't
+ // know where the top of this region will end up, we simply set
+ // NTAMS to the end of the region so all marks will be below
+ // NTAMS. We'll set it to the actual top when we retire this region.
+ _next_top_at_mark_start = end();
+ }
+ } else {
+ if (is_survivor()) {
+ // This is how we always allocate survivors.
+ assert(_next_top_at_mark_start == bottom(), "invariant");
+ } else {
+ // We could have re-used this old region as to-space over a
+ // couple of GCs since the start of the concurrent marking
+ // cycle. This means that [bottom,NTAMS) will contain objects
+ // copied up to and including initial-mark and [NTAMS, top)
+ // will contain objects copied during the concurrent marking cycle.
+ assert(top() >= _next_top_at_mark_start, "invariant");
+ }
+ }
+}
+
+inline void HeapRegion::note_end_of_copying(bool during_initial_mark) {
+ if (during_initial_mark) {
+ if (is_survivor()) {
+ assert(false, "should not allocate survivors during IM");
+ } else {
+ // See the comment for note_start_of_copying() for the details
+ // on this.
+ assert(_next_top_at_mark_start == end(), "pre-condition");
+ _next_top_at_mark_start = top();
+ }
+ } else {
+ if (is_survivor()) {
+ // This is how we always allocate survivors.
+ assert(_next_top_at_mark_start == bottom(), "invariant");
+ } else {
+ // See the comment for note_start_of_copying() for the details
+ // on this.
+ assert(top() >= _next_top_at_mark_start, "invariant");
+ }
+ }
+}
+
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_INLINE_HPP