jdk-sandbox: comparison src/hotspot/share/jfr/recorder/storage/jfrStorage.cpp

equal deleted inserted replaced

-:2c3cc4b01880
+:c16ac7a2eba4
 #include "precompiled.hpp"
 #include "jfr/jfrEvents.hpp"
 #include "jfr/jni/jfrJavaSupport.hpp"
 #include "jfr/recorder/jfrRecorder.hpp"
+#include "jfr/recorder/checkpoint/jfrCheckpointManager.hpp"
 #include "jfr/recorder/repository/jfrChunkWriter.hpp"
 #include "jfr/recorder/service/jfrOptionSet.hpp"
 #include "jfr/recorder/service/jfrPostBox.hpp"
 #include "jfr/recorder/storage/jfrMemorySpace.inline.hpp"
 #include "jfr/recorder/storage/jfrStorage.hpp"
 if (unflushed_size == 0) {
 buffer->concurrent_reinitialization();
 assert(buffer->empty(), "invariant");
 return true;
 }
+if (buffer->excluded()) {
+const bool thread_is_excluded = thread->jfr_thread_local()->is_excluded();
+buffer->reinitialize(thread_is_excluded);
+assert(buffer->empty(), "invariant");
+if (!thread_is_excluded) {
+// state change from exclusion to inclusion requires a thread checkpoint
+JfrCheckpointManager::write_thread_checkpoint(thread);
+}
+return true;
+}
 BufferPtr const promotion_buffer = get_promotion_buffer(unflushed_size, _global_mspace, *this, promotion_retry, thread);
 if (promotion_buffer == NULL) {
 write_data_loss(buffer, thread);
 return false;
 }
 static void handle_registration_failure(BufferPtr buffer) {
 assert(buffer != NULL, "invariant");
 assert(buffer->retired(), "invariant");
 const size_t unflushed_size = buffer->unflushed_size();
-buffer->reinitialize();
+buffer->concurrent_reinitialization();
 log_registration_failure(unflushed_size);
 }
 static JfrAgeNode* get_free_age_node(JfrStorageAgeMspace* age_mspace, Thread* thread) {
 assert(JfrBuffer_lock->owned_by_self(), "invariant");
 static void assert_flush_large_precondition(ConstBufferPtr cur, const u1* const cur_pos, size_t used, size_t req, bool native, Thread* t) {
 assert(t != NULL, "invariant");
 assert(cur != NULL, "invariant");
 assert(cur->lease(), "invariant");
+assert(!cur->excluded(), "invariant");
 assert(cur_pos != NULL, "invariant");
 assert(native ? t->jfr_thread_local()->native_buffer() == cur : t->jfr_thread_local()->java_buffer() == cur, "invariant");
 assert(t->jfr_thread_local()->shelved_buffer() != NULL, "invariant");
 assert(req >= used, "invariant");
 assert(cur != t->jfr_thread_local()->shelved_buffer(), "invariant");
 // which is where the "used / uncommitted" data resides. It is therefore both
 // possible and valid to migrate data after the flush. This is however only
 // the case for stable thread local buffers; it is not the case for large buffers.
 if (!cur->empty()) {
 flush_regular_buffer(cur, t);
+if (cur->excluded()) {
+return cur;
+}
 }
 assert(t->jfr_thread_local()->shelved_buffer() == NULL, "invariant");
 if (cur->free_size() >= req) {
 // simplest case, no switching of buffers
 if (used > 0) {
 }
 typedef UnBufferedWriteToChunk<JfrBuffer> WriteOperation;
 typedef MutexedWriteOp<WriteOperation> MutexedWriteOperation;
 typedef ConcurrentWriteOp<WriteOperation> ConcurrentWriteOperation;
-typedef ConcurrentWriteOpExcludeRetired<WriteOperation> ThreadLocalConcurrentWriteOperation;
+typedef Retired<JfrBuffer, true> NonRetired;
+typedef Excluded<JfrBuffer, true> NonExcluded;
+typedef CompositeOperation<NonRetired, NonExcluded> BufferPredicate;
+typedef PredicatedMutexedWriteOp<WriteOperation, BufferPredicate> ThreadLocalMutexedWriteOperation;
+typedef PredicatedConcurrentWriteOp<WriteOperation, BufferPredicate> ThreadLocalConcurrentWriteOperation;
 size_t JfrStorage::write() {
-const size_t full_size_processed = write_full();
+const size_t full_elements = write_full();
 WriteOperation wo(_chunkwriter);
-ThreadLocalConcurrentWriteOperation tlwo(wo);
+NonRetired nr;
+NonExcluded ne;
+BufferPredicate bp(&nr, &ne);
+ThreadLocalConcurrentWriteOperation tlwo(wo, bp);
 process_full_list(tlwo, _thread_local_mspace);
 ConcurrentWriteOperation cwo(wo);
 process_free_list(cwo, _global_mspace);
-return full_size_processed + wo.processed();
+return full_elements + wo.elements();
 }
 size_t JfrStorage::write_at_safepoint() {
 assert(SafepointSynchronize::is_at_safepoint(), "invariant");
 WriteOperation wo(_chunkwriter);
 MutexedWriteOperation writer(wo); // mutexed write mode
-process_full_list(writer, _thread_local_mspace);
+NonRetired nr;
+NonExcluded ne;
+BufferPredicate bp(&nr, &ne);
+ThreadLocalMutexedWriteOperation tlmwo(wo, bp);
+process_full_list(tlmwo, _thread_local_mspace);
 assert(_transient_mspace->is_free_empty(), "invariant");
 process_full_list(writer, _transient_mspace);
 assert(_global_mspace->is_full_empty(), "invariant");
 process_free_list(writer, _global_mspace);
-return wo.processed();
+return wo.elements();
 }
 typedef DiscardOp<DefaultDiscarder<JfrStorage::Buffer> > DiscardOperation;
 typedef ReleaseOp<JfrStorageMspace> ReleaseOperation;
 typedef CompositeOperation<MutexedWriteOperation, ReleaseOperation> FullOperation;
 size_t JfrStorage::clear() {
-const size_t full_size_processed = clear_full();
+const size_t full_elements = clear_full();
 DiscardOperation discarder(concurrent); // concurrent discard mode
 process_full_list(discarder, _thread_local_mspace);
 assert(_transient_mspace->is_free_empty(), "invariant");
 process_full_list(discarder, _transient_mspace);
 assert(_global_mspace->is_full_empty(), "invariant");
 process_free_list(discarder, _global_mspace);
-return full_size_processed + discarder.processed();
+return full_elements + discarder.elements();
 }
 static void insert_free_age_nodes(JfrStorageAgeMspace* age_mspace, JfrAgeNode* head, JfrAgeNode* tail, size_t count) {
 if (tail != NULL) {
 assert(tail->next() == NULL, "invariant");
 WriteOperation wo(_chunkwriter);
 MutexedWriteOperation writer(wo); // a retired buffer implies mutexed access
 ReleaseOperation ro(_transient_mspace, thread);
 FullOperation cmd(&writer, &ro);
 const size_t count = process_full(cmd, control(), _age_mspace);
-log(count, writer.processed());
+if (0 == count) {
-return writer.processed();
+assert(0 == writer.elements(), "invariant");
+return 0;
+}
+const size_t size = writer.size();
+log(count, size);
+return count;
 }
 size_t JfrStorage::clear_full() {
 DiscardOperation discarder(mutexed); // a retired buffer implies mutexed access
 const size_t count = process_full(discarder, control(), _age_mspace);
-log(count, discarder.processed(), true);
+if (0 == count) {
-return discarder.processed();
+assert(0 == discarder.elements(), "invariant");
+return 0;
+}
+const size_t size = discarder.size();
+log(count, size, true);
+return count;
 }
 static void scavenge_log(size_t count, size_t amount, size_t current) {
 if (count > 0) {
 if (log_is_enabled(Debug, jfr, system)) {
 assert(t->empty(), "invariant");
 assert(!t->transient(), "invariant");
 assert(!t->lease(), "invariant");
 ++_count;
 _amount += t->total_size();
+if (t->excluded()) {
+t->clear_excluded();
+}
+assert(!t->excluded(), "invariant");
 t->clear_retired();
 t->release();
 _control.decrement_dead();
 mspace_release_full_critical(t, _mspace);
 }
 if (ctrl.dead_count() == 0) {
 return 0;
 }
 Scavenger<JfrThreadLocalMspace> scavenger(ctrl, _thread_local_mspace);
 process_full_list(scavenger, _thread_local_mspace);
-scavenge_log(scavenger.processed(), scavenger.amount(), ctrl.dead_count());
+const size_t count = scavenger.processed();
-return scavenger.processed();
+if (0 == count) {
-}
+assert(0 == scavenger.amount(), "invariant");
+return 0;
+}
+scavenge_log(count, scavenger.amount(), ctrl.dead_count());
+return count;
+}

changeset 58863	c16ac7a2eba4
parent 55053	d58e1a447d2b
child 58967	3c2e49d43ba3