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 29732 : 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 5140 : inline uint64_t GetStartTick() const
37 : {
38 10280 : return startTick.load();
39 : };
40 6163 : inline bool GetRunFlag() const
41 : {
42 6163 : return runFlag.load();
43 : };
44 134 : inline void SetStartTick(const uint64_t tick)
45 : {
46 134 : startTick = tick;
47 134 : };
48 264 : inline void SetRunFlag(const bool isRun)
49 : {
50 264 : runFlag = isRun;
51 268 : };
52 2 : inline void SetTimeTick(const uint32_t timeS)
53 : {
54 2 : timeInTick = timeS * aicpu::GetSystemTickFreq();
55 2 : };
56 2 : inline uint64_t GetTimeTick() const
57 : {
58 2 : return timeInTick;
59 : };
60 :
61 : private:
62 : std::atomic<uint64_t> startTick;
63 : std::atomic<bool> runFlag;
64 : std::atomic<uint64_t> timeInTick;
65 : };
66 :
67 : struct TaskInfoForMonitor {
68 : uint64_t serialNo;
69 : uint64_t taskId;
70 : uint32_t streamId;
71 : bool isHwts;
72 : };
73 :
74 : class MonitorDebug {
75 : public:
76 1 : static std::string MonitorDebugString(const TaskInfoForMonitor &monitor)
77 : {
78 1 : std::ostringstream oss;
79 1 : oss << "serialNo=" << monitor.serialNo << ", stream_id=" << monitor.streamId << ", task_id=" << monitor.taskId;
80 2 : return oss.str();
81 1 : }
82 : };
83 :
84 : class AicpuMonitor {
85 : public:
86 : static AicpuMonitor &GetInstance();
87 :
88 : int32_t InitMonitor(const uint32_t devId, const bool isOnline);
89 :
90 : void SetTaskInfo(const uint32_t threadIndex, const TaskInfoForMonitor &taskInfo) const;
91 :
92 : void SetTaskStartTime(const uint32_t taskId);
93 : void SetTaskEndTime(const uint32_t taskId);
94 : void SetAicpuStreamTaskStartTime(const uint32_t taskId);
95 : void SetAicpuStreamTaskEndTime(const uint32_t taskId);
96 : void SetModelStartTime(const uint32_t modelId);
97 : void SetModelEndTime(const uint32_t modelId);
98 : void SetOpTimerStartTime(const aicpu::TimerHandle timerId, const uint32_t timeInS);
99 : void SetOpTimerEndTime(const aicpu::TimerHandle timerId);
100 : uint32_t GetTaskDefaultTimeout() const;
101 : void SendKillMsgToTsd() const;
102 :
103 : void SetOpExecuteTimeOut(const uint32_t timeOutEn, const uint32_t opExecuteTimeOut);
104 : void SetOpTimeoutFlag(const bool flag);
105 : int32_t Run();
106 : void StopMonitor();
107 : ~AicpuMonitor();
108 : void DisableModelTimeout();
109 :
110 : private:
111 : AicpuMonitor();
112 :
113 : AicpuMonitor(const AicpuMonitor &) = delete;
114 :
115 : AicpuMonitor &operator = (const AicpuMonitor &) = delete;
116 :
117 : int32_t InitTimer();
118 : int32_t SetTaskTimeoutFlag();
119 : int32_t SetModelTimeoutFlag();
120 : void InitAsyncOpTimer();
121 : static void Work(AicpuMonitor *const monitor);
122 : void HandleTaskTimeout();
123 : void HandleModelTimeout();
124 : void HandleOpTimeout();
125 :
126 : uint32_t deviceId_;
127 : std::atomic<bool> taskTimeoutFlag_;
128 : bool modelTimeoutFlag_;
129 : std::unique_ptr<TaskInfoForMonitor[]> monitorTaskInfo_;
130 :
131 : // aicpu-cust-sd need too
132 : std::mutex mutex_;
133 : std::atomic<bool> done_;
134 : // op execute time out set by ts enable flag
135 : std::mutex setTimeOutMut_;
136 : std::atomic<bool> tsTimeoutEnable_;
137 : // op execute time out value set by ts
138 : std::atomic<uint32_t> tsOpTimeOut_;
139 :
140 : uint64_t taskTimeout_;
141 : std::atomic<uint64_t> taskTimeoutTick_;
142 : uint64_t modelTimeoutTick_;
143 : std::unique_ptr<TaskTimer[]> aicpuTaskTimer_;
144 : std::unique_ptr<TaskTimer[]> aicpuStreamTaskTimer_;
145 : std::unique_ptr<TaskTimer[]> modelTimer_;
146 : std::map<aicpu::TimerHandle, std::shared_ptr<TaskTimer>> opTimer_;
147 :
148 : std::vector<std::thread> th_;
149 : sem_t sem_;
150 : bool running_;
151 : uint32_t aicpuCoreNum_;
152 : bool online_; // true when exist in process mode; false when exist in thread mode
153 : std::atomic<bool> opTimeoutFlag_;
154 : std::mutex opTimerMapMutex_;
155 : };
156 : }
157 :
158 : #endif // CORE_AICPUSD_MONITOR_H
|
