Home | History | Annotate | Download | only in win
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/logging.h"
      6 #include "base/test/test_timeouts.h"
      7 #include "base/win/sampling_profiler.h"
      8 #include "base/win/pe_image.h"
      9 #include "base/win/scoped_handle.h"
     10 #include "base/win/windows_version.h"
     11 #include "testing/gtest/include/gtest/gtest.h"
     12 
     13 // The address of our image base.
     14 extern "C" IMAGE_DOS_HEADER __ImageBase;
     15 
     16 namespace base {
     17 namespace win {
     18 
     19 namespace {
     20 
     21 class SamplingProfilerTest : public testing::Test {
     22  public:
     23   SamplingProfilerTest() : code_start(NULL), code_size(0) {
     24   }
     25 
     26   virtual void SetUp() {
     27     process.Set(::OpenProcess(PROCESS_QUERY_INFORMATION,
     28                               FALSE,
     29                               ::GetCurrentProcessId()));
     30     ASSERT_TRUE(process.IsValid());
     31 
     32     PEImage image(&__ImageBase);
     33 
     34     // Get the address of the .text section, which is the first section output
     35     // by the VS tools.
     36     ASSERT_TRUE(image.GetNumSections() > 0);
     37     const IMAGE_SECTION_HEADER* text_section = image.GetSectionHeader(0);
     38     ASSERT_EQ(0, strncmp(".text",
     39                          reinterpret_cast<const char*>(text_section->Name),
     40                          arraysize(text_section->Name)));
     41     ASSERT_NE(0U, text_section->Characteristics & IMAGE_SCN_MEM_EXECUTE);
     42 
     43     code_start = reinterpret_cast<uint8*>(&__ImageBase) +
     44         text_section->VirtualAddress;
     45     code_size = text_section->Misc.VirtualSize;
     46   }
     47 
     48  protected:
     49   ScopedHandle process;
     50   void* code_start;
     51   size_t code_size;
     52 };
     53 
     54 }  // namespace
     55 
     56 TEST_F(SamplingProfilerTest, Initialize) {
     57   SamplingProfiler profiler;
     58 
     59   ASSERT_TRUE(profiler.Initialize(process.Get(), code_start, code_size, 8));
     60 }
     61 
     62 TEST_F(SamplingProfilerTest, Sample) {
     63   if (base::win::GetVersion() == base::win::VERSION_WIN8) {
     64     LOG(INFO) << "Not running test on Windows 8";
     65     return;
     66   }
     67   SamplingProfiler profiler;
     68 
     69   // Initialize with a huge bucket size, aiming for a single bucket.
     70   ASSERT_TRUE(
     71       profiler.Initialize(process.Get(), code_start, code_size, 31));
     72 
     73   ASSERT_EQ(1, profiler.buckets().size());
     74   ASSERT_EQ(0, profiler.buckets()[0]);
     75 
     76   // We use a roomy timeout to make sure this test is not flaky.
     77   // On the buildbots, there may not be a whole lot of CPU time
     78   // allotted to our process in this wall-clock time duration,
     79   // and samples will only accrue while this thread is busy on
     80   // a CPU core.
     81   base::TimeDelta spin_time = TestTimeouts::action_timeout();
     82 
     83   base::TimeDelta save_sampling_interval;
     84   ASSERT_TRUE(SamplingProfiler::GetSamplingInterval(&save_sampling_interval));
     85 
     86   // Sample every 0.5 millisecs.
     87   ASSERT_TRUE(SamplingProfiler::SetSamplingInterval(
     88       base::TimeDelta::FromMicroseconds(500)));
     89 
     90   ASSERT_TRUE(SamplingProfiler::SetSamplingInterval(
     91       base::TimeDelta::FromMicroseconds(500)));
     92 
     93   // Start the profiler.
     94   ASSERT_TRUE(profiler.Start());
     95 
     96   // Get a volatile pointer to our bucket to make sure that the compiler
     97   // doesn't optimize out the test in the loop that follows.
     98   volatile const ULONG* bucket_ptr = &profiler.buckets()[0];
     99 
    100   // Spin for spin_time wall-clock seconds, or until we get some samples.
    101   // Note that sleeping isn't going to do us any good, the samples only
    102   // accrue while we're executing code.
    103   base::Time start = base::Time::Now();
    104   base::TimeDelta elapsed;
    105   do {
    106     elapsed = base::Time::Now() - start;
    107   } while((elapsed < spin_time) && *bucket_ptr == 0);
    108 
    109   // Stop the profiler.
    110   ASSERT_TRUE(profiler.Stop());
    111 
    112   // Restore the sampling interval we found.
    113   ASSERT_TRUE(SamplingProfiler::SetSamplingInterval(save_sampling_interval));
    114 
    115   // Check that we got some samples.
    116   ASSERT_NE(0U, profiler.buckets()[0]);
    117 }
    118 
    119 }  // namespace win
    120 }  // namespace base
    121