[EventPipe][BufferManager] Track thread_session_state

When the buffer_manager iterates over events across threads, it tracks
the current EventPipeEventInstance, EventPipeBuffer, and
EventPipeBufferList. In preparation to remove ThreadSessionStates from
the buffer_manager's thread_session_state_list, tracking the current
ThreadSessionState instead of the current EventPipeBufferList will allow
for direct removal, as they are 1:1.

ep_buffer_manager_write_all_buffers_to_file_v4 adjusts sequence points
tss:sequence_number mappings whenever events have been read from the
tss. Instead of having the tss' underlying buffer_list track the last
read sequence point, move the counter to the tss itself.

Author: mdh1418

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

@@ -113,8 +113,7 @@ static
 EventPipeBuffer *
 buffer_manager_advance_to_non_empty_buffer (
 	EventPipeBufferManager *buffer_manager,
-	EventPipeBufferList *buffer_list,
-	EventPipeBuffer *buffer,
+	EventPipeThreadSessionState *thread_session_state,
 	ep_timestamp_t before_timestamp);
 
 // Detaches this buffer from an active writer thread and marks it read-only so that the reader
@@ -164,7 +163,6 @@ ep_buffer_list_init (
 	buffer_list->head_buffer = NULL;
 	buffer_list->tail_buffer = NULL;
 	buffer_list->buffer_count = 0;
-	buffer_list->last_read_sequence_number = 0;
 
 	return buffer_list;
 }
@@ -446,7 +444,6 @@ buffer_manager_allocate_buffer_for_thread (
 	EP_ASSERT (request_size > 0);
 
 	EventPipeBuffer *new_buffer = NULL;
-	EventPipeBufferList *thread_buffer_list = NULL;
 	EventPipeSequencePoint* sequence_point = NULL;
 	uint32_t sequence_number = 0;
 
@@ -487,11 +484,9 @@ buffer_manager_allocate_buffer_for_thread (
 	new_buffer = ep_buffer_alloc (buffer_size, ep_thread_session_state_get_thread (thread_session_state), sequence_number);
 	ep_raise_error_if_nok (new_buffer != NULL);
 
+	// Allocating a new EventPipeSequencePoint and adding to the sequence_point list requires the buffer manager lock.
 	// Adding a buffer to the buffer list requires us to take the lock.
 	EP_SPIN_LOCK_ENTER (&buffer_manager->rt_lock, section1)
-		thread_buffer_list = ep_thread_session_state_get_buffer_list (thread_session_state);
-		EP_ASSERT(thread_buffer_list != NULL);
-
 		if (buffer_manager->sequence_point_alloc_budget != 0) {
 			// sequence point bookkeeping
 			if (buffer_size >= buffer_manager->remaining_sequence_point_alloc_budget) {
@@ -515,7 +510,6 @@ buffer_manager_allocate_buffer_for_thread (
 			ep_buffer_list_insert_tail (ep_thread_session_state_get_buffer_list (thread_session_state), new_buffer);
 			ep_thread_session_state_set_write_buffer (thread_session_state, new_buffer);
 		}
-
 	EP_SPIN_LOCK_EXIT (&buffer_manager->rt_lock, section1)
 
 ep_on_exit:
@@ -566,34 +560,25 @@ buffer_manager_move_next_event_any_thread (
 
 	buffer_manager->current_event = NULL;
 	buffer_manager->current_buffer = NULL;
-	buffer_manager->current_buffer_list = NULL;
+	buffer_manager->current_thread_session_state = NULL;
 
 	// We need to do this in two steps because we can't hold m_lock and EventPipeThread::m_lock
 	// at the same time.
 
 	// Step 1 - while holding m_lock get the oldest buffer from each thread
 	DN_DEFAULT_LOCAL_ALLOCATOR (allocator, dn_vector_ptr_default_local_allocator_byte_size * 2);
 
-	dn_vector_ptr_t buffer_array;
-	dn_vector_ptr_t buffer_list_array;
-
-	dn_vector_ptr_custom_init_params_t params = {0, };
-	params.allocator = (dn_allocator_t *)&allocator;
-	params.capacity = dn_vector_ptr_default_local_allocator_capacity_size;
-
-	ep_raise_error_if_nok (dn_vector_ptr_custom_init (&buffer_array, &params));
-	ep_raise_error_if_nok (dn_vector_ptr_custom_init (&buffer_list_array, &params));
+	dn_list_t *cached_thread_session_state_list = dn_list_alloc ();
+	ep_raise_error_if_nok (cached_thread_session_state_list != NULL);
 
 	EP_SPIN_LOCK_ENTER (&buffer_manager->rt_lock, section1)
 		EventPipeBufferList *buffer_list;
 		EventPipeBuffer *buffer;
 		DN_LIST_FOREACH_BEGIN (EventPipeThreadSessionState *, thread_session_state, buffer_manager->thread_session_state_list) {
 			buffer_list = ep_thread_session_state_get_buffer_list (thread_session_state);
 			buffer = buffer_list->head_buffer;
-			if (buffer && ep_buffer_get_creation_timestamp (buffer) < stop_timestamp) {
-				dn_vector_ptr_push_back (&buffer_list_array, buffer_list);
-				dn_vector_ptr_push_back (&buffer_array, buffer);
-			}
+			if (buffer && ep_buffer_get_creation_timestamp (buffer) < stop_timestamp)
+				dn_list_push_back (cached_thread_session_state_list, thread_session_state);
 		} DN_LIST_FOREACH_END;
 	EP_SPIN_LOCK_EXIT (&buffer_manager->rt_lock, section1)
 
@@ -603,32 +588,26 @@ buffer_manager_move_next_event_any_thread (
 	ep_timestamp_t oldest_timestamp;
 	oldest_timestamp = stop_timestamp;
 
-	EventPipeBufferList *buffer_list;
-	EventPipeBuffer *head_buffer;
 	EventPipeBuffer *buffer;
 	EventPipeEventInstance *next_event;
-
-	for (uint32_t i = 0; i < dn_vector_ptr_size (&buffer_array) && i < dn_vector_ptr_size (&buffer_list_array); ++i) {
-		buffer_list = (EventPipeBufferList *)*dn_vector_ptr_index (&buffer_list_array, i);
-		head_buffer = (EventPipeBuffer *)*dn_vector_ptr_index (&buffer_array, i);
-		buffer = buffer_manager_advance_to_non_empty_buffer (buffer_manager, buffer_list, head_buffer, stop_timestamp);
+	DN_LIST_FOREACH_BEGIN (EventPipeThreadSessionState *, thread_session_state, cached_thread_session_state_list) {
+		buffer = buffer_manager_advance_to_non_empty_buffer (buffer_manager, thread_session_state, stop_timestamp);
 		if (buffer) {
 			// Peek the next event out of the buffer.
 			next_event = ep_buffer_get_current_read_event (buffer);
 			// If it's the oldest event we've seen, then save it.
 			if (next_event && ep_event_instance_get_timestamp (next_event) < oldest_timestamp) {
 				buffer_manager->current_event = next_event;
 				buffer_manager->current_buffer = buffer;
-				buffer_manager->current_buffer_list = buffer_list;
+				buffer_manager->current_thread_session_state = thread_session_state;
 				oldest_timestamp = ep_event_instance_get_timestamp (buffer_manager->current_event);
 			}
 		}
-	}
+	} DN_LIST_FOREACH_END;
 
 ep_on_exit:
 	ep_buffer_manager_requires_lock_not_held (buffer_manager);
-	dn_vector_ptr_dispose (&buffer_list_array);
-	dn_vector_ptr_dispose (&buffer_array);
+	dn_list_free (cached_thread_session_state_list);
 	return;
 
 ep_on_error:
@@ -644,7 +623,7 @@ buffer_manager_move_next_event_same_thread (
 	EP_ASSERT (buffer_manager != NULL);
 	EP_ASSERT (buffer_manager->current_event != NULL);
 	EP_ASSERT (buffer_manager->current_buffer != NULL);
-	EP_ASSERT (buffer_manager->current_buffer_list != NULL);
+	EP_ASSERT (buffer_manager->current_thread_session_state != NULL);
 
 	ep_buffer_manager_requires_lock_not_held (buffer_manager);
 
@@ -653,11 +632,7 @@ buffer_manager_move_next_event_same_thread (
 	ep_buffer_move_next_read_event (buffer_manager->current_buffer);
 
 	// Find the first buffer in the list, if any, which has an event in it
-	buffer_manager->current_buffer = buffer_manager_advance_to_non_empty_buffer (
-		buffer_manager,
-		buffer_manager->current_buffer_list,
-		buffer_manager->current_buffer,
-		stop_timestamp);
+	buffer_manager->current_buffer = buffer_manager_advance_to_non_empty_buffer (buffer_manager, buffer_manager->current_thread_session_state, stop_timestamp);
 
 	if (buffer_manager->current_buffer) {
 		// get the event from that buffer
@@ -667,38 +642,37 @@ buffer_manager_move_next_event_same_thread (
 			// event exists, but isn't early enough
 			buffer_manager->current_event = NULL;
 			buffer_manager->current_buffer = NULL;
-			buffer_manager->current_buffer_list = NULL;
+			buffer_manager->current_thread_session_state = NULL;
 		} else {
 			// event is early enough, set the new cursor
 			buffer_manager->current_event = next_event;
 			EP_ASSERT (buffer_manager->current_buffer != NULL);
-			EP_ASSERT (buffer_manager->current_buffer_list != NULL);
+			EP_ASSERT (buffer_manager->current_thread_session_state != NULL);
 		}
 	} else {
 		// no more buffers prior to before_timestamp
 		EP_ASSERT (buffer_manager->current_event == NULL);
 		EP_ASSERT (buffer_manager->current_buffer == NULL);
-		buffer_manager->current_buffer_list = NULL;
+		buffer_manager->current_thread_session_state = NULL;
 	}
 }
 
 static
 EventPipeBuffer *
 buffer_manager_advance_to_non_empty_buffer (
 	EventPipeBufferManager *buffer_manager,
-	EventPipeBufferList *buffer_list,
-	EventPipeBuffer *buffer,
+	EventPipeThreadSessionState *thread_session_state,
 	ep_timestamp_t before_timestamp)
 {
 	EP_ASSERT (buffer_manager != NULL);
-	EP_ASSERT (buffer_list != NULL);
-	EP_ASSERT (buffer != NULL);
-	EP_ASSERT (buffer_list->head_buffer == buffer);
+	EP_ASSERT (thread_session_state != NULL);
 
 	ep_buffer_manager_requires_lock_not_held (buffer_manager);
 
-	EventPipeBuffer *current_buffer = buffer;
-	bool done = false;
+	EventPipeBufferList *buffer_list = ep_thread_session_state_get_buffer_list (thread_session_state);
+	EP_ASSERT (buffer_list != NULL);
+	EventPipeBuffer *current_buffer = buffer_list->head_buffer;
+	EP_ASSERT (current_buffer != NULL);
 	while (!done) {
 		buffer_manager_convert_buffer_to_read_only (buffer_manager, current_buffer);
 		if (ep_buffer_get_current_read_event (current_buffer) != NULL) {
@@ -818,7 +792,7 @@ ep_buffer_manager_alloc (
 
 	instance->current_event = NULL;
 	instance->current_buffer = NULL;
-	instance->current_buffer_list = NULL;
+	instance->current_thread_session_state = NULL;
 
 	instance->max_size_of_all_buffers = EP_CLAMP ((size_t)100 * 1024, max_size_of_all_buffers, (size_t)UINT32_MAX);
 
@@ -1155,7 +1129,7 @@ ep_buffer_manager_write_all_buffers_to_file_v4 (
 
 			uint64_t capture_thread_id = ep_thread_get_os_thread_id (ep_buffer_get_writer_thread (buffer_manager->current_buffer));
 
-			EventPipeBufferList *buffer_list = buffer_manager->current_buffer_list;
+			EventPipeThreadSessionState *current_thread_session_state = buffer_manager->current_thread_session_state;
 
 			// loop across events on this thread
 			bool events_written_for_thread = false;
@@ -1171,7 +1145,8 @@ ep_buffer_manager_write_all_buffers_to_file_v4 (
 				events_written_for_thread = true;
 				buffer_manager_move_next_event_same_thread (buffer_manager, current_timestamp_boundary);
 			}
-			buffer_list->last_read_sequence_number = sequence_number;
+
+			ep_thread_session_state_set_last_read_sequence_number (current_thread_session_state, sequence_number);
 			// Have we written events in any sequence point?
 			*events_written = events_written_for_thread || *events_written;
 		}
@@ -1193,7 +1168,7 @@ ep_buffer_manager_write_all_buffers_to_file_v4 (
 				EventPipeThreadSessionState *session_state = *dn_list_it_data_t (it, EventPipeThreadSessionState *);
 				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_buffer_list (session_state)->last_read_sequence_number;
+				uint32_t last_read_sequence_number = ep_thread_session_state_get_last_read_sequence_number (session_state);
 				// 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.

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

@@ -29,9 +29,6 @@ struct _EventPipeBufferList_Internal {
 	EventPipeBuffer *tail_buffer;
 	// The number of buffers in the list.
 	uint32_t buffer_count;
-	// The sequence number of the last event that was read, only
-	// updated/read by the reader thread.
-	uint32_t last_read_sequence_number;
 };
 
 #if !defined(EP_INLINE_GETTER_SETTER) && !defined(EP_IMPL_BUFFER_MANAGER_GETTER_SETTER)
@@ -97,7 +94,9 @@ struct _EventPipeBufferManager_Internal {
 	// These are not protected by rt_lock and expected to only be used on the reader thread.
 	EventPipeEventInstance *current_event;
 	EventPipeBuffer *current_buffer;
-	EventPipeBufferList *current_buffer_list;
+	// The thread session state grabbed from the thread_session_state_list containing the current event
+	// that is being processed by the reader thread.
+	EventPipeThreadSessionState *current_thread_session_state;
 	// The total allocation size of buffers under management.
 	volatile size_t size_of_all_buffers;
 	// The maximum allowable size of buffers under management.

src/native/eventpipe/ep-thread.c

@@ -317,6 +317,7 @@ ep_thread_session_state_alloc (
 
 	instance->session = session;
 	instance->sequence_number = 1;
+	instance->last_read_sequence_number = 0;
 
 	instance->buffer_list = ep_buffer_list_alloc (buffer_manager);
 	ep_raise_error_if_nok (instance->buffer_list != NULL);

src/native/eventpipe/ep-thread.h

@@ -270,6 +270,9 @@ struct _EventPipeThreadSessionState_Internal {
 	// The list of buffers that were written to by this thread.
 	// immutable
 	EventPipeBufferList *buffer_list;
+	// The sequence number of the last event that was read, only
+	// updated/read by the reader thread.
+	uint32_t last_read_sequence_number;
 	// The number of events that were attempted to be written by this
 	// thread. Each event was either successfully recorded in a buffer
 	// or it was dropped.
@@ -301,6 +304,8 @@ struct _EventPipeThreadSessionState {
 EP_DEFINE_GETTER_REF(EventPipeThreadSessionState *, thread_session_state, EventPipeThreadHolder *, thread_holder)
 EP_DEFINE_GETTER(EventPipeThreadSessionState *, thread_session_state, EventPipeBufferList *, buffer_list)
 EP_DEFINE_GETTER(EventPipeThreadSessionState *, thread_session_state, EventPipeSession *, session)
+EP_DEFINE_GETTER(EventPipeThreadSessionState *, thread_session_state, uint32_t, last_read_sequence_number);
+EP_DEFINE_SETTER(EventPipeThreadSessionState *, thread_session_state, uint32_t, last_read_sequence_number);
 
 EventPipeThreadSessionState *
 ep_thread_session_state_alloc (