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

equal deleted inserted replaced

-:a7d850b47b19
+:6a21dba79b81
 #include "runtime/safepoint.hpp"
 #include "runtime/thread.inline.hpp"
 #include "runtime/vmOperations.hpp"
 #include "runtime/vmThread.hpp"
-// set data iff *dest == NULL
-static bool try_set(void* const data, void** dest, bool clear) {
-assert(data != NULL, "invariant");
-const void* const current = *dest;
-if (current != NULL) {
-if (current != data) {
-// already set
-return false;
-}
-assert(current == data, "invariant");
-if (!clear) {
-// recursion disallowed
-return false;
-}
-}
-return Atomic::cmpxchg(clear ? NULL : data, dest, current) == current;
-}
-static void* rotation_thread = NULL;
-static const int rotation_try_limit = 1000;
-static const int rotation_retry_sleep_millis = 10;
 // incremented on each flushpoint
 static u8 flushpoint_id = 0;
-class RotationLock : public StackObj {
-private:
-Thread* const _thread;
-bool _acquired;
-void log(bool recursion) {
-assert(!_acquired, "invariant");
-const char* error_msg = NULL;
-if (recursion) {
-error_msg = "Unable to issue rotation due to recursive calls.";
-}
-else {
-error_msg = "Unable to issue rotation due to wait timeout.";
-}
-log_info(jfr)( // For user, should not be "jfr, system"
-"%s", error_msg);
-}
-public:
-RotationLock(Thread* thread) : _thread(thread), _acquired(false) {
-assert(_thread != NULL, "invariant");
-if (_thread == rotation_thread) {
-// recursion not supported
-log(true);
-return;
-}
-// limited to not spin indefinitely
-for (int i = 0; i < rotation_try_limit; ++i) {
-if (try_set(_thread, &rotation_thread, false)) {
-_acquired = true;
-assert(_thread == rotation_thread, "invariant");
-return;
-}
-if (_thread->is_Java_thread()) {
-// in order to allow the system to move to a safepoint
-MutexLocker msg_lock(JfrMsg_lock);
-JfrMsg_lock->wait(rotation_retry_sleep_millis);
-}
-else {
-os::naked_short_sleep(rotation_retry_sleep_millis);
-}
-}
-log(false);
-}
-~RotationLock() {
-assert(_thread != NULL, "invariant");
-if (_acquired) {
-assert(_thread == rotation_thread, "invariant");
-while (!try_set(_thread, &rotation_thread, true));
-}
-}
-bool not_acquired() const { return !_acquired; }
-};
 template <typename E, typename Instance, size_t(Instance::*func)()>
 class Content {
 private:
 Instance& _instance;
 bool JfrRecorderService::is_recording() {
 return recording;
 }
 void JfrRecorderService::start() {
-RotationLock rl(Thread::current());
+MutexLocker lock(JfrStream_lock);
-if (rl.not_acquired()) {
-return;
-}
 log_debug(jfr, system)("Request to START recording");
 assert(!is_recording(), "invariant");
 clear();
 set_recording_state(true);
 assert(is_recording(), "invariant");
 invoke_safepoint_clear();
 post_safepoint_clear();
 }
 void JfrRecorderService::pre_safepoint_clear() {
-_stack_trace_repository.clear();
 _string_pool.clear();
 _storage.clear();
+_stack_trace_repository.clear();
 }
 void JfrRecorderService::invoke_safepoint_clear() {
 JfrVMOperation<JfrRecorderService, &JfrRecorderService::safepoint_clear> safepoint_task(*this);
 VMThread::execute(&safepoint_task);
 }
 void JfrRecorderService::safepoint_clear() {
 assert(SafepointSynchronize::is_at_safepoint(), "invariant");
-_stack_trace_repository.clear();
 _string_pool.clear();
 _storage.clear();
 _checkpoint_manager.shift_epoch();
 _chunkwriter.set_time_stamp();
+_stack_trace_repository.clear();
 }
 void JfrRecorderService::post_safepoint_clear() {
 _checkpoint_manager.clear();
 }
 set_recording_state(false);
 assert(!JfrRecorderService::is_recording(), "invariant");
 }
 void JfrRecorderService::prepare_for_vm_error_rotation() {
+assert(JfrStream_lock->owned_by_self(), "invariant");
 if (!_chunkwriter.is_valid()) {
 open_new_chunk(true);
 }
 _checkpoint_manager.register_service_thread(Thread::current());
 }
 void JfrRecorderService::vm_error_rotation() {
+assert(JfrStream_lock->owned_by_self(), "invariant");
 if (_chunkwriter.is_valid()) {
 Thread* const t = Thread::current();
 _storage.flush_regular_buffer(t->jfr_thread_local()->native_buffer(), t);
-invoke_flush(t);
+invoke_flush();
 _chunkwriter.set_time_stamp();
 _repository.close_chunk();
 assert(!_chunkwriter.is_valid(), "invariant");
 _repository.on_vm_error();
 }
 }
 void JfrRecorderService::rotate(int msgs) {
-RotationLock rl(Thread::current());
+assert(!JfrStream_lock->owned_by_self(), "invariant");
-if (rl.not_acquired()) {
+MutexLocker lock(JfrStream_lock);
-return;
-}
 static bool vm_error = false;
 if (msgs & MSGBIT(MSG_VM_ERROR)) {
 vm_error = true;
 prepare_for_vm_error_rotation();
 }
 stop();
 }
 }
 void JfrRecorderService::in_memory_rotation() {
+assert(JfrStream_lock->owned_by_self(), "invariant");
 // currently running an in-memory recording
 assert(!_storage.control().to_disk(), "invariant");
 open_new_chunk();
 if (_chunkwriter.is_valid()) {
 // dump all in-memory buffer data to the newly created chunk
 write_storage(_storage, _chunkwriter);
 }
 }
 void JfrRecorderService::chunk_rotation() {
+assert(JfrStream_lock->owned_by_self(), "invariant");
 finalize_current_chunk();
 open_new_chunk();
 }
 void JfrRecorderService::finalize_current_chunk() {
 post_safepoint_write();
 }
 void JfrRecorderService::pre_safepoint_write() {
 assert(_chunkwriter.is_valid(), "invariant");
-if (_stack_trace_repository.is_modified()) {
-write_stacktrace(_stack_trace_repository, _chunkwriter, false);
-}
-if (_string_pool.is_modified()) {
-write_stringpool(_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);
 }
+if (_string_pool.is_modified()) {
+write_stringpool(_string_pool, _chunkwriter);
+}
 write_storage(_storage, _chunkwriter);
+if (_stack_trace_repository.is_modified()) {
+write_stacktrace(_stack_trace_repository, _chunkwriter, false);
+}
 }
 void JfrRecorderService::invoke_safepoint_write() {
 JfrVMOperation<JfrRecorderService, &JfrRecorderService::safepoint_write> safepoint_task(*this);
 VMThread::execute(&safepoint_task);
 }
 void JfrRecorderService::safepoint_write() {
 assert(SafepointSynchronize::is_at_safepoint(), "invariant");
-write_stacktrace(_stack_trace_repository, _chunkwriter, true);
 if (_string_pool.is_modified()) {
 write_stringpool_safepoint(_string_pool, _chunkwriter);
 }
+_checkpoint_manager.on_rotation();
 _storage.write_at_safepoint();
-_checkpoint_manager.on_rotation();
+_checkpoint_manager.shift_epoch();
 _chunkwriter.set_time_stamp();
+write_stacktrace(_stack_trace_repository, _chunkwriter, true);
 }
 void JfrRecorderService::post_safepoint_write() {
 assert(_chunkwriter.is_valid(), "invariant");
 // During the safepoint tasks just completed, the system transitioned to a new epoch.
 reset_buffer(buffer, t);
 }
 }
 size_t JfrRecorderService::flush() {
+assert(JfrStream_lock->owned_by_self(), "invariant");
 size_t total_elements = flush_metadata(_chunkwriter);
 const size_t storage_elements = flush_storage(_storage, _chunkwriter);
 if (0 == storage_elements) {
 return total_elements;
 }
 total_elements += storage_elements;
+if (_string_pool.is_modified()) {
+total_elements += flush_stringpool(_string_pool, _chunkwriter);
+}
 if (_stack_trace_repository.is_modified()) {
 total_elements += flush_stacktrace(_stack_trace_repository, _chunkwriter);
-}
-if (_string_pool.is_modified()) {
-total_elements += flush_stringpool(_string_pool, _chunkwriter);
 }
 if (_checkpoint_manager.is_type_set_required()) {
 total_elements += flush_typeset(_checkpoint_manager, _chunkwriter);
 } else if (_checkpoint_manager.is_static_type_set_required()) {
 // don't tally this, it is only in order to flush the waiting constants
 }
 typedef Content<EventFlush, JfrRecorderService, &JfrRecorderService::flush> FlushFunctor;
 typedef WriteContent<FlushFunctor> Flush;
-void JfrRecorderService::invoke_flush(Thread* t) {
+void JfrRecorderService::invoke_flush() {
-assert(t != NULL, "invariant");
+assert(JfrStream_lock->owned_by_self(), "invariant");
 assert(_chunkwriter.is_valid(), "invariant");
+Thread* const t = Thread::current();
 ResourceMark rm(t);
 HandleMark hm(t);
 ++flushpoint_id;
 reset_thread_local_buffer(t);
 FlushFunctor flushpoint(*this);
 write_thread_local_buffer(_chunkwriter, t);
 _repository.flush_chunk();
 }
 void JfrRecorderService::flushpoint() {
-Thread* const t = Thread::current();
+MutexLocker lock(JfrStream_lock);
-RotationLock rl(t);
+invoke_flush();
-if (rl.not_acquired() || !_chunkwriter.is_valid()) {
-return;
-}
-invoke_flush(t);
 }
 void JfrRecorderService::process_full_buffers() {
 if (_chunkwriter.is_valid()) {
 _storage.write_full();

branch	JEP-349-branch
changeset 58823	6a21dba79b81
parent 58578	7b89c53db169