Implemented GetSample.

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 1398 matching lines @@
 
   /**
    * Returns whether or not the associated function is called as a
    * constructor via "new".
    */
   bool IsConstructor() const;
 };
 
 
 /**
+ * Isolate::GetSample collects the current JS execution state as a sample.
+ * A collected sample contains program counter values.
+ */
+class V8_EXPORT Sample {
+ public:
+  enum { kMaxSize = 255u };
+
+  Sample() : size_(0) {}
+  template <class InputIterator>
+  Sample(InputIterator first, InputIterator last)

[loislo, 2014/09/18 13:07:28]

Looks like it should be a v8 internal constructor or method.
Also it is not clear why do you use template here.

[gholap, 2014/09/18 23:24:14]

We start with: We don't want to expose the private variables.

If we don't have this constructor, we'd need to add v8's internal classes (which
make / fill up a sample) as friend classes. But we shouldn't add internal stuff
in include/v8.h, right?

Also, we don't really mind if the embedder knows how to construct a sample,
actually, it provides a way of testing the sample without exposing the
implementation details (whether it has an array inside it, or whether it is a
vector)

Referring to: https://codereview.chromium.org/422593003/diff/420001/include/v8.h
(Benedikt's first comment on the diff)

[loislo, 2014/09/19 08:58:16]

Got it. The only thing that still bother me is the fact that when we fill the
sample from linux signal handler we actually can't use allocator. I.e. Sample
and its buffer need to be preallocated. Otherwise we will get a deadlock. And in
this case I'd prefer a template method fill just because it is semantically
clearer.

+      : size_(0) {
+    for (; first != last && size_ < kMaxSize; ++first) data_[size_++] = *first;
+  }
+
+  typedef const void* const* const_iterator;
+  const_iterator begin() const { return &data_[0]; }
+  const_iterator end() const { return &data_[size_]; }
+  size_t size() const { return size_; }
+
+ private:
+  const void* data_[kMaxSize];
+  size_t size_;
+};
+
+
+/**
  * A JSON Parser.
  */
 class V8_EXPORT JSON {
  public:
   /**
    * Tries to parse the string |json_string| and returns it as value if
    * successful.
    *
    * \param json_string The string to parse.
    * \return The corresponding value if successfully parsed.
@@ skipping 3113 matching lines @@
    * are in the range of 0 - GetNumberOfDataSlots() - 1.
    */
   V8_INLINE static uint32_t GetNumberOfDataSlots();
 
   /**
    * Get statistics about the heap memory usage.
    */
   void GetHeapStatistics(HeapStatistics* heap_statistics);
 
   /**
+   * Get a sample from the isolate.
+   * \param sp Stack pointer.
+   * \param fp Frame pointer.
+   * \param sample Pointer to (a pre-allocated) sample which will be filled.
+   * \note GetSample should only be called when the JS thread is paused or
+   *       interrupted. If that is not the case,
+   *       GetSample behaviour is undefined.
+   */
+  void GetSample(void* sp, void* fp, Sample* sample);
+
+  /**
    * Adjusts the amount of registered external memory. Used to give V8 an
    * indication of the amount of externally allocated memory that is kept alive
    * by JavaScript objects. V8 uses this to decide when to perform global
    * garbage collections. Registering externally allocated memory will trigger
    * global garbage collections more often than it would otherwise in an attempt
    * to garbage collect the JavaScript objects that keep the externally
    * allocated memory alive.
    *
    * \param change_in_bytes the change in externally allocated memory that is
    *   kept alive by JavaScript objects.
@@ skipping 2433 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_