Mercurial > hg > graal-jvmci-8

comparison src/share/vm/memory/space.cpp @ 362:f8199438385b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge
author apetrusenko
date Wed, 17 Sep 2008 16:49:18 +0400
parents 1ee8caae33af
children 122d10c82f3f
comparison
equal deleted inserted replaced
316:5fa96a5a7e76 362:f8199438385b
103 assert(_precision == CardTableModRefBS::ObjHeadPreciseArray || 103 assert(_precision == CardTableModRefBS::ObjHeadPreciseArray ||
104 _precision == CardTableModRefBS::Precise, 104 _precision == CardTableModRefBS::Precise,
105 "Only ones we deal with for now."); 105 "Only ones we deal with for now.");
106 106
107 assert(_precision != CardTableModRefBS::ObjHeadPreciseArray || 107 assert(_precision != CardTableModRefBS::ObjHeadPreciseArray ||
108 _last_bottom == NULL || 108 _cl->idempotent() || _last_bottom == NULL ||
109 top <= _last_bottom, 109 top <= _last_bottom,
110 "Not decreasing"); 110 "Not decreasing");
111 NOT_PRODUCT(_last_bottom = mr.start()); 111 NOT_PRODUCT(_last_bottom = mr.start());
112 112
113 bottom_obj = _sp->block_start(bottom); 113 bottom_obj = _sp->block_start(bottom);
142 // Walk the region if it is not empty; otherwise there is nothing to do. 142 // Walk the region if it is not empty; otherwise there is nothing to do.
143 if (!mr.is_empty()) { 143 if (!mr.is_empty()) {
144 walk_mem_region(mr, bottom_obj, top); 144 walk_mem_region(mr, bottom_obj, top);
145 } 145 }
146 146
147 _min_done = bottom; 147 // An idempotent closure might be applied in any order, so we don't
148 // record a _min_done for it.
149 if (!_cl->idempotent()) {
150 _min_done = bottom;
151 } else {
152 assert(_min_done == _last_explicit_min_done,
153 "Don't update _min_done for idempotent cl");
154 }
148 } 155 }
149 156
150 DirtyCardToOopClosure* Space::new_dcto_cl(OopClosure* cl, 157 DirtyCardToOopClosure* Space::new_dcto_cl(OopClosure* cl,
151 CardTableModRefBS::PrecisionStyle precision, 158 CardTableModRefBS::PrecisionStyle precision,
152 HeapWord* boundary) { 159 HeapWord* boundary) {
248 if (ZapUnusedHeapArea && mangle_space) { 255 if (ZapUnusedHeapArea && mangle_space) {
249 mangle_unused_area(); 256 mangle_unused_area();
250 } 257 }
251 } 258 }
252 259
253 ContiguousSpace::ContiguousSpace(): CompactibleSpace(), _top(NULL) { 260 ContiguousSpace::ContiguousSpace(): CompactibleSpace(), _top(NULL),
261 _concurrent_iteration_safe_limit(NULL) {
254 _mangler = new GenSpaceMangler(this); 262 _mangler = new GenSpaceMangler(this);
255 } 263 }
256 264
257 ContiguousSpace::~ContiguousSpace() { 265 ContiguousSpace::~ContiguousSpace() {
258 delete _mangler; 266 delete _mangler;
261 void ContiguousSpace::initialize(MemRegion mr, 269 void ContiguousSpace::initialize(MemRegion mr,
262 bool clear_space, 270 bool clear_space,
263 bool mangle_space) 271 bool mangle_space)
264 { 272 {
265 CompactibleSpace::initialize(mr, clear_space, mangle_space); 273 CompactibleSpace::initialize(mr, clear_space, mangle_space);
266 _concurrent_iteration_safe_limit = top(); 274 set_concurrent_iteration_safe_limit(top());
267 } 275 }
268 276
269 void ContiguousSpace::clear(bool mangle_space) { 277 void ContiguousSpace::clear(bool mangle_space) {
270 set_top(bottom()); 278 set_top(bottom());
271 set_saved_mark(); 279 set_saved_mark();
272 Space::clear(mangle_space); 280 CompactibleSpace::clear(mangle_space);
273 } 281 }
274 282
275 bool Space::is_in(const void* p) const { 283 bool Space::is_in(const void* p) const {
276 HeapWord* b = block_start(p); 284 HeapWord* b = block_start_const(p);
277 return b != NULL && block_is_obj(b); 285 return b != NULL && block_is_obj(b);
278 } 286 }
279 287
280 bool ContiguousSpace::is_in(const void* p) const { 288 bool ContiguousSpace::is_in(const void* p) const {
281 return _bottom <= p && p < _top; 289 return _bottom <= p && p < _top;
340 348
341 void CompactibleSpace::initialize(MemRegion mr, 349 void CompactibleSpace::initialize(MemRegion mr,
342 bool clear_space, 350 bool clear_space,
343 bool mangle_space) { 351 bool mangle_space) {
344 Space::initialize(mr, clear_space, mangle_space); 352 Space::initialize(mr, clear_space, mangle_space);
353 set_compaction_top(bottom());
354 _next_compaction_space = NULL;
355 }
356
357 void CompactibleSpace::clear(bool mangle_space) {
358 Space::clear(mangle_space);
345 _compaction_top = bottom(); 359 _compaction_top = bottom();
346 _next_compaction_space = NULL;
347 } 360 }
348 361
349 HeapWord* CompactibleSpace::forward(oop q, size_t size, 362 HeapWord* CompactibleSpace::forward(oop q, size_t size,
350 CompactPoint* cp, HeapWord* compact_top) { 363 CompactPoint* cp, HeapWord* compact_top) {
351 // q is alive 364 // q is alive
518 prev_p = p; 531 prev_p = p;
519 p += oop(p)->size(); 532 p += oop(p)->size();
520 } 533 }
521 guarantee(p == top(), "end of last object must match end of space"); 534 guarantee(p == top(), "end of last object must match end of space");
522 if (top() != end()) { 535 if (top() != end()) {
523 guarantee(top() == block_start(end()-1) && 536 guarantee(top() == block_start_const(end()-1) &&
524 top() == block_start(top()), 537 top() == block_start_const(top()),
525 "top should be start of unallocated block, if it exists"); 538 "top should be start of unallocated block, if it exists");
526 } 539 }
527 } 540 }
528 541
529 void Space::oop_iterate(OopClosure* blk) { 542 void Space::oop_iterate(OopClosure* blk) {
751 ALL_SINCE_SAVE_MARKS_CLOSURES(ContigSpace_OOP_SINCE_SAVE_MARKS_DEFN) 764 ALL_SINCE_SAVE_MARKS_CLOSURES(ContigSpace_OOP_SINCE_SAVE_MARKS_DEFN)
752 765
753 #undef ContigSpace_OOP_SINCE_SAVE_MARKS_DEFN 766 #undef ContigSpace_OOP_SINCE_SAVE_MARKS_DEFN
754 767
755 // Very general, slow implementation. 768 // Very general, slow implementation.
756 HeapWord* ContiguousSpace::block_start(const void* p) const { 769 HeapWord* ContiguousSpace::block_start_const(const void* p) const {
757 assert(MemRegion(bottom(), end()).contains(p), "p not in space"); 770 assert(MemRegion(bottom(), end()).contains(p), "p not in space");
758 if (p >= top()) { 771 if (p >= top()) {
759 return top(); 772 return top();
760 } else { 773 } else {
761 HeapWord* last = bottom(); 774 HeapWord* last = bottom();
955 while (p < top()) { 968 while (p < top()) {
956 size_t size = oop(p)->size(); 969 size_t size = oop(p)->size();
957 // For a sampling of objects in the space, find it using the 970 // For a sampling of objects in the space, find it using the
958 // block offset table. 971 // block offset table.
959 if (blocks == BLOCK_SAMPLE_INTERVAL) { 972 if (blocks == BLOCK_SAMPLE_INTERVAL) {
960 guarantee(p == block_start(p + (size/2)), "check offset computation"); 973 guarantee(p == block_start_const(p + (size/2)),
974 "check offset computation");
961 blocks = 0; 975 blocks = 0;
962 } else { 976 } else {
963 blocks++; 977 blocks++;
964 } 978 }
965 979