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
32namespace panda {
33namespace ecmascript {
34class EcmaVM;
35class Stream;
36class Progress;
37struct ProfileInfo;
38struct JsFrameInfo;
39struct SamplingInfo;
40struct TraceEvent;
41}
42class DFXJSNApi;
43class JSValueRef;
44template<typename T>
45class Local;
46using EcmaVM = ecmascript::EcmaVM;
47using Stream = ecmascript::Stream;
48using Progress = ecmascript::Progress;
49using ProfileInfo = ecmascript::ProfileInfo;
50using JsFrameInfo = ecmascript::JsFrameInfo;
51using SamplingInfo = ecmascript::SamplingInfo;
52using DebuggerPostTask = std::function<void(std::function<void()> &&)>;
53using TraceEvent = ecmascript::TraceEvent;
54using AppFreezeFilterCallback = std::function<bool(const int32_t pid)>;
55using DumpSnapShotOption = ecmascript::DumpSnapShotOption;
56using DumpFormat = ecmascript::DumpFormat;
57struct DumpForSnapShotStruct {
58    const EcmaVM *vm;
59    DumpSnapShotOption dumpOption;
60};
61
62class PUBLIC_API DFXJSNApi {
63public:
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