Bug 2050049 - Add a profiler API to dump a profile off the main thread after a deadline, r=profiler-reviewers,mstange.

Add profiler_schedule_dump_to_file / profiler_cancel_scheduled_dump (exposed
on nsIProfiler as scheduleDumpToFile / cancelScheduledDump), backed by a
one-shot deadline the SamplerThread checks each tick and serializes off the
main thread via profiler_save_profile_to_file.

Unlike a main-thread timer this still fires when the main thread is wedged in a
long synchronous run, so a caller can get a profile from a process that would
otherwise be force-killed without one.

Differential Revision: https://phabricator.services.mozilla.com/D308520

Author: fqueze

tools/profiler/core/platform.cpp

@@ -990,6 +990,28 @@ class CorePS {
   PS_GET_AND_SET(const Maybe<nsCOMPtr<nsIFile>>&, AsyncSignalDumpDirectory)
 #endif
 
+  // The scheduled off-main-thread profile dump deadline
+  // (profiler_schedule_dump_to_file). A null deadline means none is scheduled.
+  // Read by the sampler thread.
+  static const TimeStamp& ScheduledDumpDeadline(PSLockRef) {
+    MOZ_ASSERT(sInstance);
+    return sInstance->mScheduledDumpDeadline;
+  }
+  static const nsACString& ScheduledDumpPath(PSLockRef) {
+    MOZ_ASSERT(sInstance);
+    return sInstance->mScheduledDumpPath;
+  }
+  static void ScheduleDumpToFile(PSLockRef, const TimeStamp& aDeadline,
+                                 const nsACString& aPath) {
+    MOZ_ASSERT(sInstance);
+    sInstance->mScheduledDumpDeadline = aDeadline;
+    sInstance->mScheduledDumpPath = aPath;
+  }
+  static void CancelScheduledDump(PSLockRef) {
+    MOZ_ASSERT(sInstance);
+    sInstance->mScheduledDumpDeadline = TimeStamp{};
+  }
+
   static void SetBandwidthCounter(ProfilerBandwidthCounter* aBandwidthCounter) {
     MOZ_ASSERT(sInstance);
 
@@ -1043,6 +1065,12 @@ class CorePS {
   // fission)
   nsAutoCString mETLDplus1;
 
+  // A scheduled off-main-thread profile dump (profiler_schedule_dump_to_file):
+  // the deadline at which the sampler thread should write the profile, and the
+  // file to write it to. Null deadline when none is scheduled.
+  TimeStamp mScheduledDumpDeadline;
+  nsAutoCString mScheduledDumpPath;
+
   // This memory buffer is used by the MergeStacks mechanism. Previously it was
   // stack allocated, but this led to a stack overflow, as it was too much
   // memory. Here the buffer can be pre-allocated, and shared with the
@@ -4664,6 +4692,12 @@ void SamplerThread::Run() {
   // This will be set inside the loop, before invoking callbacks outside.
   SamplingState samplingState{};
 
+  // Set inside the locked scope when a scheduled off-main-thread profile dump
+  // (profiler_schedule_dump_to_file) is due, then acted on outside the lock
+  // (profiler_save_profile_to_file takes the profiler lock itself).
+  bool scheduledDumpDue = false;
+  nsAutoCString scheduledDumpPath;
+
   const TimeDuration sampleInterval =
       TimeDuration::FromMicroseconds(mIntervalMicroseconds);
   const uint32_t minimumIntervalSleepUs =
@@ -4737,6 +4771,13 @@ void SamplerThread::Run() {
 
       ActivePS::ClearExpiredExitProfiles(lock);
 
+      if (const TimeStamp& deadline = CorePS::ScheduledDumpDeadline(lock);
+          !deadline.IsNull() && sampleStart >= deadline) {
+        scheduledDumpDue = true;
+        scheduledDumpPath = CorePS::ScheduledDumpPath(lock);
+        CorePS::CancelScheduledDump(lock);
+      }
+
       TimeStamp expiredMarkersCleaned = TimeStamp::Now();
 
       if (int(gSkipSampling) <= 0 && !ActivePS::IsSamplingPaused(lock)) {
@@ -5212,6 +5253,13 @@ void SamplerThread::Run() {
     InvokePostSamplingCallbacks(std::move(postSamplingCallbacks),
                                 samplingState);
 
+    // We've hit the deadline for a scheduled profile dump; call
+    // profiler_save_profile_to_file outside the lock to avoid a deadlock.
+    if (scheduledDumpDue) {
+      scheduledDumpDue = false;
+      profiler_save_profile_to_file(scheduledDumpPath.get());
+    }
+
     ProfilerChild::ProcessPendingUpdate();
 
     if (ProfilerFeature::HasUnregisteredThreads(features)) {
@@ -6605,6 +6653,30 @@ void profiler_save_profile_to_file(const char* aFilename) {
                                        preRecordedMetaInformation);
 }
 
+void profiler_schedule_dump_to_file(double aDelaySeconds,
+                                    const char* aFilename) {
+  if (!aFilename || !CorePS::Exists()) {
+    return;
+  }
+
+  // Compute the deadline before grabbing the lock, which may already be held
+  // by another thread for a while.
+  TimeStamp deadline =
+      TimeStamp::Now() + TimeDuration::FromSeconds(aDelaySeconds);
+
+  PSAutoLock lock;
+  CorePS::ScheduleDumpToFile(lock, deadline, nsDependentCString(aFilename));
+}
+
+void profiler_cancel_scheduled_dump() {
+  if (!CorePS::Exists()) {
+    return;
+  }
+
+  PSAutoLock lock;
+  CorePS::CancelScheduledDump(lock);
+}
+
 void profiler_request_dump_and_quit_for_test(const nsACString& aReason) {
   if (!profiler_is_active()) {
     return;

tools/profiler/gecko/nsIProfiler.idl

@@ -127,6 +127,24 @@ interface nsIProfiler : nsISupports
    */
   void dumpProfileToFile(in string aFilename);
 
+  /**
+   * Schedule a one-shot profile dump performed off the main thread by the
+   * sampler thread once `aDelaySeconds` have elapsed, writing this process's
+   * profile to `aFilename` (a no-op if the profiler stops first).
+   *
+   * Unlike a main-thread timer, this still fires when the main thread is stuck
+   * in a long synchronous run, so a test that would otherwise be force-killed
+   * by the harness without a profile still leaves one. The harness that set the
+   * deadline is responsible for reporting the written file. Call
+   * `cancelScheduledDump` when the test ends normally.
+   */
+  void scheduleDumpToFile(in double aDelaySeconds, in string aFilename);
+
+  /**
+   * Cancel a dump scheduled by `scheduleDumpToFile`.
+   */
+  void cancelScheduledDump();
+
   boolean IsActive();
 
   /**

tools/profiler/gecko/nsProfiler.cpp

@@ -354,6 +354,18 @@ nsProfiler::DumpProfileToFile(const char* aFilename) {
   return NS_OK;
 }
 
+NS_IMETHODIMP
+nsProfiler::ScheduleDumpToFile(double aDelaySeconds, const char* aFilename) {
+  profiler_schedule_dump_to_file(aDelaySeconds, aFilename);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsProfiler::CancelScheduledDump() {
+  profiler_cancel_scheduled_dump();
+  return NS_OK;
+}
+
 NS_IMETHODIMP
 nsProfiler::GetProfileData(double aSinceTime, JSContext* aCx,
                            JS::MutableHandle<JS::Value> aResult) {

tools/profiler/public/GeckoProfiler.h

@@ -319,6 +319,23 @@ extern "C" {
 void profiler_save_profile_to_file(const char* aFilename);
 }
 
+// Schedule a one-shot profile dump that the sampler thread performs off the
+// main thread once aDelaySeconds have elapsed, writing this process's profile
+// to aFilename (a no-op if the profiler stops first).
+//
+// This exists for the test harnesses: a test that wedges its main thread (a
+// long synchronous run that never returns to the event loop, or a blocking
+// native call) gets force-killed by the harness without leaving a profile,
+// because a main-thread timer can never fire. Dumping from the sampler thread
+// sidesteps that: profiler_save_profile_to_file only needs the profiler state
+// lock, and the sampled main-thread stack it captures shows where the time
+// went. The harness that set the deadline is responsible for reporting the
+// written file. Call profiler_cancel_scheduled_dump() when the test ends
+// normally.
+void profiler_schedule_dump_to_file(double aDelaySeconds,
+                                    const char* aFilename);
+void profiler_cancel_scheduled_dump();
+
 //---------------------------------------------------------------------------
 // RAII classes
 //---------------------------------------------------------------------------