Simplify ProfLazyMode test on Linux.

src/platform.h

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 536 matching lines @@
   Address function;  // The last called JS function.
   static const int kMaxFramesCount = 64;
   Address stack[kMaxFramesCount];  // Call stack.
   int frames_count;  // Number of captured frames.
 };
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 class Sampler {
  public:
   // Initialize sampler.
-  explicit Sampler(int interval, bool profiling);
+  Sampler(int interval, bool profiling);
   virtual ~Sampler();
 
   // Performs stack sampling.
   virtual void SampleStack(TickSample* sample) = 0;
 
   // This method is called for each sampling period with the current
   // program counter.
   virtual void Tick(TickSample* sample) = 0;
 
   // Start and stop sampler.
   void Start();
   void Stop();
 
   // Is the sampler used for profiling?
   bool IsProfiling() const { return profiling_; }
 
   // Is the sampler running in sync with the JS thread? On platforms
   // where the sampler is implemented with a thread that wakes up
   // every now and then, having a synchronous sampler implies
   // suspending/resuming the JS thread.
   bool IsSynchronous() const { return synchronous_; }
 
   // Whether the sampler is running (that is, consumes resources).
   bool IsActive() const { return active_; }
 
+  unsigned int samples_taken() { return samples_taken_; }

[Vitaly Repeshko, 2010/11/25 15:01:20]

Please document what this counter means and that it's exposed mainly for testing
purposes.

Style nit: the mutator functions names should be CamelCase.

[mnaganov (inactive), 2010/11/25 15:26:56]

Done.

+  void inc_samples_taken() { ++samples_taken_; }

[Vitaly Repeshko, 2010/11/25 15:01:20]

Do we have to expose increment? Can't we do this before calling the
subclass-provided SampleStack? (E.g. we could have non-virtual SampleStack doing
increment and delegating the real work to virtual DoSampleStack.)

Another idea is to move this counter together with related functions to Ticker
and Logger.

[mnaganov (inactive), 2010/11/25 15:26:56]

Ticker is a module-private class, it can't be used outside of Logger. And I
don't like the idea of moving this counter to Logger, it's already too big.

I've made a non-virtual function that call IncSampleStack.

+  void reset_samples_taken() { samples_taken_ = 0; }
+
   class PlatformData;
 
  private:
   const int interval_;
   const bool profiling_;
   const bool synchronous_;
   bool active_;
   PlatformData* data_;  // Platform specific data.
+  unsigned int samples_taken_;

[Vitaly Repeshko, 2010/11/25 15:01:20]

Unsigned is banned by the style guide
(http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Intege...).
If you really care about extra bits use int64_t.

[mnaganov (inactive), 2010/11/25 15:26:56]

I care about the possibility of having negative values. Fixed.

   DISALLOW_IMPLICIT_CONSTRUCTORS(Sampler);
 };
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal
 
 #endif  // V8_PLATFORM_H_