Initial GetSample implementation.

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 1280 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,
+ * - stack       : An array of addresses.
+ *                 One address per stack frame.
+ *                 The address is the instruction pointer,
+ *                 pointing to the instruction which led to the
+ *                 creation of the stack frame.
+ *                 (for example, a function call)
+ * - frames_count: Number of stack frames that were captured.
+ *                 That is, stack[frames_count+i] might contain meaningless
+ *                 addresses for any i >= 0.
+ */
+struct V8_EXPORT Sample {

[Benedikt Meurer, 2014/09/03 04:24:30]

I would really love to get rid of the public fields below, exposing the
internals is never a good idea, although I admit that it's unlikely that we will
ever change this. But how about this instead?

class V8_EXPORT Sample {
 public:
  enum { kMaxSize = 255u };

  Sample() : size_(0) {}
  template <class InputIterator> 
  Sample(InputIterator first, InputIterator last) : size_(0) {
    for (; first != last; ++first) data_[size_++] = *first;
  }

  typedef 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:
  void const* data_[kMaxSize];
  size_t size_;
};

Not super critical for the first version, but on the other hand this is public
API and we should not refactor it too often once landed, so maybe better have it
in from the beginning. WDYT?

[gholap, 2014/09/03 19:44:29]

Let us discuss this in person?

+  Sample()
+      : frames_count(0) {}
+  static const unsigned kMaxFramesCount = 255;

[Benedikt Meurer, 2014/09/03 04:24:30]

Should probably be

enum { kMaxFramesCount = 255u };

or otherwise requires a corresponding definition in an implementation file (we
had strange linker bugs with some compilers and code like this recently).

[gholap, 2014/09/03 19:44:29]

Done.

+
+  void* stack[kMaxFramesCount];  // Call stack.
+  unsigned frames_count;         // Number of captured frames.

[Benedikt Meurer, 2014/09/03 04:24:30]

I think this should be size_t instead of unsigned.

[gholap, 2014/09/03 19:44:29]

Done.

+};
+
+
+/**
  * 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 2899 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.
+   */
+  void GetSample(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 2473 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_