v8-profiler.h   v8-profiler.h 
skipping to change at line 240 skipping to change at line 240
/** Returns destination node. */ /** Returns destination node. */
const HeapGraphNode* GetToNode() const; const HeapGraphNode* GetToNode() const;
}; };
/** /**
* HeapGraphNode represents a node in a heap graph. * HeapGraphNode represents a node in a heap graph.
*/ */
class V8EXPORT HeapGraphNode { class V8EXPORT HeapGraphNode {
public: public:
enum Type { enum Type {
kHidden = 0, // Hidden node, may be filtered when shown to user. kHidden = 0, // Hidden node, may be filtered when shown to user.
kArray = 1, // An array of elements. kArray = 1, // An array of elements.
kString = 2, // A string. kString = 2, // A string.
kObject = 3, // A JS object (except for arrays and strings). kObject = 3, // A JS object (except for arrays and strings).
kCode = 4, // Compiled code. kCode = 4, // Compiled code.
kClosure = 5, // Function closure. kClosure = 5, // Function closure.
kRegExp = 6, // RegExp. kRegExp = 6, // RegExp.
kHeapNumber = 7 // Number stored in the heap. kHeapNumber = 7, // Number stored in the heap.
kNative = 8 // Native object (not from V8 heap).
}; };
/** Returns node type (see HeapGraphNode::Type). */ /** Returns node type (see HeapGraphNode::Type). */
Type GetType() const; Type GetType() const;
/** /**
* Returns node name. Depending on node's type this can be the name * Returns node name. Depending on node's type this can be the name
* of the constructor (for objects), the name of the function (for * of the constructor (for objects), the name of the function (for
* closures), string value, or an empty string (for compiled code). * closures), string value, or an empty string (for compiled code).
*/ */
skipping to change at line 384 skipping to change at line 385
* ], * ],
* strings: [strings] * strings: [strings]
* } * }
* *
* Outgoing node links are stored after each node. Nodes reference string s * Outgoing node links are stored after each node. Nodes reference string s
* and other nodes by their indexes in corresponding arrays. * and other nodes by their indexes in corresponding arrays.
*/ */
void Serialize(OutputStream* stream, SerializationFormat format) const; void Serialize(OutputStream* stream, SerializationFormat format) const;
}; };
class RetainedObjectInfo;
/** /**
* Interface for controlling heap profiling. * Interface for controlling heap profiling.
*/ */
class V8EXPORT HeapProfiler { class V8EXPORT HeapProfiler {
public: public:
/**
* Callback function invoked for obtaining RetainedObjectInfo for
* the given JavaScript wrapper object. It is prohibited to enter V8
* while the callback is running: only getters on the handle and
* GetPointerFromInternalField on the objects are allowed.
*/
typedef RetainedObjectInfo* (*WrapperInfoCallback)
(uint16_t class_id, Handle<Value> wrapper);
/** Returns the number of snapshots taken. */ /** Returns the number of snapshots taken. */
static int GetSnapshotsCount(); static int GetSnapshotsCount();
/** Returns a snapshot by index. */ /** Returns a snapshot by index. */
static const HeapSnapshot* GetSnapshot(int index); static const HeapSnapshot* GetSnapshot(int index);
/** Returns a profile by uid. */ /** Returns a profile by uid. */
static const HeapSnapshot* FindSnapshot(unsigned uid); static const HeapSnapshot* FindSnapshot(unsigned uid);
/** /**
* Takes a heap snapshot and returns it. Title may be an empty string. * Takes a heap snapshot and returns it. Title may be an empty string.
* See HeapSnapshot::Type for types description. * See HeapSnapshot::Type for types description.
*/ */
static const HeapSnapshot* TakeSnapshot( static const HeapSnapshot* TakeSnapshot(
Handle<String> title, Handle<String> title,
HeapSnapshot::Type type = HeapSnapshot::kFull, HeapSnapshot::Type type = HeapSnapshot::kFull,
ActivityControl* control = NULL); ActivityControl* control = NULL);
/** Binds a callback to embedder's class ID. */
static void DefineWrapperClass(
uint16_t class_id,
WrapperInfoCallback callback);
/**
* Default value of persistent handle class ID. Must not be used to
* define a class. Can be used to reset a class of a persistent
* handle.
*/
static const uint16_t kPersistentHandleNoClassId = 0;
};
/**
* Interface for providing information about embedder's objects
* held by global handles. This information is reported in two ways:
*
* 1. When calling AddObjectGroup, an embedder may pass
* RetainedObjectInfo instance describing the group. To collect
* this information while taking a heap snapshot, V8 calls GC
* prologue and epilogue callbacks.
*
* 2. When a heap snapshot is collected, V8 additionally
* requests RetainedObjectInfos for persistent handles that
* were not previously reported via AddObjectGroup.
*
* Thus, if an embedder wants to provide information about native
* objects for heap snapshots, he can do it in a GC prologue
* handler, and / or by assigning wrapper class ids in the following way:
*
* 1. Bind a callback to class id by calling DefineWrapperClass.
* 2. Call SetWrapperClassId on certain persistent handles.
*
* V8 takes ownership of RetainedObjectInfo instances passed to it and
* keeps them alive only during snapshot collection. Afterwards, they
* are freed by calling the Dispose class function.
*/
class V8EXPORT RetainedObjectInfo { // NOLINT
public:
/** Called by V8 when it no longer needs an instance. */
virtual void Dispose() = 0;
/** Returns whether two instances are equivalent. */
virtual bool IsEquivalent(RetainedObjectInfo* other) = 0;
/**
* Returns hash value for the instance. Equivalent instances
* must have the same hash value.
*/
virtual intptr_t GetHash() = 0;
/**
* Returns human-readable label. It must be a NUL-terminated UTF-8
* encoded string. V8 copies its contents during a call to GetLabel.
*/
virtual const char* GetLabel() = 0;
/**
* Returns element count in case if a global handle retains
* a subgraph by holding one of its nodes.
*/
virtual intptr_t GetElementCount() { return -1; }
/** Returns embedder's object size in bytes. */
virtual intptr_t GetSizeInBytes() { return -1; }
protected:
RetainedObjectInfo() {}
virtual ~RetainedObjectInfo() {}
private:
RetainedObjectInfo(const RetainedObjectInfo&);
RetainedObjectInfo& operator=(const RetainedObjectInfo&);
}; };
} // namespace v8 } // namespace v8
#undef V8EXPORT #undef V8EXPORT
#endif // V8_V8_PROFILER_H_ #endif // V8_V8_PROFILER_H_
 End of changes. 4 change blocks. 
8 lines changed or deleted 94 lines changed or added


 v8-testing.h   v8-testing.h 
skipping to change at line 89 skipping to change at line 89
* Get the number of runs of a given test that is required to get the ful l * Get the number of runs of a given test that is required to get the ful l
* stress coverage. * stress coverage.
*/ */
static int GetStressRuns(); static int GetStressRuns();
/** /**
* Indicate the number of the run which is about to start. The value of r un * Indicate the number of the run which is about to start. The value of r un
* should be between 0 and one less than the result from GetStressRuns() * should be between 0 and one less than the result from GetStressRuns()
*/ */
static void PrepareStressRun(int run); static void PrepareStressRun(int run);
/**
* Force deoptimization of all functions.
*/
static void DeoptimizeAll();
}; };
} // namespace v8 } // namespace v8
#undef V8EXPORT #undef V8EXPORT
#endif // V8_V8_TEST_H_ #endif // V8_V8_TEST_H_
 End of changes. 1 change blocks. 
0 lines changed or deleted 5 lines changed or added


 v8.h   v8.h 
skipping to change at line 394 skipping to change at line 394
/** /**
*Checks if the handle holds the only reference to an object. *Checks if the handle holds the only reference to an object.
*/ */
inline bool IsNearDeath() const; inline bool IsNearDeath() const;
/** /**
* Returns true if the handle's reference is weak. * Returns true if the handle's reference is weak.
*/ */
inline bool IsWeak() const; inline bool IsWeak() const;
/**
* Assigns a wrapper class ID to the handle. See RetainedObjectInfo
* interface description in v8-profiler.h for details.
*/
inline void SetWrapperClassId(uint16_t class_id);
private: private:
friend class ImplementationUtilities; friend class ImplementationUtilities;
friend class ObjectTemplate; friend class ObjectTemplate;
}; };
/** /**
* A stack-allocated class that governs a number of local handles. * A stack-allocated class that governs a number of local handles.
* After a handle scope has been created, all local handles will be * After a handle scope has been created, all local handles will be
* allocated within that handle scope until either the handle scope is * allocated within that handle scope until either the handle scope is
* deleted or another handle scope is created. If there is already a * deleted or another handle scope is created. If there is already a
skipping to change at line 2471 skipping to change at line 2477
void set_heap_size_limit(size_t size) { heap_size_limit_ = size; } void set_heap_size_limit(size_t size) { heap_size_limit_ = size; }
size_t total_heap_size_; size_t total_heap_size_;
size_t total_heap_size_executable_; size_t total_heap_size_executable_;
size_t used_heap_size_; size_t used_heap_size_;
size_t heap_size_limit_; size_t heap_size_limit_;
friend class V8; friend class V8;
}; };
class RetainedObjectInfo;
/** /**
* Container class for static utility functions. * Container class for static utility functions.
*/ */
class V8EXPORT V8 { class V8EXPORT V8 {
public: public:
/** Set the callback to invoke in case of fatal errors. */ /** Set the callback to invoke in case of fatal errors. */
static void SetFatalErrorHandler(FatalErrorCallback that); static void SetFatalErrorHandler(FatalErrorCallback that);
/** /**
* Ignore out-of-memory exceptions. * Ignore out-of-memory exceptions.
skipping to change at line 2640 skipping to change at line 2648
*/ */
static void RemoveMemoryAllocationCallback(MemoryAllocationCallback callb ack); static void RemoveMemoryAllocationCallback(MemoryAllocationCallback callb ack);
/** /**
* Allows the host application to group objects together. If one * Allows the host application to group objects together. If one
* object in the group is alive, all objects in the group are alive. * object in the group is alive, all objects in the group are alive.
* After each garbage collection, object groups are removed. It is * After each garbage collection, object groups are removed. It is
* intended to be used in the before-garbage-collection callback * intended to be used in the before-garbage-collection callback
* function, for instance to simulate DOM tree connections among JS * function, for instance to simulate DOM tree connections among JS
* wrapper objects. * wrapper objects.
* See v8-profiler.h for RetainedObjectInfo interface description.
*/ */
static void AddObjectGroup(Persistent<Value>* objects, size_t length); static void AddObjectGroup(Persistent<Value>* objects,
size_t length,
RetainedObjectInfo* info = NULL);
/** /**
* Initializes from snapshot if possible. Otherwise, attempts to * Initializes from snapshot if possible. Otherwise, attempts to
* initialize from scratch. This function is called implicitly if * initialize from scratch. This function is called implicitly if
* you use the API without calling it first. * you use the API without calling it first.
*/ */
static bool Initialize(); static bool Initialize();
/** /**
* Adjusts the amount of registered external memory. Used to give * Adjusts the amount of registered external memory. Used to give
skipping to change at line 2850 skipping to change at line 2861
V8(); V8();
static internal::Object** GlobalizeReference(internal::Object** handle); static internal::Object** GlobalizeReference(internal::Object** handle);
static void DisposeGlobal(internal::Object** global_handle); static void DisposeGlobal(internal::Object** global_handle);
static void MakeWeak(internal::Object** global_handle, static void MakeWeak(internal::Object** global_handle,
void* data, void* data,
WeakReferenceCallback); WeakReferenceCallback);
static void ClearWeak(internal::Object** global_handle); static void ClearWeak(internal::Object** global_handle);
static bool IsGlobalNearDeath(internal::Object** global_handle); static bool IsGlobalNearDeath(internal::Object** global_handle);
static bool IsGlobalWeak(internal::Object** global_handle); static bool IsGlobalWeak(internal::Object** global_handle);
static void SetWrapperClassId(internal::Object** global_handle,
uint16_t class_id);
template <class T> friend class Handle; template <class T> friend class Handle;
template <class T> friend class Local; template <class T> friend class Local;
template <class T> friend class Persistent; template <class T> friend class Persistent;
friend class Context; friend class Context;
}; };
/** /**
* An external exception handler. * An external exception handler.
*/ */
skipping to change at line 3480 skipping to change at line 3493
V8::MakeWeak(reinterpret_cast<internal::Object**>(**this), V8::MakeWeak(reinterpret_cast<internal::Object**>(**this),
parameters, parameters,
callback); callback);
} }
template <class T> template <class T>
void Persistent<T>::ClearWeak() { void Persistent<T>::ClearWeak() {
V8::ClearWeak(reinterpret_cast<internal::Object**>(**this)); V8::ClearWeak(reinterpret_cast<internal::Object**>(**this));
} }
template <class T>
void Persistent<T>::SetWrapperClassId(uint16_t class_id) {
V8::SetWrapperClassId(reinterpret_cast<internal::Object**>(**this), class
_id);
}
Arguments::Arguments(internal::Object** implicit_args, Arguments::Arguments(internal::Object** implicit_args,
internal::Object** values, int length, internal::Object** values, int length,
bool is_construct_call) bool is_construct_call)
: implicit_args_(implicit_args), : implicit_args_(implicit_args),
values_(values), values_(values),
length_(length), length_(length),
is_construct_call_(is_construct_call) { } is_construct_call_(is_construct_call) { }
Local<Value> Arguments::operator[](int i) const { Local<Value> Arguments::operator[](int i) const {
if (i < 0 || length_ <= i) return Local<Value>(*Undefined()); if (i < 0 || length_ <= i) return Local<Value>(*Undefined());
 End of changes. 6 change blocks. 
1 lines changed or deleted 20 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/