Initial GetSample implementation.

test/cctest/test-sampler-api.cc

+// Copyright 2014 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
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Tests the public sampling API in include/v8-sampler.h
+
+#include "include/v8-sampler.h"
+
+#include "src/v8.h"
+
+#include "src/base/platform/platform.h"
+
+#include "test/cctest/cctest.h"
+
+using v8::Local;
+using v8::Script;
+
+using v8::internal::Isolate;
+
+// A thread which collects samples from v8.
+class SamplerThread : public v8::base::Thread {
+ public:
+  explicit SamplerThread(v8::Isolate* isolate);
+  virtual ~SamplerThread() {}
+  int biggestSampleStackSize;
+
+  void Stop();
+
+  // Thread control.
+  virtual void Run();
+
+ private:
+  v8::Isolate* isolate_;
+  volatile bool done_sampling_;
+};
+
+static const int kSamplerThreadStackSize = 64 * 1024;
+
+SamplerThread::SamplerThread(v8::Isolate* isolate)
+    : Thread(v8::base::Thread::Options("sampler-api-tester",
+                                       kSamplerThreadStackSize)),
+      biggestSampleStackSize(0),
+      isolate_(isolate),
+      done_sampling_(false) {
+}
+
+
+void SamplerThread::Stop() {
+  done_sampling_ = true;
+  v8::base::OS::Sleep(0);
+  Join();
+}
+
+
+void SamplerThread::Run() {
+  v8::Sample sample;
+  while (!done_sampling_) {
+    v8::Sample* sample_ptr = &sample;
+    sample_ptr = v8::Sampler::GetSample(isolate_, sample_ptr);
+    if (sample_ptr == NULL)
+      return;
+    if (sample_ptr->frames_count > biggestSampleStackSize)
+      biggestSampleStackSize = sample_ptr->frames_count;
+    v8::base::OS::Sleep(1);
+  }
+}
+
+
+// A JavaScript program with stack depth 5
+static const char* sampler_api_test_source = "function func(count) {\n"
+"  if (count == 1) {\n"
+"    var a = 0;\n"
+"    for (var i = 0; i < 100000; i++) {\n"
+"      a = i;\n"
+"    }\n"
+"    return a;\n"
+"  }\n"
+"  else return func(count - 1);\n"
+"}\n"
+"func(5);\n";
+
+
+// TODO(gholap): Right now, we are just checking whether GetSample
+//               gets samples and whether the stack depth is reasonable.
+//               After implementing code event listener API, add tests
+//               to further verify the correctness of collected samples.
+TEST(StackDepthIsConsistent) {

[Benedikt Meurer, 2014/08/25 04:24:22]

Please don't add any more of these fragile tests. First of all, the loop above
is basically dead-code, i.e. can be replaced with an assignment a = 100000,
which neither Crankshaft nor Fullcodegen do right now, but we may do that in the
future in Turbofan. Next, even if the loop runs for some time, there's
absolutely no warranty, that the OS scheduler allows you to capture a sample
with stack height 5. You'll need some kind of synchronization to ensure that the
"script thread" is in an expected state, otherwise this test will end up being
as useless as the current CPU profiler tests.

[gholap, 2014/08/25 17:12:30]

Ah! I see your point. Without synchronization, the test is a fragile one. Also,
I didn't realize the loop optimization issue either. The idea was to have a loop
big enough so that it runs long enough for the sampler to be able to capture at
least a full-depth stack trace. I think, if we do a += i instead of a = i; the
optimization issue will be taken care of?

Also, about synchronization, I assumed the following:
1) Sampler starts before the JS thread.
2) Sampler ends only after the JS thread is finished executing.
3) If sampler sleeps every one millisecond, and if the JS thread runs for orders
of magnitude longer, the sampler is bound to get _some_ sample. Again, because
the JS thread spends almost all its time at the full depth, the chances of not
hitting any of those samples becomes very very small.

Now, after you pointed out, I realize how that logic was flawed. Small or not,
any test which relies on probabilities is bad. I'm a bit stuck here at this and
it would be really awesome if you could help me out and teach me how to handle
such cases...

+  LocalContext env;
+  v8::HandleScope scope(env->GetIsolate());
+  Local<v8::Script> script = v8::Script::Compile(
+    v8::String::NewFromUtf8(env->GetIsolate(), sampler_api_test_source));
+  SamplerThread* sampler = new SamplerThread(env->GetIsolate());
+  sampler->Start();
+  script->Run();
+  sampler->Stop();
+
+  // Due to v8 issue 3428, sometimes an extra frame is captured.
+  // Make allowences for that.
+  CHECK_LE(5, sampler->biggestSampleStackSize);
+  CHECK_GE(6, sampler->biggestSampleStackSize);
+}