| OLD | NEW |
| (Empty) |
| 1 // Copyright 2015 the V8 project authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef V8_PROFILER_SAMPLING_HEAP_PROFILER_H_ | |
| 6 #define V8_PROFILER_SAMPLING_HEAP_PROFILER_H_ | |
| 7 | |
| 8 #include <deque> | |
| 9 #include <map> | |
| 10 #include <set> | |
| 11 #include "include/v8-profiler.h" | |
| 12 #include "src/heap/heap.h" | |
| 13 #include "src/profiler/strings-storage.h" | |
| 14 | |
| 15 namespace v8 { | |
| 16 | |
| 17 namespace base { | |
| 18 class RandomNumberGenerator; | |
| 19 } | |
| 20 | |
| 21 namespace internal { | |
| 22 | |
| 23 | |
| 24 class AllocationProfile : public v8::AllocationProfile { | |
| 25 public: | |
| 26 AllocationProfile() : nodes_() {} | |
| 27 | |
| 28 Node* GetRootNode() override { | |
| 29 return nodes_.size() == 0 ? nullptr : &nodes_.front(); | |
| 30 } | |
| 31 | |
| 32 std::deque<Node>& nodes() { return nodes_; } | |
| 33 | |
| 34 private: | |
| 35 std::deque<Node> nodes_; | |
| 36 | |
| 37 DISALLOW_COPY_AND_ASSIGN(AllocationProfile); | |
| 38 }; | |
| 39 | |
| 40 class SamplingHeapProfiler : public InlineAllocationObserver { | |
| 41 public: | |
| 42 SamplingHeapProfiler(Heap* heap, StringsStorage* names, uint64_t rate, | |
| 43 int stack_depth); | |
| 44 ~SamplingHeapProfiler(); | |
| 45 | |
| 46 v8::AllocationProfile* GetAllocationProfile(); | |
| 47 | |
| 48 void Step(int bytes_allocated, Address soon_object, size_t size) override; | |
| 49 intptr_t GetNextStepSize() override { | |
| 50 return GetNextSampleInterval(random_, rate_); | |
| 51 } | |
| 52 | |
| 53 StringsStorage* names() const { return names_; } | |
| 54 | |
| 55 class FunctionInfo { | |
| 56 public: | |
| 57 FunctionInfo(SharedFunctionInfo* shared, StringsStorage* names); | |
| 58 explicit FunctionInfo(const char* name) | |
| 59 : name_(name), | |
| 60 script_name_(""), | |
| 61 script_id_(v8::UnboundScript::kNoScriptId), | |
| 62 start_position_(0) {} | |
| 63 | |
| 64 const char* get_name() const { return name_; } | |
| 65 const char* get_script_name() const { return script_name_; } | |
| 66 int get_script_id() const { return script_id_; } | |
| 67 int get_start_position() const { return start_position_; } | |
| 68 | |
| 69 private: | |
| 70 const char* const name_; | |
| 71 const char* script_name_; | |
| 72 int script_id_; | |
| 73 const int start_position_; | |
| 74 }; | |
| 75 | |
| 76 class SampledAllocation { | |
| 77 public: | |
| 78 SampledAllocation(SamplingHeapProfiler* sampling_heap_profiler, | |
| 79 Isolate* isolate, Local<Value> local, size_t size, | |
| 80 int max_frames); | |
| 81 ~SampledAllocation() { | |
| 82 for (auto info : stack_) { | |
| 83 delete info; | |
| 84 } | |
| 85 global_.Reset(); // drop the reference. | |
| 86 } | |
| 87 size_t get_size() const { return size_; } | |
| 88 const std::vector<FunctionInfo*>& get_stack() const { return stack_; } | |
| 89 | |
| 90 private: | |
| 91 static void OnWeakCallback(const WeakCallbackInfo<SampledAllocation>& data); | |
| 92 | |
| 93 SamplingHeapProfiler* const sampling_heap_profiler_; | |
| 94 Global<Value> global_; | |
| 95 std::vector<FunctionInfo*> stack_; | |
| 96 const size_t size_; | |
| 97 | |
| 98 DISALLOW_COPY_AND_ASSIGN(SampledAllocation); | |
| 99 }; | |
| 100 | |
| 101 private: | |
| 102 using Node = v8::AllocationProfile::Node; | |
| 103 | |
| 104 Heap* heap() const { return heap_; } | |
| 105 | |
| 106 void SampleObject(Address soon_object, size_t size); | |
| 107 | |
| 108 static intptr_t GetNextSampleInterval(base::RandomNumberGenerator* random, | |
| 109 uint64_t rate); | |
| 110 | |
| 111 // Methods that construct v8::AllocationProfile. | |
| 112 Node* AddStack(AllocationProfile* profile, | |
| 113 const std::map<int, Script*>& scripts, | |
| 114 const std::vector<FunctionInfo*>& stack); | |
| 115 Node* FindOrAddChildNode(AllocationProfile* profile, | |
| 116 const std::map<int, Script*>& scripts, Node* parent, | |
| 117 FunctionInfo* function_info); | |
| 118 Node* AllocateNode(AllocationProfile* profile, | |
| 119 const std::map<int, Script*>& scripts, | |
| 120 FunctionInfo* function_info); | |
| 121 | |
| 122 Isolate* const isolate_; | |
| 123 Heap* const heap_; | |
| 124 base::RandomNumberGenerator* const random_; | |
| 125 StringsStorage* const names_; | |
| 126 std::set<SampledAllocation*> samples_; | |
| 127 const uint64_t rate_; | |
| 128 const int stack_depth_; | |
| 129 }; | |
| 130 | |
| 131 | |
| 132 } // namespace internal | |
| 133 } // namespace v8 | |
| 134 | |
| 135 #endif // V8_PROFILER_SAMPLING_HEAP_PROFILER_H_ | |
| OLD | NEW |