188 // Verify the assumption that FreeChunk::_prev and OopDesc::_klass |
188 // Verify the assumption that FreeChunk::_prev and OopDesc::_klass |
189 // offsets match. The ability to tell free chunks from objects |
189 // offsets match. The ability to tell free chunks from objects |
190 // depends on this property. |
190 // depends on this property. |
191 debug_only( |
191 debug_only( |
192 FreeChunk* junk = NULL; |
192 FreeChunk* junk = NULL; |
193 assert(junk->prev_addr() == (void*)(oop(junk)->klass_addr()), |
193 assert(UseCompressedOops || |
|
194 junk->prev_addr() == (void*)(oop(junk)->klass_addr()), |
194 "Offset of FreeChunk::_prev within FreeChunk must match" |
195 "Offset of FreeChunk::_prev within FreeChunk must match" |
195 " that of OopDesc::_klass within OopDesc"); |
196 " that of OopDesc::_klass within OopDesc"); |
196 ) |
197 ) |
197 if (ParallelGCThreads > 0) { |
198 if (ParallelGCThreads > 0) { |
198 typedef CMSParGCThreadState* CMSParGCThreadStatePtr; |
199 typedef CMSParGCThreadState* CMSParGCThreadStatePtr; |
1037 _markBitMap.mark(start + 1); // object is potentially uninitialized? |
1038 _markBitMap.mark(start + 1); // object is potentially uninitialized? |
1038 _markBitMap.mark(start + size - 1); |
1039 _markBitMap.mark(start + size - 1); |
1039 // mark end of object |
1040 // mark end of object |
1040 } |
1041 } |
1041 // check that oop looks uninitialized |
1042 // check that oop looks uninitialized |
1042 assert(oop(start)->klass() == NULL, "_klass should be NULL"); |
1043 assert(oop(start)->klass_or_null() == NULL, "_klass should be NULL"); |
1043 } |
1044 } |
1044 |
1045 |
1045 void CMSCollector::promoted(bool par, HeapWord* start, |
1046 void CMSCollector::promoted(bool par, HeapWord* start, |
1046 bool is_obj_array, size_t obj_size) { |
1047 bool is_obj_array, size_t obj_size) { |
1047 assert(_markBitMap.covers(start), "Out of bounds"); |
1048 assert(_markBitMap.covers(start), "Out of bounds"); |
1307 if (obj_ptr == NULL) { |
1308 if (obj_ptr == NULL) { |
1308 return NULL; |
1309 return NULL; |
1309 } |
1310 } |
1310 } |
1311 } |
1311 oop obj = oop(obj_ptr); |
1312 oop obj = oop(obj_ptr); |
1312 assert(obj->klass() == NULL, "Object should be uninitialized here."); |
1313 assert(obj->klass_or_null() == NULL, "Object should be uninitialized here."); |
1313 // Otherwise, copy the object. Here we must be careful to insert the |
1314 // Otherwise, copy the object. Here we must be careful to insert the |
1314 // klass pointer last, since this marks the block as an allocated object. |
1315 // klass pointer last, since this marks the block as an allocated object. |
|
1316 // Except with compressed oops it's the mark word. |
1315 HeapWord* old_ptr = (HeapWord*)old; |
1317 HeapWord* old_ptr = (HeapWord*)old; |
1316 if (word_sz > (size_t)oopDesc::header_size()) { |
1318 if (word_sz > (size_t)oopDesc::header_size()) { |
1317 Copy::aligned_disjoint_words(old_ptr + oopDesc::header_size(), |
1319 Copy::aligned_disjoint_words(old_ptr + oopDesc::header_size(), |
1318 obj_ptr + oopDesc::header_size(), |
1320 obj_ptr + oopDesc::header_size(), |
1319 word_sz - oopDesc::header_size()); |
1321 word_sz - oopDesc::header_size()); |
1320 } |
1322 } |
|
1323 |
|
1324 if (UseCompressedOops) { |
|
1325 // Copy gap missed by (aligned) header size calculation above |
|
1326 obj->set_klass_gap(old->klass_gap()); |
|
1327 } |
|
1328 |
1321 // Restore the mark word copied above. |
1329 // Restore the mark word copied above. |
1322 obj->set_mark(m); |
1330 obj->set_mark(m); |
|
1331 |
1323 // Now we can track the promoted object, if necessary. We take care |
1332 // Now we can track the promoted object, if necessary. We take care |
1324 // To delay the transition from uninitialized to full object |
1333 // To delay the transition from uninitialized to full object |
1325 // (i.e., insertion of klass pointer) until after, so that it |
1334 // (i.e., insertion of klass pointer) until after, so that it |
1326 // atomically becomes a promoted object. |
1335 // atomically becomes a promoted object. |
1327 if (promoInfo->tracking()) { |
1336 if (promoInfo->tracking()) { |
1328 promoInfo->track((PromotedObject*)obj, old->klass()); |
1337 promoInfo->track((PromotedObject*)obj, old->klass()); |
1329 } |
1338 } |
1330 // Finally, install the klass pointer. |
1339 |
|
1340 // Finally, install the klass pointer (this should be volatile). |
1331 obj->set_klass(old->klass()); |
1341 obj->set_klass(old->klass()); |
1332 |
1342 |
1333 assert(old->is_oop(), "Will dereference klass ptr below"); |
1343 assert(old->is_oop(), "Will dereference klass ptr below"); |
1334 collector()->promoted(true, // parallel |
1344 collector()->promoted(true, // parallel |
1335 obj_ptr, old->is_objArray(), word_sz); |
1345 obj_ptr, old->is_objArray(), word_sz); |
6604 // and we have been asked to abort this ongoing preclean cycle. |
6614 // and we have been asked to abort this ongoing preclean cycle. |
6605 return 0; |
6615 return 0; |
6606 } |
6616 } |
6607 if (_bitMap->isMarked(addr)) { |
6617 if (_bitMap->isMarked(addr)) { |
6608 // it's marked; is it potentially uninitialized? |
6618 // it's marked; is it potentially uninitialized? |
6609 if (p->klass() != NULL) { |
6619 if (p->klass_or_null() != NULL) { |
6610 if (CMSPermGenPrecleaningEnabled && !p->is_parsable()) { |
6620 if (CMSPermGenPrecleaningEnabled && !p->is_parsable()) { |
6611 // Signal precleaning to redirty the card since |
6621 // Signal precleaning to redirty the card since |
6612 // the klass pointer is already installed. |
6622 // the klass pointer is already installed. |
6613 assert(size == 0, "Initial value"); |
6623 assert(size == 0, "Initial value"); |
6614 } else { |
6624 } else { |
6617 // since we are running concurrent with mutators |
6627 // since we are running concurrent with mutators |
6618 assert(p->is_oop(true), "should be an oop"); |
6628 assert(p->is_oop(true), "should be an oop"); |
6619 if (p->is_objArray()) { |
6629 if (p->is_objArray()) { |
6620 // objArrays are precisely marked; restrict scanning |
6630 // objArrays are precisely marked; restrict scanning |
6621 // to dirty cards only. |
6631 // to dirty cards only. |
6622 size = p->oop_iterate(_scanningClosure, mr); |
6632 size = CompactibleFreeListSpace::adjustObjectSize( |
6623 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), |
6633 p->oop_iterate(_scanningClosure, mr)); |
6624 "adjustObjectSize should be the identity for array sizes, " |
|
6625 "which are necessarily larger than minimum object size of " |
|
6626 "two heap words"); |
|
6627 } else { |
6634 } else { |
6628 // A non-array may have been imprecisely marked; we need |
6635 // A non-array may have been imprecisely marked; we need |
6629 // to scan object in its entirety. |
6636 // to scan object in its entirety. |
6630 size = CompactibleFreeListSpace::adjustObjectSize( |
6637 size = CompactibleFreeListSpace::adjustObjectSize( |
6631 p->oop_iterate(_scanningClosure)); |
6638 p->oop_iterate(_scanningClosure)); |
6655 // will dirty the card when the klass pointer is installed in the |
6662 // will dirty the card when the klass pointer is installed in the |
6656 // object (signalling the completion of initialization). |
6663 // object (signalling the completion of initialization). |
6657 } |
6664 } |
6658 } else { |
6665 } else { |
6659 // Either a not yet marked object or an uninitialized object |
6666 // Either a not yet marked object or an uninitialized object |
6660 if (p->klass() == NULL || !p->is_parsable()) { |
6667 if (p->klass_or_null() == NULL || !p->is_parsable()) { |
6661 // An uninitialized object, skip to the next card, since |
6668 // An uninitialized object, skip to the next card, since |
6662 // we may not be able to read its P-bits yet. |
6669 // we may not be able to read its P-bits yet. |
6663 assert(size == 0, "Initial value"); |
6670 assert(size == 0, "Initial value"); |
6664 } else { |
6671 } else { |
6665 // An object not (yet) reached by marking: we merely need to |
6672 // An object not (yet) reached by marking: we merely need to |
6712 size_t SurvivorSpacePrecleanClosure::do_object_careful(oop p) { |
6719 size_t SurvivorSpacePrecleanClosure::do_object_careful(oop p) { |
6713 |
6720 |
6714 HeapWord* addr = (HeapWord*)p; |
6721 HeapWord* addr = (HeapWord*)p; |
6715 DEBUG_ONLY(_collector->verify_work_stacks_empty();) |
6722 DEBUG_ONLY(_collector->verify_work_stacks_empty();) |
6716 assert(!_span.contains(addr), "we are scanning the survivor spaces"); |
6723 assert(!_span.contains(addr), "we are scanning the survivor spaces"); |
6717 assert(p->klass() != NULL, "object should be initializd"); |
6724 assert(p->klass_or_null() != NULL, "object should be initializd"); |
6718 assert(p->is_parsable(), "must be parsable."); |
6725 assert(p->is_parsable(), "must be parsable."); |
6719 // an initialized object; ignore mark word in verification below |
6726 // an initialized object; ignore mark word in verification below |
6720 // since we are running concurrent with mutators |
6727 // since we are running concurrent with mutators |
6721 assert(p->is_oop(true), "should be an oop"); |
6728 assert(p->is_oop(true), "should be an oop"); |
6722 // Note that we do not yield while we iterate over |
6729 // Note that we do not yield while we iterate over |
6870 if (_bitMap->isMarked(addr+1)) { |
6877 if (_bitMap->isMarked(addr+1)) { |
6871 // this is an allocated but not yet initialized object |
6878 // this is an allocated but not yet initialized object |
6872 assert(_skipBits == 0, "tautology"); |
6879 assert(_skipBits == 0, "tautology"); |
6873 _skipBits = 2; // skip next two marked bits ("Printezis-marks") |
6880 _skipBits = 2; // skip next two marked bits ("Printezis-marks") |
6874 oop p = oop(addr); |
6881 oop p = oop(addr); |
6875 if (p->klass() == NULL || !p->is_parsable()) { |
6882 if (p->klass_or_null() == NULL || !p->is_parsable()) { |
6876 DEBUG_ONLY(if (!_verifying) {) |
6883 DEBUG_ONLY(if (!_verifying) {) |
6877 // We re-dirty the cards on which this object lies and increase |
6884 // We re-dirty the cards on which this object lies and increase |
6878 // the _threshold so that we'll come back to scan this object |
6885 // the _threshold so that we'll come back to scan this object |
6879 // during the preclean or remark phase. (CMSCleanOnEnter) |
6886 // during the preclean or remark phase. (CMSCleanOnEnter) |
6880 if (CMSCleanOnEnter) { |
6887 if (CMSCleanOnEnter) { |
6892 assert(_threshold <= end_card_addr, |
6899 assert(_threshold <= end_card_addr, |
6893 "Because we are just scanning into this object"); |
6900 "Because we are just scanning into this object"); |
6894 if (_threshold < end_card_addr) { |
6901 if (_threshold < end_card_addr) { |
6895 _threshold = end_card_addr; |
6902 _threshold = end_card_addr; |
6896 } |
6903 } |
6897 if (p->klass() != NULL) { |
6904 if (p->klass_or_null() != NULL) { |
6898 // Redirty the range of cards... |
6905 // Redirty the range of cards... |
6899 _mut->mark_range(redirty_range); |
6906 _mut->mark_range(redirty_range); |
6900 } // ...else the setting of klass will dirty the card anyway. |
6907 } // ...else the setting of klass will dirty the card anyway. |
6901 } |
6908 } |
6902 DEBUG_ONLY(}) |
6909 DEBUG_ONLY(}) |
7051 if (_bit_map->isMarked(addr+1)) { |
7058 if (_bit_map->isMarked(addr+1)) { |
7052 // this is an allocated object that might not yet be initialized |
7059 // this is an allocated object that might not yet be initialized |
7053 assert(_skip_bits == 0, "tautology"); |
7060 assert(_skip_bits == 0, "tautology"); |
7054 _skip_bits = 2; // skip next two marked bits ("Printezis-marks") |
7061 _skip_bits = 2; // skip next two marked bits ("Printezis-marks") |
7055 oop p = oop(addr); |
7062 oop p = oop(addr); |
7056 if (p->klass() == NULL || !p->is_parsable()) { |
7063 if (p->klass_or_null() == NULL || !p->is_parsable()) { |
7057 // in the case of Clean-on-Enter optimization, redirty card |
7064 // in the case of Clean-on-Enter optimization, redirty card |
7058 // and avoid clearing card by increasing the threshold. |
7065 // and avoid clearing card by increasing the threshold. |
7059 return true; |
7066 return true; |
7060 } |
7067 } |
7061 } |
7068 } |
8032 size = pointer_delta(nextOneAddr + 1, addr); |
8039 size = pointer_delta(nextOneAddr + 1, addr); |
8033 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), |
8040 assert(size == CompactibleFreeListSpace::adjustObjectSize(size), |
8034 "alignment problem"); |
8041 "alignment problem"); |
8035 |
8042 |
8036 #ifdef DEBUG |
8043 #ifdef DEBUG |
8037 if (oop(addr)->klass() != NULL && |
8044 if (oop(addr)->klass_or_null() != NULL && |
8038 ( !_collector->should_unload_classes() |
8045 ( !_collector->should_unload_classes() |
8039 || oop(addr)->is_parsable())) { |
8046 || oop(addr)->is_parsable())) { |
8040 // Ignore mark word because we are running concurrent with mutators |
8047 // Ignore mark word because we are running concurrent with mutators |
8041 assert(oop(addr)->is_oop(true), "live block should be an oop"); |
8048 assert(oop(addr)->is_oop(true), "live block should be an oop"); |
8042 assert(size == |
8049 assert(size == |
8045 } |
8052 } |
8046 #endif |
8053 #endif |
8047 |
8054 |
8048 } else { |
8055 } else { |
8049 // This should be an initialized object that's alive. |
8056 // This should be an initialized object that's alive. |
8050 assert(oop(addr)->klass() != NULL && |
8057 assert(oop(addr)->klass_or_null() != NULL && |
8051 (!_collector->should_unload_classes() |
8058 (!_collector->should_unload_classes() |
8052 || oop(addr)->is_parsable()), |
8059 || oop(addr)->is_parsable()), |
8053 "Should be an initialized object"); |
8060 "Should be an initialized object"); |
8054 // Ignore mark word because we are running concurrent with mutators |
8061 // Ignore mark word because we are running concurrent with mutators |
8055 assert(oop(addr)->is_oop(true), "live block should be an oop"); |
8062 assert(oop(addr)->is_oop(true), "live block should be an oop"); |