Line data Source code
1 : /**
2 : * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 :
11 : #ifndef CORE_AICPUSD_MONITOR_H
12 : #define CORE_AICPUSD_MONITOR_H
13 :
14 : #include <map>
15 : #include <atomic>
16 : #include <mutex>
17 : #include <functional>
18 : #include <string>
19 : #include <memory>
20 : #include <thread>
21 : #include <sstream>
22 : #include <semaphore.h>
23 : #include <vector>
24 : #include "aicpusd_status.h"
25 : #include "aicpu_timer.h"
26 : #include "profiling_adp.h"
27 : #include "aicpusd_common.h"
28 :
29 : namespace AicpuSchedule {
30 : class TaskTimer {
31 : public:
32 30758 : TaskTimer() : startTick(0UL), runFlag(false), timeInTick(0UL) {}
33 1027 : TaskTimer(const uint64_t tick, const bool isRun) : startTick(tick), runFlag(isRun), timeInTick(0UL) {}
34 : ~TaskTimer() = default;
35 :
36 10280 : inline uint64_t GetStartTick() const { return startTick.load(); };
37 6165 : inline bool GetRunFlag() const { return runFlag.load(); };
38 135 : inline void SetStartTick(const uint64_t tick) { startTick = tick; };
39 269 : inline void SetRunFlag(const bool isRun) { runFlag = isRun; };
40 2 : inline void SetTimeTick(const uint32_t timeS) { timeInTick = timeS * aicpu::GetSystemTickFreq(); };
41 2 : inline uint64_t GetTimeTick() const { return timeInTick; };
42 :
43 : private:
44 : std::atomic<uint64_t> startTick;
45 : std::atomic<bool> runFlag;
46 : std::atomic<uint64_t> timeInTick;
47 : };
48 :
49 : struct TaskInfoForMonitor {
50 : uint64_t serialNo;
51 : uint64_t taskId;
52 : uint32_t streamId;
53 : bool isHwts;
54 : };
55 :
56 : class MonitorDebug {
57 : public:
58 1 : static std::string MonitorDebugString(const TaskInfoForMonitor& monitor)
59 : {
60 1 : std::ostringstream oss;
61 1 : oss << "serialNo=" << monitor.serialNo << ", stream_id=" << monitor.streamId << ", task_id=" << monitor.taskId;
62 2 : return oss.str();
63 1 : }
64 : };
65 :
66 : class AicpuMonitor {
67 : public:
68 : static AicpuMonitor& GetInstance();
69 :
70 : int32_t InitMonitor(const uint32_t devId, const bool isOnline);
71 :
72 : void SetTaskInfo(const uint32_t threadIndex, const TaskInfoForMonitor& taskInfo) const;
73 :
74 : void SetTaskStartTime(const uint32_t taskId);
75 : void SetTaskEndTime(const uint32_t taskId);
76 : void SetAicpuStreamTaskStartTime(const uint32_t taskId);
77 : void SetAicpuStreamTaskEndTime(const uint32_t taskId);
78 : void SetModelStartTime(const uint32_t modelId);
79 : void SetModelEndTime(const uint32_t modelId);
80 : void SetOpTimerStartTime(const aicpu::TimerHandle timerId, const uint32_t timeInS);
81 : void SetOpTimerEndTime(const aicpu::TimerHandle timerId);
82 : uint32_t GetTaskDefaultTimeout() const;
83 : void SendKillMsgToTsd() const;
84 :
85 : void SetOpExecuteTimeOut(const uint32_t timeOutEn, const uint32_t opExecuteTimeOut);
86 : void SetOpTimeoutFlag(const bool flag);
87 10 : void SetCloseMonitorFlag(const bool closeFlag) { closeMonitorFlag_.store(closeFlag); }
88 145 : bool IsMonitorClosed() const { return closeMonitorFlag_.load(); }
89 : int32_t Run();
90 : void StopMonitor();
91 : ~AicpuMonitor();
92 : void DisableModelTimeout();
93 :
94 : private:
95 : AicpuMonitor();
96 :
97 : AicpuMonitor(const AicpuMonitor&) = delete;
98 :
99 : AicpuMonitor& operator=(const AicpuMonitor&) = delete;
100 :
101 : int32_t InitTimer();
102 : int32_t SetTaskTimeoutFlag();
103 : int32_t SetModelTimeoutFlag();
104 : void InitAsyncOpTimer();
105 : static void Work(AicpuMonitor* const monitor);
106 : void HandleTaskTimeout();
107 : void HandleModelTimeout();
108 : void HandleOpTimeout();
109 :
110 : uint32_t deviceId_;
111 : std::atomic<bool> taskTimeoutFlag_;
112 : bool modelTimeoutFlag_;
113 : std::unique_ptr<TaskInfoForMonitor[]> monitorTaskInfo_;
114 :
115 : // aicpu-cust-sd need too
116 : std::mutex mutex_;
117 : std::atomic<bool> done_;
118 : // op execute time out set by ts enable flag
119 : std::mutex setTimeOutMut_;
120 : std::atomic<bool> tsTimeoutEnable_;
121 : // op execute time out value set by ts
122 : std::atomic<uint32_t> tsOpTimeOut_;
123 :
124 : uint64_t taskTimeout_;
125 : std::atomic<uint64_t> taskTimeoutTick_;
126 : uint64_t modelTimeoutTick_;
127 : std::unique_ptr<TaskTimer[]> aicpuTaskTimer_;
128 : std::unique_ptr<TaskTimer[]> aicpuStreamTaskTimer_;
129 : std::unique_ptr<TaskTimer[]> modelTimer_;
130 : std::map<aicpu::TimerHandle, std::shared_ptr<TaskTimer>> opTimer_;
131 :
132 : std::vector<std::thread> th_;
133 : sem_t sem_;
134 : bool running_;
135 : uint32_t aicpuCoreNum_;
136 : bool online_; // true when exist in process mode; false when exist in thread mode
137 : std::atomic<bool> opTimeoutFlag_;
138 : std::mutex opTimerMapMutex_;
139 : std::atomic<bool> closeMonitorFlag_{false};
140 : };
141 : } // namespace AicpuSchedule
142 :
143 : #endif // CORE_AICPUSD_MONITOR_H
|
