[VM/Profiler] Correctly apply the value of --profile-period specified on the CLI

TEST=Verified that pkg/vm_service/test/profile_period_cli_option_test
passes with the changes in this CL and fails without them.

Change-Id: Ic36014abe682f9b4c829317b59bb664683e12d7e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/412781
Commit-Queue: Derek Xu <[email protected]>
Reviewed-by: Siva Annamalai <[email protected]>

Author: derekxu16

pkg/vm_service/test/profile_period_cli_option_test.dart

@@ -0,0 +1,35 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test/test.dart';
+import 'package:vm_service/vm_service.dart';
+
+import 'common/test_helper.dart';
+
+void testeeMain() {
+  final stopwatch = Stopwatch();
+  stopwatch.start();
+  while (stopwatch.elapsedMilliseconds < 5000) {}
+  stopwatch.stop();
+}
+
+final tests = <IsolateTest>[
+  (VmService service, IsolateRef isolateRef) async {
+    final cpuSamples = await service.getCpuSamples(isolateRef.id!, -1, -1);
+    // The default profile period is 1ms, and the testee runs for at least 5000
+    // ms. So, we confirm that increasing the profile period using the CLI
+    // option worked by confirming that we received significantly fewer than
+    // 5000 samples.
+    expect(cpuSamples.sampleCount, lessThan(2000));
+  }
+];
+
+Future<void> main([args = const <String>[]]) => runIsolateTests(
+      args,
+      tests,
+      'eval_with_resident_compiler_test.dart',
+      testeeBefore: testeeMain,
+      pauseOnExit: true,
+      extraArgs: ['--profile-period=10000'],
+    );

runtime/vm/profiler.cc

@@ -580,14 +580,14 @@ void Profiler::Init() {
     return;
   }
   ASSERT(!initialized_);
-  SetSamplePeriod(FLAG_profile_period);
   // The profiler may have been shutdown previously, in which case the sample
   // buffer will have already been initialized.
   if (sample_block_buffer_ == nullptr) {
     intptr_t num_blocks = CalculateSampleBufferCapacity();
     sample_block_buffer_ = new SampleBlockBuffer(num_blocks);
   }
-  ThreadInterrupter::Init();
+  UpdateFlagProfilePeriod(FLAG_profile_period);
+  ThreadInterrupter::Init(FLAG_profile_period);
   ThreadInterrupter::Startup();
   SampleBlockProcessor::Init();
   SampleBlockProcessor::Startup();
@@ -656,18 +656,18 @@ intptr_t Profiler::CalculateSampleBufferCapacity() {
   return (sample_count / SampleBlock::kSamplesPerBlock) + 1;
 }
 
-void Profiler::SetSamplePeriod(intptr_t period) {
+void Profiler::UpdateFlagProfilePeriod(intptr_t period) {
   const int kMinimumProfilePeriod = 50;
   if (period < kMinimumProfilePeriod) {
     FLAG_profile_period = kMinimumProfilePeriod;
   } else {
     FLAG_profile_period = period;
   }
-  ThreadInterrupter::SetInterruptPeriod(FLAG_profile_period);
 }
 
 void Profiler::UpdateSamplePeriod() {
-  SetSamplePeriod(FLAG_profile_period);
+  UpdateFlagProfilePeriod(FLAG_profile_period);
+  ThreadInterrupter::SetInterruptPeriod(FLAG_profile_period);
 }
 
 SampleBlockBuffer::SampleBlockBuffer(intptr_t blocks,

runtime/vm/profiler.h

@@ -56,7 +56,8 @@ class Profiler : public AllStatic {
   static void Cleanup();
 
   static void SetSampleDepth(intptr_t depth);
-  static void SetSamplePeriod(intptr_t period);
+  // Sets |FLAG_profile_period| to |max(period, 50)|.
+  static void UpdateFlagProfilePeriod(intptr_t period);
   // Restarts sampling with a given profile period. This is called after the
   // profile period is changed via the service protocol.
   static void UpdateSamplePeriod();

runtime/vm/profiler_test.cc

@@ -2438,7 +2438,8 @@ ISOLATE_UNIT_TEST_CASE(Profiler_ProfileCodeTableTest) {
 // https://github.com/flutter/flutter/issues/134548
 ISOLATE_UNIT_TEST_CASE(Profiler_EnterExitIsolate) {
   EnableProfiler();
-  Profiler::SetSamplePeriod(50);  // Microseconds.
+  Profiler::UpdateFlagProfilePeriod(50);  // Microseconds.
+  Profiler::UpdateSamplePeriod();
 
   const char* kScript = "main() => null;\n";
   const Library& root_library = Library::Handle(LoadTestScript(kScript));

runtime/vm/thread_interrupter.cc

@@ -51,14 +51,15 @@ Monitor* ThreadInterrupter::monitor_ = nullptr;
 intptr_t ThreadInterrupter::interrupt_period_ = 1000;
 intptr_t ThreadInterrupter::current_wait_time_ = Monitor::kNoTimeout;
 
-void ThreadInterrupter::Init() {
+void ThreadInterrupter::Init(intptr_t period) {
   ASSERT(!initialized_);
   if (monitor_ == nullptr) {
     monitor_ = new Monitor();
   }
   ASSERT(monitor_ != nullptr);
   initialized_ = true;
   shutdown_ = false;
+  interrupt_period_ = period;
 }
 
 void ThreadInterrupter::Startup() {

runtime/vm/thread_interrupter.h

@@ -22,12 +22,15 @@ struct InterruptedThreadState {
 
 class ThreadInterrupter : public AllStatic {
  public:
-  static void Init();
+  static void Init(intptr_t period);
 
   static void Startup();
   static void Cleanup();
 
   // Delay between interrupts.
+  //
+  // Warning: This method will have no effect if
+  // |ThreadInterrupter::initialized_| is false.
   static void SetInterruptPeriod(intptr_t period);
 
   // Wake up the thread interrupter thread.