[EventPipe] Restrict SequencePoint sequence numbers

Previously, EventPipeThread's lifetimes were inherently tied to the
lifetime of all SequencePoints that track the thread's last sequence
number. In adding ThreadSessionState cleanup, SequencePoints forced
deletions to be deferred.

SequencePoints do not need to extend EventPipeThreads lifetimes, as they
only need to track the last known sequence number of that thread by the
time the SequencePoint is written. To disassociate the two lifetimes and
allow ThreadSessionStates to be cleaned up as soon as possible:

1) Update SequencePoints in tandem with event processing
Delaying SequencePoint updating until the SequencePoint is written
requires the buffer_manager's thread_session_state_list to not trim any
ThreadSessionStates. Updating the mapped ThreadId:sequence_number in
tandem allows the thread_session_state_list to be trimmed immediately.

2) Restrict ThreadId:sequence_number tracking
Previously, SequencePoints tracked all threads and their last known
sequence number regardless of whether there have been new events, and
mandated reactionary removal when the ThreadSessionState was
being deleted. Instead, by tightening the conditions for when a
SequencePoint should track a particulr thread, they should never need to
track threads unnecessarily. The conditions for when a SequencePoint
needs to track a thread are:
  a) EventPipeThread is registered during SequencePoint init
  or
  b) EventPipeThread is unregistered during SP init and there are new
  event write attempts since the last SP

Author: mdh1418

src/native/eventpipe/ep-buffer-manager.c

@@ -399,6 +399,10 @@ buffer_manager_init_sequence_point_thread_list (
 	ep_buffer_manager_requires_lock_held (buffer_manager);
 
 	DN_LIST_FOREACH_BEGIN (EventPipeThreadSessionState *, thread_session_state, buffer_manager->thread_session_state_list) {
+		EventPipeThreadSequencePointTrackState prev_track_state = ep_thread_session_state_get_track_state (thread_session_state);
+		if (prev_track_state == EP_SEQUENCE_POINT_THREAD_ID_RETIRED)
+			continue;
+
 		// The sequence number captured here is not guaranteed to be the most recent sequence number, nor
 		// is it guaranteed to match the number of events we would observe in the thread's write buffer
 		// memory. This is only used as a lower bound on the number of events the thread has attempted to
@@ -408,6 +412,22 @@ buffer_manager_init_sequence_point_thread_list (
 		// event is one less. Sequence numbers are allowed to overflow, so going backwards is allowed to
 		// underflow.
 		uint32_t sequence_number = ep_thread_session_state_get_volatile_sequence_number (thread_session_state) - 1;
+		if (ep_rt_volatile_load_uint32_t_without_barrier (ep_thread_get_unregistered_ref (ep_thread_session_state_get_thread (thread_session_state))) > 0) {
+			// This sequence point will be the last one that embeds this thread's ID as there will be no more
+			// writes by this thread and thus all its events are prior to this sequence point.
+			// Future sequence points do not need to track this thread's ID
+			ep_thread_session_state_set_track_state (thread_session_state, EP_SEQUENCE_POINT_THREAD_ID_RETIRED);
+
+			if ((ep_thread_session_state_get_last_read_sequence_number (thread_session_state) == sequence_number) &&
+				(prev_track_state == EP_SEQUENCE_POINT_THREAD_ID_TRACKED)) {
+				// The thread will not emit new events, and the last sequence point has already tracked
+				// the last sequence number emitted by this thread,
+				// so we don't need to track it anymore
+				continue;
+			}
+		} else if (prev_track_state == EP_SEQUENCE_POINT_THREAD_ID_UNTRACKED) {
+			ep_thread_session_state_set_track_state (thread_session_state, EP_SEQUENCE_POINT_THREAD_ID_TRACKED);
+		}
 
 		dn_umap_ptr_uint32_insert (ep_sequence_point_get_thread_sequence_numbers (sequence_point), thread_session_state, sequence_number);
 		ep_thread_addref (ep_thread_holder_get_thread (ep_thread_session_state_get_thread_holder_ref (thread_session_state)));
@@ -1188,6 +1208,12 @@ ep_buffer_manager_write_all_buffers_to_file_v4 (
 			}
 
 			ep_thread_session_state_set_last_read_sequence_number (current_thread_session_state, sequence_number);
+			if (sequence_point != NULL) {
+				dn_umap_it_t found = dn_umap_ptr_uint32_find (ep_sequence_point_get_thread_sequence_numbers (sequence_point), current_thread_session_state);
+				EP_ASSERT (!dn_umap_it_end (found));
+				dn_umap_ptr_uint32_insert_or_assign (ep_sequence_point_get_thread_sequence_numbers (sequence_point), current_thread_session_state, sequence_number);
+			}
+
 			// Have we written events in any sequence point?
 			*events_written = events_written_for_thread || *events_written;
 		}
@@ -1210,6 +1236,7 @@ ep_buffer_manager_write_all_buffers_to_file_v4 (
 				dn_umap_it_t found = dn_umap_ptr_uint32_find (ep_sequence_point_get_thread_sequence_numbers (sequence_point), session_state);
 				uint32_t thread_sequence_number = !dn_umap_it_end (found) ? dn_umap_it_value_uint32_t (found) : 0;
 				uint32_t last_read_sequence_number = ep_thread_session_state_get_last_read_sequence_number (session_state);
+				EP_ASSERT (thread_sequence_number == 0 || thread_sequence_number == last_read_sequence_number);
 				// Sequence numbers can overflow so we can't use a direct last_read > sequence_number comparison
 				// If a thread is able to drop more than 0x80000000 events in between sequence points then we will
 				// miscategorize it, but that seems unlikely.
@@ -1237,6 +1264,7 @@ ep_buffer_manager_write_all_buffers_to_file_v4 (
 					buffer_manager_remove_and_delete_thread_session_state (buffer_manager, thread_session_state);
 			} DN_VECTOR_PTR_FOREACH_END;
 			buffer_manager_dequeue_sequence_point (buffer_manager);
+			sequence_point = NULL;
 		EP_SPIN_LOCK_EXIT (&buffer_manager->rt_lock, section3)
 	}
 

src/native/eventpipe/ep-thread.c

@@ -339,6 +339,7 @@ ep_thread_session_state_alloc (
 	ep_raise_error_if_nok (instance->buffer_list != NULL);
 
 	instance->delete_deferred = false;
+	instance->track_state = EP_SEQUENCE_POINT_THREAD_ID_UNTRACKED;
 
 ep_on_exit:
 	return instance;

src/native/eventpipe/ep-thread.h

@@ -302,6 +302,7 @@ struct _EventPipeThreadSessionState_Internal {
 	// buffer_manager_advance_to_non_empty_buffer, but sequence points are active,
 	// so we defer the deletion until the next sequence point updates its map.
 	bool delete_deferred;
+	EventPipeThreadSequencePointTrackState track_state;
 };
 
 #if !defined(EP_INLINE_GETTER_SETTER) && !defined(EP_IMPL_THREAD_GETTER_SETTER)
@@ -316,6 +317,8 @@ EP_DEFINE_GETTER(EventPipeThreadSessionState *, thread_session_state, uint32_t,
 EP_DEFINE_SETTER(EventPipeThreadSessionState *, thread_session_state, uint32_t, last_read_sequence_number)
 EP_DEFINE_GETTER(EventPipeThreadSessionState *, thread_session_state, bool, delete_deferred)
 EP_DEFINE_SETTER(EventPipeThreadSessionState *, thread_session_state, bool, delete_deferred)
+EP_DEFINE_GETTER(EventPipeThreadSessionState *, thread_session_state, EventPipeThreadSequencePointTrackState, track_state)
+EP_DEFINE_SETTER(EventPipeThreadSessionState *, thread_session_state, EventPipeThreadSequencePointTrackState, track_state)
 
 EventPipeThreadSessionState *
 ep_thread_session_state_alloc (

src/native/eventpipe/ep-types-forward.h

@@ -169,6 +169,42 @@ typedef enum {
 	EP_THREAD_TYPE_SAMPLING
 } EventPipeThreadType;
 
+/**
+ * Tracks the lifecycle of a ThreadSessionState in relation to SequencePoint tracking.
+ *
+ * SequencePoints capture a snapshot of thread sequence numbers at a point in time to establish
+ * ordering boundaries for event processing. This enum tracks whether a thread's sequence number
+ * needs to be included in SequencePoint snapshots.
+ *
+ * State transitions:
+ * UNTRACKED -> TRACKED: When a thread first participates in event writing after a SequencePoint is initialized
+ * TRACKED -> RETIRED: When a thread unregisters and will write no more events
+ *
+ * The UNTRACKED state exists to handle threads that write events and unregister before a SequencePoint
+ * is initialized. In this scenario, the thread's last known sequence number still needs to be tracked
+ * by the SequencePoint to maintain proper event ordering boundaries. However, if a thread has no new
+ * event writes between two SequencePoints and unregisters before the second SequencePoint, that
+ * SequencePoint does not need to track it.
+ *
+ * UNTRACKED (0): The thread has not yet been tracked by any SequencePoint since the last SequencePoint
+ * was written. This is the initial state for new ThreadSessionStates, and also applies
+ * to threads that wrote events but unregistered before a SequencePoint could track them.
+ *
+ * TRACKED (1): The thread is actively being tracked by SequencePoints. The thread's sequence number
+ * will be captured in SequencePoint snapshots to establish event ordering boundaries.
+ *
+ * RETIRED (2): The thread has unregistered and will write no more events. Once a thread unregisters
+ * before a SequencePoint, there will never be any events written by the thread past that SequencePoint,
+ * and therefore no future SequencePoints will need to track that thread's sequence numbers. The final
+ * sequence number has been captured, and future SequencePoints do not need to track this thread unless
+ * there are still unread events from this thread.
+ */
+typedef enum {
+	EP_SEQUENCE_POINT_THREAD_ID_UNTRACKED = 0,
+	EP_SEQUENCE_POINT_THREAD_ID_TRACKED = 1,
+	EP_SEQUENCE_POINT_THREAD_ID_RETIRED = 2
+} EventPipeThreadSequencePointTrackState;
+
 /*
  * EventPipe Basic Types.
  */