Debian Codegraph @

level_zero/experimental/source/tracing/tracing_imp.cpp

raw
1 /*
2 * Copyright (C) 2020-2023 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "level_zero/experimental/source/tracing/tracing_imp.h"
9
10 #include "shared/source/helpers/debug_helpers.h"
11 #include "shared/source/helpers/sleep.h"
12
13 namespace L0 {
14
15 thread_local ze_bool_t tracingInProgress = 0;
16
17 struct APITracerContextImp globalAPITracerContextImp;
18 struct APITracerContextImp *pGlobalAPITracerContextImp = &globalAPITracerContextImp;
19
20 APITracer *APITracer::create() {
21 APITracerImp *tracer = new APITracerImp;
22 tracer->tracingState = disabledState;
23 tracer->tracerFunctions = {};
24 UNRECOVERABLE_IF(tracer == nullptr);
25 return tracer;
26 }
27
28 ze_result_t createAPITracer(zet_context_handle_t hContext, const zet_tracer_exp_desc_t *desc, zet_tracer_exp_handle_t *phTracer) {
29
30 if (!pGlobalAPITracerContextImp->isTracingEnabled()) {
31 return ZE_RESULT_ERROR_UNINITIALIZED;
32 }
33
34 APITracerImp *tracer = static_cast<APITracerImp *>(APITracer::create());
35
36 tracer->tracerFunctions.pUserData = desc->pUserData;
37
38 *phTracer = tracer->toHandle();
39 return ZE_RESULT_SUCCESS;
40 }
41
42 // This destructor will be called only during at-exit processing,
43 // Hence, this function is executing in a single threaded environment,
44 // and requires no mutex.
45 APITracerContextImp::~APITracerContextImp() {
46 std::list<ThreadPrivateTracerData *>::iterator itr = threadTracerDataList.begin();
47 while (itr != threadTracerDataList.end()) {
48 (*itr)->clearThreadTracerDataOnList();
49 itr = threadTracerDataList.erase(itr);
50 }
51 }
52
53 ze_result_t APITracerImp::destroyTracer(zet_tracer_exp_handle_t phTracer) {
54
55 APITracerImp *tracer = static_cast<APITracerImp *>(phTracer);
56
57 ze_result_t result = pGlobalAPITracerContextImp->finalizeDisableImpTracingWait(tracer);
58 if (result == ZE_RESULT_SUCCESS) {
59 delete L0::APITracer::fromHandle(phTracer);
60 }
61 return result;
62 }
63
64 ze_result_t APITracerImp::setPrologues(zet_core_callbacks_t *pCoreCbs) {
65
66 if (this->tracingState != disabledState) {
67 return ZE_RESULT_ERROR_INVALID_ARGUMENT;
68 }
69
70 this->tracerFunctions.corePrologues = *pCoreCbs;
71
72 return ZE_RESULT_SUCCESS;
73 }
74
75 ze_result_t APITracerImp::setEpilogues(zet_core_callbacks_t *pCoreCbs) {
76
77 if (this->tracingState != disabledState) {
78 return ZE_RESULT_ERROR_INVALID_ARGUMENT;
79 }
80
81 this->tracerFunctions.coreEpilogues = *pCoreCbs;
82
83 return ZE_RESULT_SUCCESS;
84 }
85
86 ze_result_t APITracerImp::enableTracer(ze_bool_t enable) {
87 return pGlobalAPITracerContextImp->enableTracingImp(this, enable);
88 }
89
90 void APITracerContextImp::addThreadTracerDataToList(ThreadPrivateTracerData *threadDataP) {
91 std::lock_guard<std::mutex> lock(threadTracerDataListMutex);
92 threadTracerDataList.push_back(threadDataP);
93 }
94
95 void APITracerContextImp::removeThreadTracerDataFromList(ThreadPrivateTracerData *threadDataP) {
96 std::lock_guard<std::mutex> lock(threadTracerDataListMutex);
97 if (threadTracerDataList.empty())
98 return;
99 threadTracerDataList.remove(threadDataP);
100 }
101
102 thread_local ThreadPrivateTracerData myThreadPrivateTracerData;
103
104 ThreadPrivateTracerData::ThreadPrivateTracerData() {
105 isInitialized = false;
106 onList = false;
107 tracerArrayPointer.store(nullptr, std::memory_order_relaxed);
108 }
109
110 ThreadPrivateTracerData::~ThreadPrivateTracerData() {
111 if (onList) {
112 globalAPITracerContextImp.removeThreadTracerDataFromList(this);
113 onList = false;
114 }
115 tracerArrayPointer.store(nullptr, std::memory_order_relaxed);
116 }
117
118 void ThreadPrivateTracerData::removeThreadTracerDataFromList(void) {
119 if (onList) {
120 globalAPITracerContextImp.removeThreadTracerDataFromList(this);
121 onList = false;
122 }
123 tracerArrayPointer.store(nullptr, std::memory_order_relaxed);
124 }
125
126 bool ThreadPrivateTracerData::testAndSetThreadTracerDataInitializedAndOnList(void) {
127 if (!isInitialized) {
128 isInitialized = true;
129 onList = true;
130 globalAPITracerContextImp.addThreadTracerDataToList(&myThreadPrivateTracerData);
131 }
132 return onList;
133 }
134
135 bool APITracerContextImp::isTracingEnabled() { return driverDdiTable.enableTracing; }
136
137 //
138 // Walk the list of per-thread private data structures, testing
139 // whether any of them reference this array.
140 //
141 // Return 1 if a reference is found. Otherwise return 0.
142 //
143 ze_bool_t APITracerContextImp::testForTracerArrayReferences(tracer_array_t *tracerArray) {
144 std::lock_guard<std::mutex> lock(threadTracerDataListMutex);
145 std::list<ThreadPrivateTracerData *>::iterator itr;
146 for (itr = threadTracerDataList.begin();
147 itr != threadTracerDataList.end();
148 itr++) {
149 if ((*itr)->tracerArrayPointer.load(std::memory_order_relaxed) == tracerArray)
150 return 1;
151 }
152 return 0;
153 }
154
155 //
156 // Walk the retiring_tracer_array_list, checking each member of the list for
157 // references by per thread tracer array pointer. Delete and free
158 // each tracer array that has no per-thread references.
159 //
160 // Return the number of entries on the retiring tracer array list.
161 //
162 size_t APITracerContextImp::testAndFreeRetiredTracers() {
163 std::list<tracer_array_t *>::iterator itr = this->retiringTracerArrayList.begin();
164 while (itr != this->retiringTracerArrayList.end()) {
165 tracer_array_t *retiringTracerArray = *itr;
166 itr++;
167 if (testForTracerArrayReferences(retiringTracerArray))
168 continue;
169 this->retiringTracerArrayList.remove(retiringTracerArray);
170 delete[] retiringTracerArray->tracerArrayEntries;
171 delete retiringTracerArray;
172 }
173 return this->retiringTracerArrayList.size();
174 }
175
176 size_t APITracerContextImp::updateTracerArrays() {
177 tracer_array_t *newTracerArray;
178 size_t newTracerArrayCount = this->enabledTracerImpList.size();
179
180 if (newTracerArrayCount != 0) {
181
182 newTracerArray = new tracer_array_t;
183
184 newTracerArray->tracerArrayCount = newTracerArrayCount;
185 newTracerArray->tracerArrayEntries = new tracer_array_entry_t[newTracerArrayCount];
186 //
187 // iterate over the list of enabled tracers, copying their entries into the
188 // new tracer array
189 //
190 size_t i = 0;
191 std::list<struct APITracerImp *>::iterator itr;
192 for (itr = enabledTracerImpList.begin(); itr != enabledTracerImpList.end(); itr++) {
193 newTracerArray->tracerArrayEntries[i] = (*itr)->tracerFunctions;
194 i++;
195 }
196
197 } else {
198 newTracerArray = &emptyTracerArray;
199 }
200 //
201 // active_tracer_array.load can use memory_order_relaxed here because
202 // there is logically no transfer of other memory context between
203 // threads in this case.
204 //
205 tracer_array_t *activeTracerArrayShadow = activeTracerArray.load(std::memory_order_relaxed);
206 if (activeTracerArrayShadow != &emptyTracerArray) {
207 retiringTracerArrayList.push_back(activeTracerArrayShadow);
208 }
209 //
210 // This active_tracer_array.store must use memory_order_release.
211 // This store DOES signal a logical transfer of tracer state information
212 // from this thread to the tracing threads.
213 //
214 activeTracerArray.store(newTracerArray, std::memory_order_release);
215 return testAndFreeRetiredTracers(); // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
216 }
217
218 ze_result_t APITracerContextImp::enableTracingImp(struct APITracerImp *tracerImp, ze_bool_t enable) {
219 std::lock_guard<std::mutex> lock(traceTableMutex);
220 ze_result_t result;
221 switch (tracerImp->tracingState) {
222 case disabledState:
223 if (enable) {
224 enabledTracerImpList.push_back(tracerImp);
225 tracerImp->tracingState = enabledState;
226 updateTracerArrays();
227 }
228 result = ZE_RESULT_SUCCESS;
229 break;
230
231 case enabledState:
232 if (!enable) {
233 enabledTracerImpList.remove(tracerImp);
234 tracerImp->tracingState = disabledWaitingState;
235 if (updateTracerArrays() == 0)
236 tracerImp->tracingState = disabledState;
237 }
238 result = ZE_RESULT_SUCCESS;
239 break;
240
241 case disabledWaitingState:
242 result = ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE;
243 break;
244
245 default:
246 result = ZE_RESULT_ERROR_UNINITIALIZED;
247 UNRECOVERABLE_IF(true);
248 break;
249 }
250 return result;
251 }
252
253 // This is called by the destroy tracer method.
254 //
255 // This routine will return ZE_RESULT_SUCCESS
256 // state if either it has never been enabled,
257 // or if it has been enabled and then disabled.
258 //
259 // On ZE_RESULT_SUCESS, the destroy tracer method
260 // can free the tracer's memory.
261 //
262 // ZE_RESULT_ERROR_UNINITIALIZED is returned
263 // if the tracer has been enabled but not
264 // disabled. The destroy tracer method
265 // should NOT free this tracer's memory.
266 //
267 ze_result_t APITracerContextImp::finalizeDisableImpTracingWait(struct APITracerImp *tracerImp) {
268 std::lock_guard<std::mutex> lock(traceTableMutex);
269 ze_result_t result;
270 switch (tracerImp->tracingState) {
271 case disabledState:
272 result = ZE_RESULT_SUCCESS;
273 break;
274
275 case enabledState:
276 result = ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE;
277 break;
278
279 case disabledWaitingState:
280 while (testAndFreeRetiredTracers() != 0) {
281 NEO::sleep(std::chrono::milliseconds(1));
282 }
283 tracerImp->tracingState = disabledState;
284 result = ZE_RESULT_SUCCESS;
285 break;
286
287 default:
288 result = ZE_RESULT_ERROR_UNINITIALIZED;
289 UNRECOVERABLE_IF(true);
290 break;
291 }
292
293 return result;
294 }
295
296 void *APITracerContextImp::getActiveTracersList() {
297 tracer_array_t *stableTracerArray = nullptr;
298
299 if (!myThreadPrivateTracerData.testAndSetThreadTracerDataInitializedAndOnList()) {
300 return nullptr;
301 }
302
303 do {
304 stableTracerArray = pGlobalAPITracerContextImp->activeTracerArray.load(std::memory_order_acquire);
305 myThreadPrivateTracerData.tracerArrayPointer.store(stableTracerArray, std::memory_order_relaxed);
306 } while (stableTracerArray !=
307 pGlobalAPITracerContextImp->activeTracerArray.load(std::memory_order_relaxed));
308 return (void *)stableTracerArray;
309 }
310
311 void APITracerContextImp::releaseActivetracersList() {
312 if (myThreadPrivateTracerData.testAndSetThreadTracerDataInitializedAndOnList())
313 myThreadPrivateTracerData.tracerArrayPointer.store(nullptr, std::memory_order_relaxed);
314 }
315
316 } // namespace L0