jdk-sandbox: comparison src/hotspot/share/jfr/recorder/service/jfrRecorderService.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 *
 */
 #include "precompiled.hpp"
 #include "jfr/jni/jfrJavaSupport.hpp"
+#include "jfr/leakprofiler/leakProfiler.hpp"
 #include "jfr/leakprofiler/checkpoint/objectSampleCheckpoint.hpp"
+#include "jfr/leakprofiler/sampling/objectSampler.hpp"
 #include "jfr/recorder/jfrRecorder.hpp"
 #include "jfr/recorder/checkpoint/jfrCheckpointManager.hpp"
 #include "jfr/recorder/checkpoint/jfrMetadataEvent.hpp"
 #include "jfr/recorder/repository/jfrChunkRotation.hpp"
 #include "jfr/recorder/repository/jfrChunkWriter.hpp"
 }
 bool not_acquired() const { return !_acquired; }
 };
 static int64_t write_checkpoint_event_prologue(JfrChunkWriter& cw, u8 type_id) {
-const int64_t prev_cp_offset = cw.previous_checkpoint_offset();
+const int64_t last_cp_offset = cw.last_checkpoint_offset();
-const int64_t prev_cp_relative_offset = 0 == prev_cp_offset ? 0 : prev_cp_offset - cw.current_offset();
+const int64_t delta_to_last_checkpoint = 0 == last_cp_offset ? 0 : last_cp_offset - cw.current_offset();
 cw.reserve(sizeof(u4));
 cw.write<u8>(EVENT_CHECKPOINT);
 cw.write(JfrTicks::now());
-cw.write((int64_t)0);
+cw.write((int64_t)0); // duration
-cw.write(prev_cp_relative_offset); // write previous checkpoint offset delta
+cw.write(delta_to_last_checkpoint);
 cw.write<bool>(false); // flushpoint
 cw.write((u4)1); // nof types in this checkpoint
 cw.write(type_id);
 const int64_t number_of_elements_offset = cw.current_offset();
 cw.reserve(sizeof(u4));
 assert(number_of_elements > 0, "invariant");
 assert(_cw.current_offset() > num_elements_offset, "invariant");
 _cw.write_padded_at_offset<u4>(number_of_elements, num_elements_offset);
 _cw.write_padded_at_offset<u4>((u4)_cw.current_offset() - current_cp_offset, current_cp_offset);
 // update writer with last checkpoint position
-_cw.set_previous_checkpoint_offset(current_cp_offset);
+_cw.set_last_checkpoint_offset(current_cp_offset);
 return true;
 }
 };
 template <typename Instance, size_t(Instance::*func)()>
 static bool vm_error = false;
 if (msgs & MSGBIT(MSG_VM_ERROR)) {
 vm_error = true;
 prepare_for_vm_error_rotation();
 }
+if (!_storage.control().to_disk()) {
+in_memory_rotation();
+} else if (vm_error) {
+vm_error_rotation();
+} else {
+chunk_rotation();
+}
 if (msgs & (MSGBIT(MSG_STOP))) {
 stop();
 }
-// action determined by chunkwriter state
-if (!_chunkwriter.is_valid()) {
-in_memory_rotation();
-return;
-}
-if (vm_error) {
-vm_error_rotation();
-return;
-}
-chunk_rotation();
 }
 void JfrRecorderService::prepare_for_vm_error_rotation() {
 if (!_chunkwriter.is_valid()) {
 open_new_chunk(true);
 }
 _checkpoint_manager.register_service_thread(Thread::current());
+JfrMetadataEvent::lock();
 }
 void JfrRecorderService::open_new_chunk(bool vm_error) {
 assert(!_chunkwriter.is_valid(), "invariant");
 assert(!JfrStream_lock->owned_by_self(), "invariant");
 static void write_stacktrace_checkpoint(JfrStackTraceRepository& stack_trace_repo, JfrChunkWriter& chunkwriter, bool clear) {
 WriteStackTraceRepository write_stacktrace_repo(stack_trace_repo, chunkwriter, clear);
 WriteStackTraceCheckpoint write_stack_trace_checkpoint(chunkwriter, TYPE_STACKTRACE, write_stacktrace_repo);
 write_stack_trace_checkpoint.process();
 }
 static void write_stringpool_checkpoint(JfrStringPool& string_pool, JfrChunkWriter& chunkwriter) {
 WriteStringPool write_string_pool(string_pool);
 WriteStringPoolCheckpoint write_string_pool_checkpoint(chunkwriter, TYPE_STRING, write_string_pool);
 write_string_pool_checkpoint.process();
 }
 //  lock stream lock ->
 //    write non-safepoint dependent types ->
 //      write checkpoint epoch transition list->
 //        write stack trace checkpoint ->
 //          write string pool checkpoint ->
-//            write storage ->
+//            write object sample stacktraces ->
-//              release stream lock
+//              write storage ->
+//                release stream lock
 //
 void JfrRecorderService::pre_safepoint_write() {
 MutexLocker stream_lock(JfrStream_lock, Mutex::_no_safepoint_check_flag);
 assert(_chunkwriter.is_valid(), "invariant");
 _checkpoint_manager.write_types();
 _checkpoint_manager.write_epoch_transition_mspace();
 write_stacktrace_checkpoint(_stack_trace_repository, _chunkwriter, false);
 write_stringpool_checkpoint(_string_pool, _chunkwriter);
+if (LeakProfiler::is_running()) {
+// Exclusive access to the object sampler instance.
+// The sampler is released (unlocked) later in post_safepoint_write.
+ObjectSampleCheckpoint::on_rotation(ObjectSampler::acquire(), _stack_trace_repository);
+}
 _storage.write();
 }
 void JfrRecorderService::invoke_safepoint_write() {
 JfrVMOperation<JfrRecorderService, &JfrRecorderService::safepoint_write> safepoint_task(*this);
 VMThread::execute(&safepoint_task);
 }
-static void write_object_sample_stacktrace(JfrStackTraceRepository& stack_trace_repository) {
-WriteObjectSampleStacktrace object_sample_stacktrace(stack_trace_repository);
-object_sample_stacktrace.process();
-}
 //
 // safepoint write sequence
 //
 //   lock stream lock ->
-//     write object sample stacktraces ->
 //       write stacktrace repository ->
 //         write string pool ->
 //           write safepoint dependent types ->
 //             write storage ->
 //                 shift_epoch ->
 //                       release stream lock
 //
 void JfrRecorderService::safepoint_write() {
 assert(SafepointSynchronize::is_at_safepoint(), "invariant");
 MutexLocker stream_lock(JfrStream_lock, Mutex::_no_safepoint_check_flag);
-write_object_sample_stacktrace(_stack_trace_repository);
 write_stacktrace_checkpoint(_stack_trace_repository, _chunkwriter, true);
 write_stringpool_checkpoint_safepoint(_string_pool, _chunkwriter);
 _checkpoint_manager.write_safepoint_types();
 _storage.write_at_safepoint();
 _checkpoint_manager.shift_epoch();
 }
 //
 // post-safepoint write sequence
 //
-//  lock stream lock ->
+//   write type set ->
-//    write type set ->
+//     release object sampler ->
-//      write checkpoints ->
+//       lock stream lock ->
-//        write metadata event ->
+//         write checkpoints ->
-//          write chunk header ->
+//           write metadata event ->
-//            close chunk fd ->
+//             write chunk header ->
-//              release stream lock
+//               close chunk fd ->
+//                 release stream lock
 //
 void JfrRecorderService::post_safepoint_write() {
 assert(_chunkwriter.is_valid(), "invariant");
 // During the safepoint tasks just completed, the system transitioned to a new epoch.
 // Type tagging is epoch relative which entails we are able to write out the
 // already tagged artifacts for the previous epoch. We can accomplish this concurrently
 // with threads now tagging artifacts in relation to the new, now updated, epoch and remain outside of a safepoint.
 _checkpoint_manager.write_type_set();
+if (LeakProfiler::is_running()) {
+// The object sampler instance was exclusively acquired and locked in pre_safepoint_write.
+// Note: There is a dependency on write_type_set() above, ensure the release is subsequent.
+ObjectSampler::release();
+}
 MutexLocker stream_lock(JfrStream_lock, Mutex::_no_safepoint_check_flag);
 // serialize any outstanding checkpoint memory
 _checkpoint_manager.write();
 // serialize the metadata descriptor event and close out the chunk
 _repository.close_chunk(write_metadata_event(_chunkwriter));
 }
 void JfrRecorderService::finalize_current_chunk_on_vm_error() {
 assert(_chunkwriter.is_valid(), "invariant");
 pre_safepoint_write();
-JfrMetadataEvent::lock();
 // Do not attempt safepoint dependent operations during emergency dump.
 // Optimistically write tagged artifacts.
 _checkpoint_manager.shift_epoch();
-_checkpoint_manager.write_type_set();
 // update time
 _chunkwriter.time_stamp_chunk_now();
 post_safepoint_write();
 assert(!_chunkwriter.is_valid(), "invariant");
 }

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54623	1126f0607c70
child 58679	9c3209ff7550