362 process_free_list(discarder, _epoch_transition_mspace); |
362 process_free_list(discarder, _epoch_transition_mspace); |
363 synchronize_epoch(); |
363 synchronize_epoch(); |
364 return discarder.elements(); |
364 return discarder.elements(); |
365 } |
365 } |
366 |
366 |
367 // Optimization for write_types() and write_threads() is to write |
367 // Optimization for write_static_type_set() and write_threads() is to write |
368 // directly into the epoch transition mspace because we will immediately |
368 // directly into the epoch transition mspace because we will immediately |
369 // serialize and reset this mspace post-write. |
369 // serialize and reset this mspace post-write. |
370 static JfrBuffer* get_epoch_transition_buffer(JfrCheckpointMspace* mspace, Thread* t) { |
370 static JfrBuffer* get_epoch_transition_buffer(JfrCheckpointMspace* mspace, Thread* t) { |
371 assert(mspace != NULL, "invariant"); |
371 assert(mspace != NULL, "invariant"); |
372 JfrBuffer* const buffer = mspace->free_head(); |
372 JfrBuffer* const buffer = mspace->free_head(); |
375 buffer->set_lease(); |
375 buffer->set_lease(); |
376 DEBUG_ONLY(assert_free_lease(buffer);) |
376 DEBUG_ONLY(assert_free_lease(buffer);) |
377 return buffer; |
377 return buffer; |
378 } |
378 } |
379 |
379 |
380 size_t JfrCheckpointManager::write_types() { |
380 bool JfrCheckpointManager::is_static_type_set_required() { |
|
381 return JfrTypeManager::has_new_static_type(); |
|
382 } |
|
383 |
|
384 size_t JfrCheckpointManager::write_static_type_set() { |
381 Thread* const t = Thread::current(); |
385 Thread* const t = Thread::current(); |
382 ResourceMark rm(t); |
386 ResourceMark rm(t); |
383 HandleMark hm(t); |
387 HandleMark hm(t); |
384 JfrCheckpointWriter writer(t, get_epoch_transition_buffer(_epoch_transition_mspace, t), STATICS); |
388 JfrCheckpointWriter writer(t, get_epoch_transition_buffer(_epoch_transition_mspace, t), STATICS); |
385 JfrTypeManager::write_types(writer); |
389 JfrTypeManager::write_static_types(writer); |
386 return writer.used_size(); |
390 return writer.used_size(); |
387 } |
391 } |
388 |
392 |
389 size_t JfrCheckpointManager::write_threads() { |
393 size_t JfrCheckpointManager::write_threads() { |
390 Thread* const t = Thread::current(); |
394 Thread* const t = Thread::current(); |
392 HandleMark hm(t); |
396 HandleMark hm(t); |
393 JfrCheckpointWriter writer(t, get_epoch_transition_buffer(_epoch_transition_mspace, t), THREADS); |
397 JfrCheckpointWriter writer(t, get_epoch_transition_buffer(_epoch_transition_mspace, t), THREADS); |
394 JfrTypeManager::write_threads(writer); |
398 JfrTypeManager::write_threads(writer); |
395 return writer.used_size(); |
399 return writer.used_size(); |
396 } |
400 } |
397 size_t JfrCheckpointManager::write_constants() { |
401 |
398 write_types(); |
402 size_t JfrCheckpointManager::write_static_type_set_and_threads() { |
|
403 write_static_type_set(); |
399 write_threads(); |
404 write_threads(); |
400 return write_epoch_transition_mspace(); |
405 return write_epoch_transition_mspace(); |
|
406 } |
|
407 |
|
408 void JfrCheckpointManager::shift_epoch() { |
|
409 debug_only(const u1 current_epoch = JfrTraceIdEpoch::current();) |
|
410 JfrTraceIdEpoch::shift_epoch(); |
|
411 assert(current_epoch != JfrTraceIdEpoch::current(), "invariant"); |
|
412 } |
|
413 |
|
414 void JfrCheckpointManager::on_rotation() { |
|
415 assert(SafepointSynchronize::is_at_safepoint(), "invariant"); |
|
416 JfrTypeManager::on_rotation(); |
|
417 notify_threads(); |
|
418 shift_epoch(); |
|
419 } |
|
420 |
|
421 void JfrCheckpointManager::write_type_set() { |
|
422 JfrTypeManager::write_type_set(); |
|
423 write(); |
|
424 } |
|
425 |
|
426 void JfrCheckpointManager::write_type_set_for_unloaded_classes() { |
|
427 JfrTypeManager::write_type_set_for_unloaded_classes(); |
|
428 } |
|
429 |
|
430 bool JfrCheckpointManager::is_type_set_required() { |
|
431 return JfrTraceIdEpoch::has_changed_tag_state(); |
|
432 } |
|
433 |
|
434 size_t JfrCheckpointManager::flush_type_set() { |
|
435 const size_t elements = JfrTypeManager::flush_type_set(); |
|
436 flush(); |
|
437 return elements; |
|
438 } |
|
439 |
|
440 void JfrCheckpointManager::flush_static_type_set() { |
|
441 flush(); |
|
442 } |
|
443 |
|
444 void JfrCheckpointManager::create_thread_blob(Thread* t) { |
|
445 JfrTypeManager::create_thread_blob(t); |
|
446 } |
|
447 |
|
448 void JfrCheckpointManager::write_thread_checkpoint(Thread* t) { |
|
449 JfrTypeManager::write_thread_checkpoint(t); |
401 } |
450 } |
402 |
451 |
403 class JfrNotifyClosure : public ThreadClosure { |
452 class JfrNotifyClosure : public ThreadClosure { |
404 public: |
453 public: |
405 void do_thread(Thread* t) { |
454 void do_thread(Thread* t) { |
416 JfrJavaThreadIterator iter; |
465 JfrJavaThreadIterator iter; |
417 while (iter.has_next()) { |
466 while (iter.has_next()) { |
418 tc.do_thread(iter.next()); |
467 tc.do_thread(iter.next()); |
419 } |
468 } |
420 } |
469 } |
421 |
|
422 void JfrCheckpointManager::on_rotation() { |
|
423 assert(SafepointSynchronize::is_at_safepoint(), "invariant"); |
|
424 JfrTypeManager::on_rotation(); |
|
425 notify_threads(); |
|
426 shift_epoch(); |
|
427 } |
|
428 |
|
429 void JfrCheckpointManager::write_type_set() { |
|
430 JfrTypeManager::write_type_set(); |
|
431 write(); |
|
432 } |
|
433 |
|
434 void JfrCheckpointManager::write_type_set_for_unloaded_classes() { |
|
435 JfrTypeManager::write_type_set_for_unloaded_classes(); |
|
436 } |
|
437 |
|
438 bool JfrCheckpointManager::is_type_set_required() { |
|
439 return JfrTraceIdEpoch::has_changed_tag_state(); |
|
440 } |
|
441 |
|
442 bool JfrCheckpointManager::is_constant_set_required() { |
|
443 return JfrTypeManager::is_new_constant_registered(); |
|
444 } |
|
445 |
|
446 size_t JfrCheckpointManager::flush_type_set() { |
|
447 const size_t elements = JfrTypeManager::flush_type_set(); |
|
448 flush(); |
|
449 return elements; |
|
450 } |
|
451 |
|
452 void JfrCheckpointManager::flush_constant_set() { |
|
453 flush(); |
|
454 } |
|
455 |
|
456 void JfrCheckpointManager::create_thread_blob(Thread* t) { |
|
457 JfrTypeManager::create_thread_blob(t); |
|
458 } |
|
459 |
|
460 void JfrCheckpointManager::write_thread_checkpoint(Thread* t) { |
|
461 JfrTypeManager::write_thread_checkpoint(t); |
|
462 } |
|
463 |
|
464 void JfrCheckpointManager::shift_epoch() { |
|
465 debug_only(const u1 current_epoch = JfrTraceIdEpoch::current();) |
|
466 JfrTraceIdEpoch::shift_epoch(); |
|
467 assert(current_epoch != JfrTraceIdEpoch::current(), "invariant"); |
|
468 } |
|