Home | History | Annotate | Download | only in src 
      1 // Copyright 2009-2010 the V8 project authors. All rights reserved.
      2 // Redistribution and use in source and binary forms, with or without
      3 // modification, are permitted provided that the following conditions are
      4 // met:
      5 //
      6 //     * Redistributions of source code must retain the above copyright
      7 //       notice, this list of conditions and the following disclaimer.
      8 //     * Redistributions in binary form must reproduce the above
      9 //       copyright notice, this list of conditions and the following
     10 //       disclaimer in the documentation and/or other materials provided
     11 //       with the distribution.
     12 //     * Neither the name of Google Inc. nor the names of its
     13 //       contributors may be used to endorse or promote products derived
     14 //       from this software without specific prior written permission.
     15 //
     16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 
     28 #ifndef V8_HEAP_PROFILER_H_
     29 #define V8_HEAP_PROFILER_H_
     30 
     31 #include "heap-snapshot-generator-inl.h"
     32 #include "isolate.h"
     33 #include "smart-pointers.h"
     34 
     35 namespace v8 {
     36 namespace internal {
     37 
     38 class HeapSnapshot;
     39 
     40 class HeapProfiler {
     41  public:
     42   explicit HeapProfiler(Heap* heap);
     43   ~HeapProfiler();
     44 
     45   size_t GetMemorySizeUsedByProfiler();
     46 
     47   HeapSnapshot* TakeSnapshot(
     48       const char* name,
     49       v8::ActivityControl* control,
     50       v8::HeapProfiler::ObjectNameResolver* resolver);
     51   HeapSnapshot* TakeSnapshot(
     52       String* name,
     53       v8::ActivityControl* control,
     54       v8::HeapProfiler::ObjectNameResolver* resolver);
     55 
     56   void StartHeapObjectsTracking(bool track_allocations);
     57   void StopHeapObjectsTracking();
     58   AllocationTracker* allocation_tracker() { return *allocation_tracker_; }
     59   HeapObjectsMap* heap_object_map() { return *ids_; }
     60   StringsStorage* names() { return *names_; }
     61 
     62   SnapshotObjectId PushHeapObjectsStats(OutputStream* stream);
     63   int GetSnapshotsCount();
     64   HeapSnapshot* GetSnapshot(int index);
     65   SnapshotObjectId GetSnapshotObjectId(Handle<Object> obj);
     66   void DeleteAllSnapshots();
     67   void RemoveSnapshot(HeapSnapshot* snapshot);
     68 
     69   void ObjectMoveEvent(Address from, Address to, int size);
     70 
     71   void AllocationEvent(Address addr, int size);
     72 
     73   void UpdateObjectSizeEvent(Address addr, int size);
     74 
     75   void DefineWrapperClass(
     76       uint16_t class_id, v8::HeapProfiler::WrapperInfoCallback callback);
     77 
     78   v8::RetainedObjectInfo* ExecuteWrapperClassCallback(uint16_t class_id,
     79                                                       Object** wrapper);
     80   void SetRetainedObjectInfo(UniqueId id, RetainedObjectInfo* info);
     81 
     82   bool is_tracking_object_moves() const { return is_tracking_object_moves_; }
     83   bool is_tracking_allocations() { return !allocation_tracker_.is_empty(); }
     84 
     85   Handle<HeapObject> FindHeapObjectById(SnapshotObjectId id);
     86 
     87  private:
     88   Heap* heap() const { return ids_->heap(); }
     89 
     90   // Mapping from HeapObject addresses to objects' uids.
     91   SmartPointer<HeapObjectsMap> ids_;
     92   List<HeapSnapshot*> snapshots_;
     93   SmartPointer<StringsStorage> names_;
     94   unsigned next_snapshot_uid_;
     95   List<v8::HeapProfiler::WrapperInfoCallback> wrapper_callbacks_;
     96   SmartPointer<AllocationTracker> allocation_tracker_;
     97   bool is_tracking_object_moves_;
     98 };
     99 
    100 } }  // namespace v8::internal
    101 
    102 #endif  // V8_HEAP_PROFILER_H_
    103