1 /* 2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ECMASCRIPT_NAPI_INCLUDE_DFX_JSNAPI_H 17 #define ECMASCRIPT_NAPI_INCLUDE_DFX_JSNAPI_H 18 19 #include <cassert> 20 #include <cstdint> 21 #include <functional> 22 #include <memory> 23 #include <string> 24 #include <vector> 25 26 #include "ecmascript/common.h" 27 #include "ecmascript/dfx/hprof/file_stream.h" 28 #include "ecmascript/dfx/hprof/heap_profiler_interface.h" 29 30 #include "libpandabase/macros.h" 31 32 namespace panda { 33 namespace ecmascript { 34 class EcmaVM; 35 class Stream; 36 class Progress; 37 struct ProfileInfo; 38 struct JsFrameInfo; 39 struct SamplingInfo; 40 struct TraceEvent; 41 } 42 class DFXJSNApi; 43 class JSValueRef; 44 template<typename T> 45 class Local; 46 using EcmaVM = ecmascript::EcmaVM; 47 using Stream = ecmascript::Stream; 48 using Progress = ecmascript::Progress; 49 using ProfileInfo = ecmascript::ProfileInfo; 50 using JsFrameInfo = ecmascript::JsFrameInfo; 51 using SamplingInfo = ecmascript::SamplingInfo; 52 using DebuggerPostTask = std::function<void(std::function<void()> &&)>; 53 using TraceEvent = ecmascript::TraceEvent; 54 using AppFreezeFilterCallback = std::function<bool(const int32_t pid)>; 55 using DumpSnapShotOption = ecmascript::DumpSnapShotOption; 56 using DumpFormat = ecmascript::DumpFormat; 57 struct DumpForSnapShotStruct { 58 const EcmaVM *vm; 59 DumpSnapShotOption dumpOption; 60 }; 61 62 class PUBLIC_API DFXJSNApi { 63 public: 64 // progress pointer is used to report the object number for IDE. 65 // isVmMode means the internal class in vm is visible. isPrivate means the number and string is not visible. 66 static void DumpHeapSnapshot(const EcmaVM *vm, const std::string &path, const DumpSnapShotOption &dumpOption); 67 static void DumpHeapSnapshot(const EcmaVM *vm, Stream *stream, const DumpSnapShotOption &dumpOption, 68 Progress *progress = nullptr); 69 static void DumpCpuProfile(const EcmaVM *vm); 70 static void DumpHeapSnapshot(const EcmaVM *vm, const DumpSnapShotOption &dumpOption); 71 static void DumpHeapSnapshot(const EcmaVM *vm, const DumpSnapShotOption &dumpOption, uint32_t tid); 72 static void GenerateHeapSnapshotByBinFile(const EcmaVM *vm, std::string &inputFilePath, std::string &outputPath); 73 static void DumpHeapSnapshotWithVm(const EcmaVM *vm, const DumpSnapShotOption &dumpOption, uint32_t tid); 74 static void TriggerGC(const EcmaVM *vm, uint32_t tid); 75 static void TriggerGCWithVm(const EcmaVM *vm); 76 static void TriggerSharedGCWithVm(const EcmaVM *vm); 77 static void DestroyHeapProfiler(const EcmaVM *vm); 78 79 static bool BuildNativeAndJsStackTrace(const EcmaVM *vm, std::string &stackTraceStr); 80 static bool BuildJsStackTrace(const EcmaVM *vm, std::string &stackTraceStr); 81 static bool StartHeapTracking(const EcmaVM *vm, double timeInterval, bool isVmMode = true, 82 Stream *stream = nullptr, bool traceAllocation = false, bool newThread = true); 83 static bool UpdateHeapTracking(const EcmaVM *vm, Stream *stream); 84 static bool StopHeapTracking(const EcmaVM *vm, const std::string &filePath, bool newThread = true); 85 static bool StopHeapTracking(const EcmaVM *vm, Stream *stream, Progress *progress = nullptr, bool newThread = true); 86 static void PrintStatisticResult(const EcmaVM *vm); 87 static void StartRuntimeStat(EcmaVM *vm); 88 static void StopRuntimeStat(EcmaVM *vm); 89 static size_t GetArrayBufferSize(const EcmaVM *vm); 90 static size_t GetHeapTotalSize(const EcmaVM *vm); 91 // GetHeapUsedSize only support running on vm thread and provide an accurate value. 92 // GetHeapObjectSize provide a rough estimate. 93 static size_t GetHeapUsedSize(const EcmaVM *vm); 94 static size_t GetHeapObjectSize(const EcmaVM *vm); 95 static size_t GetHeapLimitSize(const EcmaVM *vm); 96 static size_t GetProcessHeapLimitSize(); 97 static size_t GetGCCount(const EcmaVM *vm); 98 static size_t GetGCDuration(const EcmaVM *vm); 99 static size_t GetAccumulatedAllocateSize(const EcmaVM *vm); 100 static size_t GetAccumulatedFreeSize(const EcmaVM *vm); 101 static size_t GetFullGCLongTimeCount(const EcmaVM *vm); 102 static void GetHeapPrepare(const EcmaVM *vm); 103 static void NotifyApplicationState(EcmaVM *vm, bool inBackground); 104 static void NotifyIdleStatusControl(const EcmaVM *vm, std::function<void(bool)> callback); 105 static void NotifyIdleTime(const EcmaVM *vm, int idleMicroSec); 106 static void NotifyMemoryPressure(EcmaVM *vm, bool inHighMemoryPressure); 107 static void NotifyFinishColdStart(EcmaVM *vm, bool isConvinced); 108 static void NotifyHighSensitive(EcmaVM *vm, bool isStart); 109 static bool BuildJsStackInfoList(const EcmaVM *hostVm, uint32_t tid, std::vector<JsFrameInfo>& jsFrames); 110 static int32_t GetObjectHash(const EcmaVM *vm, Local<JSValueRef> nativeObject); 111 112 // cpuprofiler 113 static bool StopCpuProfilerForColdStart(const EcmaVM *vm); 114 static bool CpuProfilerSamplingAnyTime(const EcmaVM *vm); 115 static void CpuProfilerAnyTimeMainThread(const EcmaVM *vm); 116 static void SetJsDumpThresholds(EcmaVM *vm, size_t thresholds); 117 static void SetAppFreezeFilterCallback(const EcmaVM *vm, AppFreezeFilterCallback cb); 118 static bool StartCpuProfilerForFile(const EcmaVM *vm, const std::string &fileName, 119 int interval = 500); // 500:Default Sampling interval 500 microseconds 120 static void StopCpuProfilerForFile(const EcmaVM *vm); 121 static bool StartCpuProfilerForInfo(const EcmaVM *vm, 122 int interval = 500); // 500:Default Sampling interval 500 microseconds 123 static std::unique_ptr<ProfileInfo> StopCpuProfilerForInfo(const EcmaVM *vm); 124 static void EnableSeriliazationTimeoutCheck(const EcmaVM *ecmaVM, int32_t threshhold); 125 static void DisableSeriliazationTimeoutCheck(const EcmaVM *ecmaVM); 126 127 enum class PUBLIC_API ProfilerType : uint8_t { CPU_PROFILER, HEAP_PROFILER }; 128 129 struct ProfilerOption { 130 const char *libraryPath; 131 int interval = 500; // 500:Default Sampling interval 500 microseconds 132 ProfilerType profilerType = ProfilerType::CPU_PROFILER; 133 }; 134 // To be compatible with old process. 135 static bool StartProfiler(EcmaVM *vm, const ProfilerOption &option, int tid, 136 int32_t instanceId, const DebuggerPostTask &debuggerPostTask, bool isDebugApp); 137 static void SetCpuSamplingInterval(const EcmaVM *vm, int interval); 138 static bool StartSampling(const EcmaVM *vm, uint64_t samplingInterval); 139 static const SamplingInfo *GetAllocationProfile(const EcmaVM *vm); 140 static void StopSampling(const EcmaVM *vm); 141 142 static void ResumeVM(const EcmaVM *vm); 143 static bool SuspendVM(const EcmaVM *vm); 144 static bool IsSuspended(const EcmaVM *vm); 145 static void TerminateExecution(const EcmaVM *vm); 146 static bool CheckSafepoint(const EcmaVM *vm); 147 static void ResumeVMById(EcmaVM *vm, uint32_t tid); 148 static bool SuspendVMById(EcmaVM *vm, uint32_t tid); 149 150 // tracing 151 static bool StartTracing(const EcmaVM *vm, std::string &categories); 152 static std::unique_ptr<std::vector<TraceEvent>> StopTracing(const EcmaVM *vm); 153 static void GetTracingBufferUseage(const EcmaVM *vm, double &percentFull, uint32_t &eventCount, double &value); 154 static void TranslateJSStackInfo(const EcmaVM *vm, std::string &url, int32_t &line, int32_t &column); 155 156 static uint32_t GetCurrentThreadId(); 157 }; 158 } 159 #endif