Mercurial > hg > truffle

comparison src/share/vm/memory/referenceProcessor.cpp @ 14309:63a4eb8bcd23

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8025856: Fix typos in the GC code Summary: Fix about 440 typos in comments in the VM code Reviewed-by: mgerdin, tschatzl, coleenp, kmo, jcoomes
author jwilhelm
date Thu, 23 Jan 2014 14:47:23 +0100
parents fbc1677398c0
children 2cff20331ca2
comparison
equal deleted inserted replaced
14308:870aedf4ba4f 14309:63a4eb8bcd23
43 void referenceProcessor_init() { 43 void referenceProcessor_init() {
44 ReferenceProcessor::init_statics(); 44 ReferenceProcessor::init_statics();
45 } 45 }
46 46
47 void ReferenceProcessor::init_statics() { 47 void ReferenceProcessor::init_statics() {
48 // We need a monotonically non-deccreasing time in ms but 48 // We need a monotonically non-decreasing time in ms but
49 // os::javaTimeMillis() does not guarantee monotonicity. 49 // os::javaTimeMillis() does not guarantee monotonicity.
50 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC; 50 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
51 51
52 // Initialize the soft ref timestamp clock. 52 // Initialize the soft ref timestamp clock.
53 _soft_ref_timestamp_clock = now; 53 _soft_ref_timestamp_clock = now;
150 150
151 void ReferenceProcessor::update_soft_ref_master_clock() { 151 void ReferenceProcessor::update_soft_ref_master_clock() {
152 // Update (advance) the soft ref master clock field. This must be done 152 // Update (advance) the soft ref master clock field. This must be done
153 // after processing the soft ref list. 153 // after processing the soft ref list.
154 154
155 // We need a monotonically non-deccreasing time in ms but 155 // We need a monotonically non-decreasing time in ms but
156 // os::javaTimeMillis() does not guarantee monotonicity. 156 // os::javaTimeMillis() does not guarantee monotonicity.
157 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC; 157 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
158 jlong soft_ref_clock = java_lang_ref_SoftReference::clock(); 158 jlong soft_ref_clock = java_lang_ref_SoftReference::clock();
159 assert(soft_ref_clock == _soft_ref_timestamp_clock, "soft ref clocks out of sync"); 159 assert(soft_ref_clock == _soft_ref_timestamp_clock, "soft ref clocks out of sync");
160 160
166 ) 166 )
167 // The values of now and _soft_ref_timestamp_clock are set using 167 // The values of now and _soft_ref_timestamp_clock are set using
168 // javaTimeNanos(), which is guaranteed to be monotonically 168 // javaTimeNanos(), which is guaranteed to be monotonically
169 // non-decreasing provided the underlying platform provides such 169 // non-decreasing provided the underlying platform provides such
170 // a time source (and it is bug free). 170 // a time source (and it is bug free).
171 // In product mode, however, protect ourselves from non-monotonicty. 171 // In product mode, however, protect ourselves from non-monotonicity.
172 if (now > _soft_ref_timestamp_clock) { 172 if (now > _soft_ref_timestamp_clock) {
173 _soft_ref_timestamp_clock = now; 173 _soft_ref_timestamp_clock = now;
174 java_lang_ref_SoftReference::set_clock(now); 174 java_lang_ref_SoftReference::set_clock(now);
175 } 175 }
176 // Else leave clock stalled at its old value until time progresses 176 // Else leave clock stalled at its old value until time progresses
347 INTPTR_FORMAT, (address)refs_list.head()); 347 INTPTR_FORMAT, (address)refs_list.head());
348 } 348 }
349 349
350 oop obj = NULL; 350 oop obj = NULL;
351 oop next_d = refs_list.head(); 351 oop next_d = refs_list.head();
352 if (pending_list_uses_discovered_field()) { // New behaviour 352 if (pending_list_uses_discovered_field()) { // New behavior
353 // Walk down the list, self-looping the next field 353 // Walk down the list, self-looping the next field
354 // so that the References are not considered active. 354 // so that the References are not considered active.
355 while (obj != next_d) { 355 while (obj != next_d) {
356 obj = next_d; 356 obj = next_d;
357 assert(obj->is_instanceRef(), "should be reference object"); 357 assert(obj->is_instanceRef(), "should be reference object");
364 "Reference not active; should not be discovered"); 364 "Reference not active; should not be discovered");
365 // Self-loop next, so as to make Ref not active. 365 // Self-loop next, so as to make Ref not active.
366 // Post-barrier not needed when looping to self. 366 // Post-barrier not needed when looping to self.
367 java_lang_ref_Reference::set_next_raw(obj, obj); 367 java_lang_ref_Reference::set_next_raw(obj, obj);
368 if (next_d == obj) { // obj is last 368 if (next_d == obj) { // obj is last
369 // Swap refs_list into pendling_list_addr and 369 // Swap refs_list into pending_list_addr and
370 // set obj's discovered to what we read from pending_list_addr. 370 // set obj's discovered to what we read from pending_list_addr.
371 oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr); 371 oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
372 // Need post-barrier on pending_list_addr above; 372 // Need post-barrier on pending_list_addr above;
373 // see special post-barrier code at the end of 373 // see special post-barrier code at the end of
374 // enqueue_discovered_reflists() further below. 374 // enqueue_discovered_reflists() further below.
375 java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL 375 java_lang_ref_Reference::set_discovered_raw(obj, old); // old may be NULL
376 oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old); 376 oopDesc::bs()->write_ref_field(java_lang_ref_Reference::discovered_addr(obj), old);
377 } 377 }
378 } 378 }
379 } else { // Old behaviour 379 } else { // Old behavior
380 // Walk down the list, copying the discovered field into 380 // Walk down the list, copying the discovered field into
381 // the next field and clearing the discovered field. 381 // the next field and clearing the discovered field.
382 while (obj != next_d) { 382 while (obj != next_d) {
383 obj = next_d; 383 obj = next_d;
384 assert(obj->is_instanceRef(), "should be reference object"); 384 assert(obj->is_instanceRef(), "should be reference object");
388 (void *)obj, (void *)next_d); 388 (void *)obj, (void *)next_d);
389 } 389 }
390 assert(java_lang_ref_Reference::next(obj) == NULL, 390 assert(java_lang_ref_Reference::next(obj) == NULL,
391 "The reference should not be enqueued"); 391 "The reference should not be enqueued");
392 if (next_d == obj) { // obj is last 392 if (next_d == obj) { // obj is last
393 // Swap refs_list into pendling_list_addr and 393 // Swap refs_list into pending_list_addr and
394 // set obj's next to what we read from pending_list_addr. 394 // set obj's next to what we read from pending_list_addr.
395 oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr); 395 oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
396 // Need oop_check on pending_list_addr above; 396 // Need oop_check on pending_list_addr above;
397 // see special oop-check code at the end of 397 // see special oop-check code at the end of
398 // enqueue_discovered_reflists() further below. 398 // enqueue_discovered_reflists() further below.
1339 1339
1340 // Walk the given discovered ref list, and remove all reference objects 1340 // Walk the given discovered ref list, and remove all reference objects
1341 // whose referents are still alive, whose referents are NULL or which 1341 // whose referents are still alive, whose referents are NULL or which
1342 // are not active (have a non-NULL next field). NOTE: When we are 1342 // are not active (have a non-NULL next field). NOTE: When we are
1343 // thus precleaning the ref lists (which happens single-threaded today), 1343 // thus precleaning the ref lists (which happens single-threaded today),
1344 // we do not disable refs discovery to honour the correct semantics of 1344 // we do not disable refs discovery to honor the correct semantics of
1345 // java.lang.Reference. As a result, we need to be careful below 1345 // java.lang.Reference. As a result, we need to be careful below
1346 // that ref removal steps interleave safely with ref discovery steps 1346 // that ref removal steps interleave safely with ref discovery steps
1347 // (in this thread). 1347 // (in this thread).
1348 void 1348 void
1349 ReferenceProcessor::preclean_discovered_reflist(DiscoveredList& refs_list, 1349 ReferenceProcessor::preclean_discovered_reflist(DiscoveredList& refs_list,