jdk-sandbox: comparison src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp

equal deleted inserted replaced

-:21dccfac0ec5
+:90ead0febf56
 // size of an object that may not yet have been initialized.
 // Things to support parallel young-gen collection.
 oop
 ConcurrentMarkSweepGeneration::par_promote(int thread_num,
-oop old, markOop m,
+oop old, markWord m,
 size_t word_sz) {
 #ifndef PRODUCT
 if (CMSHeap::heap()->promotion_should_fail()) {
 return NULL;
 }
 bool CMSCollector::take_from_overflow_list(size_t num, CMSMarkStack* stack) {
 assert(stack->isEmpty(), "Expected precondition");
 assert(stack->capacity() > num, "Shouldn't bite more than can chew");
 size_t i = num;
 oop  cur = _overflow_list;
-const markOop proto = markOopDesc::prototype();
+const markWord proto = markWord::prototype();
 NOT_PRODUCT(ssize_t n = 0;)
 for (oop next; i > 0 && cur != NULL; cur = next, i--) {
-next = oop(cur->mark_raw());
+next = oop(cur->mark_raw().to_pointer());
 cur->set_mark_raw(proto);   // until proven otherwise
 assert(oopDesc::is_oop(cur), "Should be an oop");
 bool res = stack->push(cur);
 assert(res, "Bit off more than can chew?");
 NOT_PRODUCT(n++;)
 }
 assert(prefix != NULL && prefix != BUSY, "Error");
 size_t i = num;
 oop cur = prefix;
 // Walk down the first "num" objects, unless we reach the end.
-for (; i > 1 && cur->mark_raw() != NULL; cur = oop(cur->mark_raw()), i--);
+for (; i > 1 && cur->mark_raw().to_pointer() != NULL; cur = oop(cur->mark_raw().to_pointer()), i--);
-if (cur->mark_raw() == NULL) {
+if (cur->mark_raw().to_pointer() == NULL) {
 // We have "num" or fewer elements in the list, so there
 // is nothing to return to the global list.
 // Write back the NULL in lieu of the BUSY we wrote
 // above, if it is still the same value.
 if (_overflow_list == BUSY) {
 Atomic::cmpxchg((oopDesc*)NULL, &_overflow_list, (oopDesc*)BUSY);
 }
 } else {
 // Chop off the suffix and return it to the global list.
-assert(cur->mark_raw() != BUSY, "Error");
+assert(cur->mark_raw().to_pointer() != (void*)BUSY, "Error");
-oop suffix_head = cur->mark_raw(); // suffix will be put back on global list
+oop suffix_head = oop(cur->mark_raw().to_pointer()); // suffix will be put back on global list
-cur->set_mark_raw(NULL);           // break off suffix
+cur->set_mark_raw(markWord::from_pointer(NULL));     // break off suffix
 // It's possible that the list is still in the empty(busy) state
 // we left it in a short while ago; in that case we may be
 // able to place back the suffix without incurring the cost
 // of a walk down the list.
 oop observed_overflow_list = _overflow_list;
 }
 if (!attached) {
 // Too bad, someone else sneaked in (at least) an element; we'll need
 // to do a splice. Find tail of suffix so we can prepend suffix to global
 // list.
-for (cur = suffix_head; cur->mark_raw() != NULL; cur = (oop)(cur->mark_raw()));
+for (cur = suffix_head; cur->mark_raw().to_pointer() != NULL; cur = (oop)(cur->mark_raw().to_pointer()));
 oop suffix_tail = cur;
-assert(suffix_tail != NULL && suffix_tail->mark_raw() == NULL,
+assert(suffix_tail != NULL && suffix_tail->mark_raw().to_pointer() == NULL,
 "Tautology");
 observed_overflow_list = _overflow_list;
 do {
 cur_overflow_list = observed_overflow_list;
 if (cur_overflow_list != BUSY) {
 // Do the splice ...
-suffix_tail->set_mark_raw(markOop(cur_overflow_list));
+suffix_tail->set_mark_raw(markWord::from_pointer((void*)cur_overflow_list));
 } else { // cur_overflow_list == BUSY
-suffix_tail->set_mark_raw(NULL);
+suffix_tail->set_mark_raw(markWord::from_pointer(NULL));
 }
 // ... and try to place spliced list back on overflow_list ...
 observed_overflow_list =
 Atomic::cmpxchg((oopDesc*)suffix_head, &_overflow_list, (oopDesc*)cur_overflow_list);
 } while (cur_overflow_list != observed_overflow_list);
 }
 }
 // Push the prefix elements on work_q
 assert(prefix != NULL, "control point invariant");
-const markOop proto = markOopDesc::prototype();
+const markWord proto = markWord::prototype();
 oop next;
 NOT_PRODUCT(ssize_t n = 0;)
 for (cur = prefix; cur != NULL; cur = next) {
-next = oop(cur->mark_raw());
+next = oop(cur->mark_raw().to_pointer());
 cur->set_mark_raw(proto);   // until proven otherwise
 assert(oopDesc::is_oop(cur), "Should be an oop");
 bool res = work_q->push(cur);
 assert(res, "Bit off more than we can chew?");
 NOT_PRODUCT(n++;)
 // Single-threaded
 void CMSCollector::push_on_overflow_list(oop p) {
 NOT_PRODUCT(_num_par_pushes++;)
 assert(oopDesc::is_oop(p), "Not an oop");
 preserve_mark_if_necessary(p);
-p->set_mark_raw((markOop)_overflow_list);
+p->set_mark_raw(markWord::from_pointer(_overflow_list));
 _overflow_list = p;
 }
 // Multi-threaded; use CAS to prepend to overflow list
 void CMSCollector::par_push_on_overflow_list(oop p) {
 oop observed_overflow_list = _overflow_list;
 oop cur_overflow_list;
 do {
 cur_overflow_list = observed_overflow_list;
 if (cur_overflow_list != BUSY) {
-p->set_mark_raw(markOop(cur_overflow_list));
+p->set_mark_raw(markWord::from_pointer((void*)cur_overflow_list));
 } else {
-p->set_mark_raw(NULL);
+p->set_mark_raw(markWord::from_pointer(NULL));
 }
 observed_overflow_list =
 Atomic::cmpxchg((oopDesc*)p, &_overflow_list, (oopDesc*)cur_overflow_list);
 } while (cur_overflow_list != observed_overflow_list);
 }
 // an indication of success or failure with the assumption that
 // the caller may be able to recover from a failure; code in
 // the VM can then be changed, incrementally, to deal with such
 // failures where possible, thus, incrementally hardening the VM
 // in such low resource situations.
-void CMSCollector::preserve_mark_work(oop p, markOop m) {
+void CMSCollector::preserve_mark_work(oop p, markWord m) {
 _preserved_oop_stack.push(p);
 _preserved_mark_stack.push(m);
 assert(m == p->mark_raw(), "Mark word changed");
 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),
 "bijection");
 }
 // Single threaded
 void CMSCollector::preserve_mark_if_necessary(oop p) {
-markOop m = p->mark_raw();
+markWord m = p->mark_raw();
-if (m->must_be_preserved(p)) {
+if (m.must_be_preserved(p)) {
 preserve_mark_work(p, m);
 }
 }
 void CMSCollector::par_preserve_mark_if_necessary(oop p) {
-markOop m = p->mark_raw();
+markWord m = p->mark_raw();
-if (m->must_be_preserved(p)) {
+if (m.must_be_preserved(p)) {
 MutexLocker x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
 // Even though we read the mark word without holding
 // the lock, we are assured that it will not change
 // because we "own" this oop, so no other thread can
 // be trying to push it on the overflow list; see
 while (!_preserved_oop_stack.is_empty()) {
 oop p = _preserved_oop_stack.pop();
 assert(oopDesc::is_oop(p), "Should be an oop");
 assert(_span.contains(p), "oop should be in _span");
-assert(p->mark_raw() == markOopDesc::prototype(),
+assert(p->mark_raw() == markWord::prototype(),
 "Set when taken from overflow list");
-markOop m = _preserved_mark_stack.pop();
+markWord m = _preserved_mark_stack.pop();
 p->set_mark_raw(m);
 }
 assert(_preserved_mark_stack.is_empty() && _preserved_oop_stack.is_empty(),
 "stacks were cleared above");
 }

changeset 57777	90ead0febf56
parent 57637	c38cca5ffb66
child 57782	ca133d5ea78a