Allow thread selection alongside time range (#4659)

This allows users to select a thread either on it's own or in
conjunction with a time range selection. The UI needs some improvements
to make this more obvious, but the functionality is all there in this
PR. It is still hidden behind the flag --time_range_selection so will
nto affect any current workflows.

Bug: http://b/240111360

Author: vwbaker

src/ClientData/CaptureData.cpp

@@ -21,6 +21,7 @@
 #include "ClientData/ScopeInfo.h"
 #include "ClientData/ScopeStatsCollection.h"
 #include "GrpcProtos/process.pb.h"
+#include "OrbitBase/ThreadConstants.h"
 #include "OrbitBase/Typedef.h"
 #include "SymbolProvider/ModuleIdentifier.h"
 
@@ -276,23 +277,34 @@ std::shared_ptr<const ScopeStatsCollection> CaptureData::GetAllScopeStatsCollect
 }
 
 std::unique_ptr<const ScopeStatsCollection> CaptureData::CreateScopeStatsCollection(
-    uint64_t min_tick, uint64_t max_tick) const {
+    uint32_t thread_id, uint64_t min_tick, uint64_t max_tick) const {
   ORBIT_CHECK(scope_id_provider_);
-  auto timers = GetAllScopeTimers(kAllValidScopeTypes, min_tick, max_tick, /*exclusive=*/true);
+  std::vector<uint32_t> thread_ids = thread_id == orbit_base::kAllProcessThreadsTid
+                                         ? GetThreadTrackDataProvider()->GetAllThreadIds()
+                                         : std::vector<uint32_t>{thread_id};
+  auto timers = GetAllScopeTimersByTids(thread_ids, kAllValidScopeTypes, min_tick, max_tick,
+                                        /*exclusive=*/true);
   return std::make_unique<ScopeStatsCollection>(*scope_id_provider_, timers);
 }
 
 [[nodiscard]] std::vector<const TimerInfo*> CaptureData::GetAllScopeTimers(
     const absl::flat_hash_set<ScopeType> types, uint64_t min_tick, uint64_t max_tick,
     bool exclusive) const {
+  std::vector<uint32_t> thread_ids = GetThreadTrackDataProvider()->GetAllThreadIds();
+  return GetAllScopeTimersByTids(thread_ids, types, min_tick, max_tick, exclusive);
+}
+
+[[nodiscard]] std::vector<const TimerInfo*> CaptureData::GetAllScopeTimersByTids(
+    const std::vector<uint32_t>& thread_ids, const absl::flat_hash_set<ScopeType> types,
+    uint64_t min_tick, uint64_t max_tick, bool exclusive) const {
   std::vector<const TimerInfo*> result;
 
   // The timers corresponding to dynamically instrumented functions and manual instrumentation
   // (kApiScope)  are stored in ThreadTracks. Hence, they're acquired separately from the manual
   // async (kApiScope).
   if (types.contains(ScopeType::kApiScope) ||
       types.contains(ScopeType::kDynamicallyInstrumentedFunction)) {
-    for (const uint32_t thread_id : GetThreadTrackDataProvider()->GetAllThreadIds()) {
+    for (const uint32_t thread_id : thread_ids) {
       const std::vector<const TimerInfo*> thread_track_timers =
           GetThreadTrackDataProvider()->GetTimers(thread_id, min_tick, max_tick, exclusive);
       std::copy_if(std::begin(thread_track_timers), std::end(thread_track_timers),

src/ClientData/include/ClientData/CaptureData.h

@@ -265,6 +265,11 @@ class CaptureData {
       uint64_t min_tick = std::numeric_limits<uint64_t>::min(),
       uint64_t max_tick = std::numeric_limits<uint64_t>::max(), bool exclusive = false) const;
 
+  [[nodiscard]] std::vector<const TimerInfo*> GetAllScopeTimersByTids(
+      const std::vector<uint32_t>& thread_ids, absl::flat_hash_set<ScopeType> types,
+      uint64_t min_tick = std::numeric_limits<uint64_t>::min(),
+      uint64_t max_tick = std::numeric_limits<uint64_t>::max(), bool exclusive = false) const;
+
   [[nodiscard]] std::vector<const TimerInfo*> GetTimersForScope(
       ScopeId scope_id, uint64_t min_tick = std::numeric_limits<uint64_t>::min(),
       uint64_t max_tick = std::numeric_limits<uint64_t>::max()) const;
@@ -277,7 +282,7 @@ class CaptureData {
       int64_t thread_id, uint64_t timestamp) const;
 
   [[nodiscard]] std::unique_ptr<const ScopeStatsCollection> CreateScopeStatsCollection(
-      uint64_t min_tick, uint64_t max_tick) const;
+      uint32_t thread_id, uint64_t min_tick, uint64_t max_tick) const;
   [[nodiscard]] std::shared_ptr<const ScopeStatsCollection> GetAllScopeStatsCollection() const;
 
  private:

src/OrbitGl/CaptureWindow.cpp

@@ -290,13 +290,11 @@ void CaptureWindow::RightUp() {
     }
   }
 
-  if (absl::GetFlag(FLAGS_time_range_selection)) {
-    if (select_start_pos_world_[0] == select_stop_pos_world_[0]) {
-      app_->ClearTimeRangeSelection();
-    } else {
-      app_->OnTimeRangeSelection(TimeRange(std::min(select_start_time_, select_stop_time_),
-                                           std::max(select_start_time_, select_stop_time_)));
-    }
+  if (select_start_pos_world_[0] == select_stop_pos_world_[0]) {
+    app_->ClearTimeRangeSelection();
+  } else {
+    app_->OnTimeRangeSelection(TimeRange(std::min(select_start_time_, select_stop_time_),
+                                         std::max(select_start_time_, select_stop_time_)));
   }
 
   if (time_graph_ != nullptr) {

src/OrbitGl/OrbitApp.cpp

@@ -7,6 +7,7 @@
 #include <absl/container/flat_hash_map.h>
 #include <absl/container/flat_hash_set.h>
 #include <absl/flags/flag.h>
+#include <absl/flags/internal/flag.h>
 #include <absl/hash/hash.h>
 #include <absl/strings/match.h>
 #include <absl/strings/str_cat.h>
@@ -117,6 +118,7 @@
 
 using orbit_base::CanceledOr;
 using orbit_base::Future;
+using orbit_base::kAllProcessThreadsTid;
 using orbit_base::NotFoundOr;
 
 using orbit_capture_client::CaptureClient;
@@ -183,6 +185,8 @@ namespace {
 constexpr const char* kNtdllSoFileName = "ntdll.so";
 constexpr const char* kWineSyscallDispatcherFunctionName = "__wine_syscall_dispatcher";
 constexpr std::string_view kGgpVlkModulePathSubstring = "ggpvlk.so";
+const TimeRange kDefaultTimeRange =
+    TimeRange(std::numeric_limits<uint64_t>::min(), std::numeric_limits<uint64_t>::max());
 
 orbit_data_views::PresetLoadState GetPresetLoadStateForProcess(const PresetFile& preset,
                                                                const ProcessData* process) {
@@ -2156,9 +2160,15 @@ void OrbitApp::SetVisibleScopeIds(absl::flat_hash_set<ScopeId> visible_scope_ids
 }
 
 bool OrbitApp::IsTimerActive(const TimerInfo& timer) const {
-  const std::optional<TimeRange>& time_range = data_manager_->GetSelectionTimeRange();
-  if (time_range.has_value() && !time_range.value().IsTimerInRange(timer)) {
-    return false;
+  if (absl::GetFlag(FLAGS_time_range_selection)) {
+    const std::optional<TimeRange>& time_range = data_manager_->GetSelectionTimeRange();
+    if (time_range.has_value() && !time_range.value().IsTimerInRange(timer)) {
+      return false;
+    }
+    const uint32_t thread_id = data_manager_->selected_thread_id();
+    if (thread_id != kAllProcessThreadsTid && thread_id != timer.thread_id()) {
+      return false;
+    }
   }
   const std::optional<ScopeId> scope_id = GetCaptureData().ProvideScopeId(timer);
   if (!scope_id.has_value()) {
@@ -2180,7 +2190,8 @@ ThreadID OrbitApp::selected_thread_id() const { return data_manager_->selected_t
 
 void OrbitApp::set_selected_thread_id(ThreadID thread_id) {
   RequestUpdatePrimitives();
-  return data_manager_->set_selected_thread_id(thread_id);
+  data_manager_->set_selected_thread_id(thread_id);
+  OnThreadOrTimeRangeSelectionChange();
 }
 
 std::optional<ThreadStateSliceInfo> OrbitApp::selected_thread_state_slice() const {
@@ -2290,8 +2301,7 @@ void OrbitApp::InspectCallstackEvents(absl::Span<const CallstackEvent> selected_
   FireRefreshCallbacks();
 }
 
-void OrbitApp::ClearAllSelections() {
-  ClearInspection();
+void OrbitApp::ClearSelectionTabs() {
   ClearSelectionReport();
   ClearSelectionTopDownView();
   ClearSelectionBottomUpView();
@@ -2806,33 +2816,57 @@ const ProcessData& OrbitApp::GetConnectedOrLoadedProcess() const {
 }
 
 void OrbitApp::OnTimeRangeSelection(TimeRange time_range) {
-  ClearAllSelections();
-
-  auto selected_callstack_events =
-      GetCaptureData().GetCallstackData().GetCallstackEventsInTimeRange(time_range.start,
-                                                                        time_range.end);
-  SetCaptureDataSelectionFields(selected_callstack_events, /*origin_is_multiple_threads=*/true);
-
-  main_window_->SetLiveTabScopeStatsCollection(
-      GetCaptureData().CreateScopeStatsCollection(time_range.start, time_range.end));
-  SetTopDownView(GetCaptureData().selection_post_processed_sampling_data());
-  SetBottomUpView(GetCaptureData().selection_post_processed_sampling_data());
-  SetSamplingReport(&GetCaptureData().selection_callstack_data(),
-                    &GetCaptureData().selection_post_processed_sampling_data());
   data_manager_->SetSelectionTimeRange(time_range);
-
-  FireRefreshCallbacks();
+  OnThreadOrTimeRangeSelectionChange();
 }
 
 void OrbitApp::ClearTimeRangeSelection() {
-  ClearAllSelections();
+  data_manager_->ClearSelectionTimeRange();
+  OnThreadOrTimeRangeSelectionChange();
+}
 
+void OrbitApp::ClearThreadAndTimeRangeSelection() {
   main_window_->SetLiveTabScopeStatsCollection(GetCaptureData().GetAllScopeStatsCollection());
   SetTopDownView(GetCaptureData().post_processed_sampling_data());
   SetBottomUpView(GetCaptureData().post_processed_sampling_data());
   SetSamplingReport(&GetCaptureData().GetCallstackData(),
                     &GetCaptureData().post_processed_sampling_data());
-  data_manager_->ClearSelectionTimeRange();
+
+  FireRefreshCallbacks();
+}
+
+void OrbitApp::OnThreadOrTimeRangeSelectionChange() {
+  if (!HasCaptureData() || !absl::GetFlag(FLAGS_time_range_selection)) return;
+
+  ClearSelectionTabs();
+  ClearInspection();
+
+  uint32_t thread_id = data_manager_->selected_thread_id();
+  bool has_time_range = data_manager_->GetSelectionTimeRange().has_value();
+  if (thread_id == kAllProcessThreadsTid && !has_time_range) {
+    ClearThreadAndTimeRangeSelection();
+    return;
+  }
+
+  TimeRange time_range =
+      has_time_range ? data_manager_->GetSelectionTimeRange().value() : kDefaultTimeRange;
+  if (thread_id == kAllProcessThreadsTid) {
+    SetCaptureDataSelectionFields(GetCaptureData().GetCallstackData().GetCallstackEventsInTimeRange(
+                                      time_range.start, time_range.end),
+                                  /*origin_is_multiple_threads=*/true);
+  } else {
+    SetCaptureDataSelectionFields(
+        GetCaptureData().GetCallstackData().GetCallstackEventsOfTidInTimeRange(
+            thread_id, time_range.start, time_range.end),
+        /*origin_is_multiple_threads=*/false);
+  }
+
+  main_window_->SetLiveTabScopeStatsCollection(
+      GetCaptureData().CreateScopeStatsCollection(thread_id, time_range.start, time_range.end));
+  SetTopDownView(GetCaptureData().selection_post_processed_sampling_data());
+  SetBottomUpView(GetCaptureData().selection_post_processed_sampling_data());
+  SetSamplingReport(&GetCaptureData().selection_callstack_data(),
+                    &GetCaptureData().selection_post_processed_sampling_data());
 
   FireRefreshCallbacks();
 }

src/OrbitGl/include/OrbitGl/OrbitApp.h

@@ -408,7 +408,7 @@ class OrbitApp final : public DataViewFactory,
       absl::Span<const orbit_client_data::CallstackEvent> selected_callstack_events,
       bool origin_is_multiple_threads);
   void ClearInspection();
-  void ClearAllSelections();
+  void ClearSelectionTabs();
 
   void SelectTracepoint(const orbit_grpc_protos::TracepointInfo& tracepoint) override;
   void DeselectTracepoint(const orbit_grpc_protos::TracepointInfo& tracepoint) override;
@@ -486,6 +486,8 @@ class OrbitApp final : public DataViewFactory,
 
   void OnTimeRangeSelection(orbit_client_data::TimeRange time_range);
   void ClearTimeRangeSelection();
+  void OnThreadOrTimeRangeSelectionChange();
+  void ClearThreadAndTimeRangeSelection();
 
  private:
   void UpdateModulesAbortCaptureIfModuleWithoutBuildIdNeedsReload(