Debian Codegraph @

media_softlet/agnostic/common/shared/profiler/media_perf_profiler.cpp

raw
1 /*
2 * Copyright (c) 2021-2023, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file media_perf_profiler.cpp
24 //! \brief Defines data structures and interfaces for media performance profiler.
25 //! \details
26 //!
27
28 #include <stddef.h>
29 #include "media_perf_profiler.h"
30 #include "media_skuwa_specific.h"
31 #include "mhw_itf.h"
32 #include "mhw_mi.h"
33 #include "mhw_mi_cmdpar.h"
34 #include "mhw_mi_itf.h"
35 #include "mos_resource_defs.h"
36 #include "mos_util_debug.h"
37 #include "mos_utilities.h"
38 #include "mos_utilities_common.h"
39
40 #define UMD_PERF_LOG 8
41 #define NAME_LEN 60
42 #define LOCAL_STRING_SIZE 64
43 #define OFFSET_OF(TYPE, MEMBER) ((size_t) & ((TYPE *)0)->MEMBER )
44
45 typedef enum _UMD_PERF_MODE
46 {
47 UMD_PERF_MODE_TIMING_ONLY = 0,
48 UMD_PERF_MODE_WITH_MEMORY_INFO = 4
49 } UMD_PERF_MODE;
50
51 #pragma pack(push)
52 #pragma pack(8)
53 struct PerfEntry
54 {
55 uint32_t nodeIndex; //!< Perf node index
56 uint32_t processId; //!< Process Id
57 uint32_t instanceId; //!< Instance Id
58 uint32_t engineTag; //!< Engine tag
59 uint32_t perfTag; //!< Performance tag
60 uint32_t timeStampBase; //!< HW timestamp base
61 uint32_t beginRegisterValue[8]; //!< Begin register value
62 uint32_t endRegisterValue[8]; //!< End register value
63 uint32_t beginCpuTime[2]; //!< Begin CPU Time Stamp
64 uint32_t bitstreamSize; //!< frame level: bitstreamSize
65 uint32_t SSEY; //!< frame level: SSEY
66 uint32_t SSEU; //!< frame level: SSEU
67 uint32_t SSEV; //!< frame level: SSEV
68 union
69 {
70 uint32_t DWMeanSsimLayer1_YU;
71 struct
72 {
73 uint32_t MeanSsimLayer1_Y : 12, // [11:0]
74 DW3_Res_15_12 : 4, // [15:12]
75 MeanSsimLayer1_U : 12, // [27:16]
76 DW3_Res_31_18 : 4; // [31:28]
77 };
78 };
79 union
80 {
81 uint32_t DWMeanSsimLayer1_V;
82 struct
83 {
84 uint32_t MeanSsimLayer1_V : 12, // [11:0]
85 DW4_Res_15_12 : 4, // [15:12]
86 MeanSsimLayer1Part_Y : 12, // [27:16]
87 DW4_Res_31_18 : 4; // [31:28]
88 };
89 };
90 uint32_t reserved[8]; //!< Reserved[8]
91 uint64_t beginTimeClockValue; //!< Begin timestamp
92 uint64_t endTimeClockValue; //!< End timestamp
93 };
94 #pragma pack(pop)
95
96 struct NodeHeader
97 {
98 uint32_t osPlatform : 3;
99 uint32_t genPlatform : 3;
100 uint32_t eventType : 4;
101 uint32_t perfMode : 3;
102 uint32_t genAndroid : 4;
103 uint32_t genPlatform_ext : 2;
104 uint32_t reserved : 13;
105 };
106
107 #define BASE_OF_NODE(perfDataIndex) (sizeof(NodeHeader) + (sizeof(PerfEntry) * perfDataIndex))
108
109 #define CHK_STATUS_RETURN(_stmt) \
110 { \
111 MOS_STATUS stmtStatus = (MOS_STATUS)(_stmt); \
112 if (stmtStatus != MOS_STATUS_SUCCESS) \
113 { \
114 return stmtStatus; \
115 } \
116 }
117
118 #define CHK_NULL_RETURN(_ptr) \
119 { \
120 if ((_ptr) == nullptr) \
121 { \
122 return MOS_STATUS_NULL_POINTER; \
123 } \
124 }
125
126 #define CHK_NULL_NO_STATUS_RETURN(_ptr) \
127 { \
128 if ((_ptr) == nullptr) \
129 { \
130 return; \
131 } \
132 }
133
134 #define CHK_STATUS_UNLOCK_MUTEX_RETURN(_stmt) \
135 { \
136 MOS_STATUS stmtStatus = (MOS_STATUS)(_stmt); \
137 if (stmtStatus != MOS_STATUS_SUCCESS) \
138 { \
139 MosUtilities::MosUnlockMutex(m_mutex); \
140 return stmtStatus; \
141 } \
142 }
143
144 #define CHK_NULL_UNLOCK_MUTEX_RETURN(_ptr) \
145 { \
146 if ((_ptr) == nullptr) \
147 { \
148 MosUtilities::MosUnlockMutex(m_mutex); \
149 return MOS_STATUS_NULL_POINTER; \
150 } \
151 }
152
153 MediaPerfProfiler::MediaPerfProfiler()
154 {
155 m_perfStoreBufferMap.clear();
156 m_perfDataIndexMap.clear();
157 m_refMap.clear();
158 m_initializedMap.clear();
159
160 m_profilerEnabled = 0;
161
162 m_mutex = MosUtilities::MosCreateMutex();
163
164 if (m_mutex)
165 {
166 // m_mutex is destroyed after MemNinja report, this will cause fake memory leak,
167 // the following 2 lines is to circumvent Memninja counter validation and log parser
168 MosUtilities::MosAtomicDecrement(MosUtilities::m_mosMemAllocCounter);
169 MOS_MEMNINJA_FREE_MESSAGE(m_mutex, __FUNCTION__, __FILE__, __LINE__);
170 PRINT_DESTROY_MEMORY(MT_MOS_DESTROY_MEMORY, MT_NORMAL, MT_MEMORY_PTR, (int64_t)(m_mutex), __FUNCTION__, __FILE__, __LINE__);
171 }
172 else
173 {
174 MOS_OS_ASSERTMESSAGE("Create Mutex failed!");
175 }
176 }
177
178 MediaPerfProfiler::~MediaPerfProfiler()
179 {
180 if (m_mutex != nullptr)
181 {
182 MosUtilities::MosDestroyMutex(m_mutex);
183 m_mutex = nullptr;
184 }
185 }
186
187 MediaPerfProfiler* MediaPerfProfiler::Instance()
188 {
189 static MediaPerfProfiler instance;
190 if (!instance.m_mutex && instance.m_profilerEnabled)
191 {
192 MOS_OS_ASSERTMESSAGE("Create MediaPerfProfiler failed!");
193 return nullptr;
194 }
195 else
196 {
197 return &instance;
198 }
199 }
200
201 void MediaPerfProfiler::Destroy(MediaPerfProfiler* profiler, void* context, MOS_INTERFACE *osInterface)
202 {
203 PERF_UTILITY_PRINT;
204
205 CHK_NULL_NO_STATUS_RETURN(profiler);
206 CHK_NULL_NO_STATUS_RETURN(osInterface);
207
208 if (profiler->m_profilerEnabled == 0 || profiler->m_mutex == nullptr)
209 {
210 return;
211 }
212
213 PMOS_CONTEXT pOsContext = osInterface->pOsContext;
214 CHK_NULL_NO_STATUS_RETURN(pOsContext);
215 MosUtilities::MosLockMutex(profiler->m_mutex);
216 if (profiler->m_refMap[pOsContext] > 0)
217 {
218 profiler->m_refMap[pOsContext]--;
219 }
220 osInterface->pfnWaitAllCmdCompletion(osInterface);
221
222 profiler->m_contextIndexMap.erase(context);
223
224 if (profiler->m_refMap[pOsContext] == 0)
225 {
226 if (profiler->m_initializedMap[pOsContext] == true)
227 {
228 if(profiler->m_enableProfilerDump)
229 {
230 profiler->SavePerfData(osInterface);
231 }
232
233 osInterface->pfnFreeResource(
234 osInterface,
235 profiler->m_perfStoreBufferMap[pOsContext]);
236
237 MOS_FreeMemAndSetNull(profiler->m_perfStoreBufferMap[pOsContext]);
238
239 profiler->m_perfStoreBufferMap.erase(pOsContext);
240 profiler->m_initializedMap.erase(pOsContext);
241 profiler->m_refMap.erase(pOsContext);
242 profiler->m_perfDataIndexMap.erase(pOsContext);
243 }
244
245 MosUtilities::MosUnlockMutex(profiler->m_mutex);
246 }
247 else
248 {
249 MosUtilities::MosUnlockMutex(profiler->m_mutex);
250 }
251 }
252
253 MOS_STATUS MediaPerfProfiler::Initialize(void* context, MOS_INTERFACE *osInterface)
254 {
255 MOS_STATUS status = MOS_STATUS_SUCCESS;
256 CHK_NULL_RETURN(osInterface);
257 CHK_NULL_RETURN(m_mutex);
258
259 PMOS_CONTEXT pOsContext = osInterface->pOsContext;
260 CHK_NULL_RETURN(pOsContext);
261 MediaUserSettingSharedPtr userSettingPtr = osInterface->pfnGetUserSettingInstance(osInterface);
262 // Check whether profiler is enabled
263 ReadUserSetting(
264 userSettingPtr,
265 m_profilerEnabled,
266 __MEDIA_USER_FEATURE_VALUE_PERF_PROFILER_ENABLE,
267 MediaUserSetting::Group::Device);
268
269 if (m_profilerEnabled == 0 || m_mutex == nullptr)
270 {
271 return MOS_STATUS_SUCCESS;
272 }
273
274 MosUtilities::MosLockMutex(m_mutex);
275
276 m_contextIndexMap[context] = 0;
277
278 if (m_initializedMap[pOsContext] == true)
279 {
280 MosUtilities::MosUnlockMutex(m_mutex);
281 return status;
282 }
283
284 m_refMap[pOsContext]++;
285
286 m_enableProfilerDump = MosUtilities::MosIsProfilerDumpEnabled();
287
288 // Read output file name
289 status = ReadUserSetting(
290 userSettingPtr,
291 m_outputFileName,
292 __MEDIA_USER_FEATURE_VALUE_PERF_PROFILER_OUTPUT_FILE_NAME,
293 MediaUserSetting::Group::Device);
294 if (status != MOS_STATUS_SUCCESS)
295 {
296 MosUtilities::MosUnlockMutex(m_mutex);
297 return status;
298 }
299
300 // Read buffer size
301 ReadUserSetting(
302 userSettingPtr,
303 m_bufferSize,
304 __MEDIA_USER_FEATURE_VALUE_PERF_PROFILER_BUFFER_SIZE_KEY,
305 MediaUserSetting::Group::Device);
306
307 m_timerBase = osInterface->pfnGetTsFrequency(osInterface);
308
309 // Read multi processes support
310 ReadUserSetting(
311 userSettingPtr,
312 m_multiprocess,
313 __MEDIA_USER_FEATURE_VALUE_PERF_PROFILER_ENABLE_MUL_PROC,
314 MediaUserSetting::Group::Device);
315
316 // Read multi header support
317 ReadUserSetting(
318 userSettingPtr,
319 m_mergeheader,
320 __MEDIA_USER_FEATURE_VALUE_PERF_PROFILER_ENABLE_MER_HEADER,
321 MediaUserSetting::Group::Device);
322
323 // Read parallel execution support
324 bool addPid = false;
325 ReadUserSetting(
326 userSettingPtr,
327 addPid,
328 __MEDIA_USER_FEATURE_VALUE_PERF_PROFILER_PARALLEL_EXEC,
329 MediaUserSetting::Group::Device);
330
331 if (addPid)
332 {
333 m_outputFileName += "-" + std::to_string(MosUtilities::MosGetPid());
334 }
335 // Read memory information register address
336 int8_t regIndex = 0;
337 for (regIndex = 0; regIndex < 8; regIndex++)
338 {
339 ReadUserSetting(
340 userSettingPtr,
341 m_registers[regIndex],
342 m_registersKey[regIndex],
343 MediaUserSetting::Group::Device);
344 }
345
346 // Read multi processes single binary flag
347 ReadUserSetting(
348 userSettingPtr,
349 m_multiprocesssinglebin,
350 __MEDIA_USER_FEATURE_VALUE_PERF_PROFILER_MUL_PROC_SINGLE_BIN,
351 MediaUserSetting::Group::Device);
352
353 PMOS_RESOURCE pPerfStoreBuffer = (PMOS_RESOURCE)MOS_AllocAndZeroMemory(sizeof(MOS_RESOURCE));
354 m_perfStoreBufferMap[pOsContext] = pPerfStoreBuffer;
355 // Allocate the buffer which store the performance data
356 MOS_ALLOC_GFXRES_PARAMS allocParams;
357 MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
358 allocParams.Type = MOS_GFXRES_BUFFER;
359 allocParams.TileType = MOS_TILE_LINEAR;
360 allocParams.Format = Format_Buffer;
361 allocParams.dwBytes = m_bufferSize;
362 allocParams.pBufName = "PerfStoreBuffer";
363
364 status = osInterface->pfnAllocateResource(
365 osInterface,
366 &allocParams,
367 pPerfStoreBuffer);
368
369 CHK_STATUS_UNLOCK_MUTEX_RETURN(status);
370
371 CHK_STATUS_UNLOCK_MUTEX_RETURN(
372 osInterface->pfnSkipResourceSync(pPerfStoreBuffer));
373
374 PLATFORM platform = { IGFX_UNKNOWN };
375 osInterface->pfnGetPlatform(osInterface, &platform);
376
377 MOS_LOCK_PARAMS lockFlags;
378 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
379 lockFlags.WriteOnly = 1;
380
381 NodeHeader* header = (NodeHeader*)osInterface->pfnLockResource(
382 osInterface,
383 pPerfStoreBuffer,
384 &lockFlags);
385
386 CHK_NULL_UNLOCK_MUTEX_RETURN(header);
387
388 // Append the header info
389 MOS_ZeroMemory(header, m_bufferSize);
390 header->eventType = UMD_PERF_LOG;
391
392 uint32_t mappedPlatFormId = PlatFormIdMap(platform);
393 header->genPlatform = (mappedPlatFormId - 8) & 0x7;
394 header->genPlatform_ext = ((mappedPlatFormId - 8) >> 3) & 0x3;
395
396 if (IsPerfModeWidthMemInfo(m_registers))
397 {
398 header->perfMode = UMD_PERF_MODE_WITH_MEMORY_INFO;
399 }
400 else
401 {
402 header->perfMode = UMD_PERF_MODE_TIMING_ONLY;
403 }
404
405 osInterface->pfnUnlockResource(
406 osInterface,
407 pPerfStoreBuffer);
408
409 m_initializedMap[pOsContext] = true;
410
411 MosUtilities::MosUnlockMutex(m_mutex);
412
413 return MOS_STATUS_SUCCESS;
414 }
415
416 MOS_STATUS MediaPerfProfiler::StoreData(
417 std::shared_ptr<mhw::mi::Itf> miItf,
418 PMOS_COMMAND_BUFFER cmdBuffer,
419 MOS_CONTEXT_HANDLE pOsContext,
420 uint32_t offset,
421 uint32_t value)
422 {
423 CHK_NULL_RETURN(miItf);
424
425 auto& storeDataParams = miItf->MHW_GETPAR_F(MI_STORE_DATA_IMM)();
426 storeDataParams = {};
427 storeDataParams.pOsResource = m_perfStoreBufferMap[(PMOS_CONTEXT)pOsContext];
428 storeDataParams.dwResourceOffset = offset;
429 storeDataParams.dwValue = value;
430 CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_STORE_DATA_IMM)(cmdBuffer));
431
432 return MOS_STATUS_SUCCESS;
433 }
434
435 MOS_STATUS MediaPerfProfiler::StoreRegister(
436 MOS_INTERFACE *osInterface,
437 std::shared_ptr<mhw::mi::Itf> miItf,
438 PMOS_COMMAND_BUFFER cmdBuffer,
439 uint32_t offset,
440 uint32_t reg)
441 {
442 CHK_NULL_RETURN(osInterface);
443 CHK_NULL_RETURN(miItf);
444
445 auto& storeRegMemParams = miItf->MHW_GETPAR_F(MI_STORE_REGISTER_MEM)();
446 storeRegMemParams = {};
447 storeRegMemParams.presStoreBuffer = m_perfStoreBufferMap[osInterface->pOsContext];
448 storeRegMemParams.dwOffset = offset;
449 storeRegMemParams.dwRegister = reg;
450
451 MEDIA_FEATURE_TABLE* skuTable = osInterface->pfnGetSkuTable(osInterface);
452 if(skuTable && MEDIA_IS_SKU(skuTable, FtrMemoryRemapSupport))
453 {
454 storeRegMemParams.dwOption = CCS_HW_FRONT_END_MMIO_REMAP;
455 }
456
457 CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_STORE_REGISTER_MEM)(cmdBuffer));
458
459 return MOS_STATUS_SUCCESS;
460 }
461
462 MOS_STATUS MediaPerfProfiler::StoreTSByPipeCtrl(
463 std::shared_ptr<mhw::mi::Itf> miItf,
464 PMOS_COMMAND_BUFFER cmdBuffer,
465 MOS_CONTEXT_HANDLE pOsContext,
466 uint32_t offset)
467 {
468 CHK_NULL_RETURN(miItf);
469
470 auto& PipeControlParams = miItf->MHW_GETPAR_F(PIPE_CONTROL)();
471 PipeControlParams = {};
472 PipeControlParams.dwResourceOffset = offset;
473 PipeControlParams.dwPostSyncOp = MHW_FLUSH_WRITE_TIMESTAMP_REG;
474 PipeControlParams.dwFlushMode = MHW_FLUSH_READ_CACHE;
475 PipeControlParams.presDest = m_perfStoreBufferMap[(PMOS_CONTEXT)pOsContext];
476
477 CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(PIPE_CONTROL)(cmdBuffer));
478
479 return MOS_STATUS_SUCCESS;
480 }
481
482 MOS_STATUS MediaPerfProfiler::StoreTSByMiFlush(
483 std::shared_ptr<mhw::mi::Itf> miItf,
484 PMOS_COMMAND_BUFFER cmdBuffer,
485 MOS_CONTEXT_HANDLE pOsContext,
486 uint32_t offset)
487 {
488 CHK_NULL_RETURN(miItf);
489
490 auto& FlushDwParams = miItf->MHW_GETPAR_F(MI_FLUSH_DW)();
491 FlushDwParams = {};
492 FlushDwParams.postSyncOperation = MHW_FLUSH_WRITE_TIMESTAMP_REG;
493 FlushDwParams.dwResourceOffset = offset;
494 FlushDwParams.pOsResource = m_perfStoreBufferMap[(PMOS_CONTEXT)pOsContext];
495
496 CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_FLUSH_DW)(cmdBuffer));
497
498 return MOS_STATUS_SUCCESS;
499 }
500
501 MOS_STATUS MediaPerfProfiler::AddPerfCollectStartCmd(
502 void *context,
503 MOS_INTERFACE *osInterface,
504 std::shared_ptr<mhw::mi::Itf> miItf,
505 MOS_COMMAND_BUFFER *cmdBuffer)
506 {
507 MOS_STATUS status = MOS_STATUS_SUCCESS;
508
509 CHK_NULL_RETURN(osInterface);
510 CHK_NULL_RETURN(miItf);
511 CHK_NULL_RETURN(cmdBuffer);
512 CHK_NULL_RETURN(m_mutex);
513
514 PMOS_CONTEXT pOsContext = osInterface->pOsContext;
515 CHK_NULL_RETURN(pOsContext);
516
517 if (m_profilerEnabled == 0 || m_initializedMap[pOsContext] == false)
518 {
519 return status;
520 }
521
522 uint32_t perfDataIndex = 0;
523
524 MosUtilities::MosLockMutex(m_mutex);
525
526 perfDataIndex = m_perfDataIndexMap[pOsContext];
527 m_perfDataIndexMap[pOsContext]++;
528 m_contextIndexMap[context] = perfDataIndex;
529
530 MosUtilities::MosUnlockMutex(m_mutex);
531
532 bool rcsEngineUsed = false;
533 MOS_GPU_CONTEXT gpuContext;
534
535 gpuContext = osInterface->pfnGetGpuContext(osInterface);
536 rcsEngineUsed = MOS_RCS_ENGINE_USED(gpuContext);
537
538 if (m_multiprocess)
539 {
540 CHK_STATUS_RETURN(StoreData(
541 miItf,
542 cmdBuffer,
543 pOsContext,
544 BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, processId),
545 MosUtilities::MosGetPid()));
546 }
547
548 CHK_STATUS_RETURN(StoreData(
549 miItf,
550 cmdBuffer,
551 pOsContext,
552 BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, perfTag),
553 osInterface->pfnGetPerfTag(osInterface)));
554
555 CHK_STATUS_RETURN(StoreData(
556 miItf,
557 cmdBuffer,
558 pOsContext,
559 BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, engineTag),
560 GpuContextToGpuNode(gpuContext)));
561
562 if (m_timerBase != 0)
563 {
564 CHK_STATUS_RETURN(StoreData(
565 miItf,
566 cmdBuffer,
567 pOsContext,
568 BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, timeStampBase),
569 m_timerBase));
570 }
571
572 int8_t regIndex = 0;
573 for (regIndex = 0; regIndex < 8; regIndex++)
574 {
575 if (m_registers[regIndex] != 0)
576 {
577 CHK_STATUS_RETURN(StoreRegister(
578 osInterface,
579 miItf,
580 cmdBuffer,
581 BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, beginRegisterValue[regIndex]),
582 m_registers[regIndex]));
583 }
584 }
585
586 uint64_t beginCPUTimestamp = MosUtilities::MosGetCurTime();
587 uint32_t timeStamp[2];
588 MOS_SecureMemcpy(timeStamp, 2*sizeof(uint32_t), &beginCPUTimestamp, 2*sizeof(uint32_t));
589
590 for (int i = 0; i < 2; i++)
591 {
592 CHK_STATUS_RETURN(StoreData(
593 miItf,
594 cmdBuffer,
595 pOsContext,
596 BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, beginCpuTime[i]),
597 timeStamp[i]));
598 }
599
600 // The address of timestamp must be 8 bytes aligned.
601 uint32_t offset = BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, beginTimeClockValue);
602 offset = MOS_ALIGN_CEIL(offset, 8);
603
604 if (rcsEngineUsed)
605 {
606 CHK_STATUS_RETURN(StoreTSByPipeCtrl(
607 miItf,
608 cmdBuffer,
609 pOsContext,
610 offset));
611 }
612 else
613 {
614 CHK_STATUS_RETURN(StoreTSByMiFlush(
615 miItf,
616 cmdBuffer,
617 pOsContext,
618 offset));
619 }
620
621 return status;
622 }
623
624 MOS_STATUS MediaPerfProfiler::AddPerfCollectEndCmd(
625 void *context,
626 MOS_INTERFACE *osInterface,
627 std::shared_ptr<mhw::mi::Itf> miItf,
628 MOS_COMMAND_BUFFER *cmdBuffer)
629 {
630 MOS_STATUS status = MOS_STATUS_SUCCESS;
631
632 CHK_NULL_RETURN(osInterface);
633 CHK_NULL_RETURN(miItf);
634 CHK_NULL_RETURN(cmdBuffer);
635
636 PMOS_CONTEXT pOsContext = osInterface->pOsContext;
637 CHK_NULL_RETURN(pOsContext);
638
639 if (m_profilerEnabled == 0 || m_initializedMap[pOsContext] == false)
640 {
641 return status;
642 }
643
644 MOS_GPU_CONTEXT gpuContext;
645 bool rcsEngineUsed = false;
646 uint32_t perfDataIndex = 0;
647
648 gpuContext = osInterface->pfnGetGpuContext(osInterface);
649 rcsEngineUsed = MOS_RCS_ENGINE_USED(gpuContext);
650
651 perfDataIndex = m_contextIndexMap[context];
652
653 int8_t regIndex = 0;
654 for (regIndex = 0; regIndex < 8; regIndex++)
655 {
656 if (m_registers[regIndex] != 0)
657 {
658 CHK_STATUS_RETURN(StoreRegister(
659 osInterface,
660 miItf,
661 cmdBuffer,
662 BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, endRegisterValue[regIndex]),
663 m_registers[regIndex]));
664 }
665 }
666
667 // The address of timestamp must be 8 bytes aligned.
668 uint32_t offset = BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, endTimeClockValue);
669 offset = MOS_ALIGN_CEIL(offset, 8);
670
671 if (rcsEngineUsed)
672 {
673 CHK_STATUS_RETURN(StoreTSByPipeCtrl(
674 miItf,
675 cmdBuffer,
676 pOsContext,
677 offset));
678 }
679 else
680 {
681 CHK_STATUS_RETURN(StoreTSByMiFlush(
682 miItf,
683 cmdBuffer,
684 pOsContext,
685 offset));
686 }
687
688 return status;
689 }
690
691 MOS_STATUS MediaPerfProfiler::AddStoreBitstreamSizeCmd(
692 void *context,
693 MOS_INTERFACE *osInterface,
694 std::shared_ptr<mhw::mi::Itf>& miItf,
695 MOS_COMMAND_BUFFER *cmdBuffer,
696 uint32_t reg)
697 {
698 MOS_STATUS status = MOS_STATUS_SUCCESS;
699
700 CHK_NULL_RETURN(context);
701 CHK_NULL_RETURN(osInterface);
702 CHK_NULL_RETURN(miItf);
703 CHK_NULL_RETURN(cmdBuffer);
704
705 PMOS_CONTEXT pOsContext = osInterface->pOsContext;
706 CHK_NULL_RETURN(pOsContext);
707
708 if (m_profilerEnabled == 0 || m_initializedMap[pOsContext] == false)
709 {
710 return status;
711 }
712
713 uint32_t perfDataIndex = m_contextIndexMap[context];
714
715 CHK_STATUS_RETURN(StoreRegister(
716 osInterface,
717 miItf,
718 cmdBuffer,
719 BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, bitstreamSize),
720 reg));
721
722 return status;
723 }
724
725 MOS_STATUS MediaPerfProfiler::CopyMemData(
726 std::shared_ptr<mhw::mi::Itf>& miItf,
727 PMOS_COMMAND_BUFFER cmdBuffer,
728 MOS_CONTEXT_HANDLE pOsContext,
729 PMOS_RESOURCE presSrc,
730 uint32_t dwSrcOffset,
731 uint32_t dwDstOffset)
732 {
733 CHK_NULL_RETURN(miItf);
734
735 auto &miCpyMemMemParams = miItf->MHW_GETPAR_F(MI_COPY_MEM_MEM)();
736 miCpyMemMemParams = {};
737
738 miCpyMemMemParams.presSrc = presSrc;
739 miCpyMemMemParams.dwSrcOffset = dwSrcOffset;
740 miCpyMemMemParams.presDst = m_perfStoreBufferMap[(PMOS_CONTEXT)pOsContext];
741 miCpyMemMemParams.dwDstOffset = dwDstOffset;
742 CHK_STATUS_RETURN(miItf->MHW_ADDCMD_F(MI_COPY_MEM_MEM)(cmdBuffer));
743
744 return MOS_STATUS_SUCCESS;
745 }
746
747 MOS_STATUS MediaPerfProfiler::AddCopyQualityMetricCmd(
748 void *context,
749 MOS_INTERFACE *osInterface,
750 std::shared_ptr<mhw::mi::Itf>& miItf,
751 MOS_COMMAND_BUFFER *cmdBuffer,
752 UMD_QUALITY_METRIC_ITEM item,
753 PMOS_RESOURCE presSrc,
754 uint32_t dwSrcOffset)
755 {
756 MOS_STATUS status = MOS_STATUS_SUCCESS;
757 uint32_t offset = 0;
758
759 if (m_profilerEnabled == 0)
760 {
761 return status;
762 }
763
764 CHK_NULL_RETURN(context);
765 CHK_NULL_RETURN(osInterface);
766 CHK_NULL_RETURN(miItf);
767 CHK_NULL_RETURN(cmdBuffer);
768 CHK_NULL_RETURN(presSrc);
769
770 PMOS_CONTEXT pOsContext = osInterface->pOsContext;
771 CHK_NULL_RETURN(pOsContext);
772
773 uint32_t perfDataIndex = m_contextIndexMap[context];
774
775 switch (item)
776 {
777 case UMD_QUALITY_ITEM_SSEY:
778 offset = BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, SSEY);
779 break;
780 case UMD_QUALITY_ITEM_SSEU:
781 offset = BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, SSEU);
782 break;
783 case UMD_QUALITY_ITEM_SSEV:
784 offset = BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, SSEV);
785 break;
786 case UMD_QUALITY_ITEM_MEAN_SSIM_YU:
787 offset = BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, DWMeanSsimLayer1_YU);
788 break;
789 case UMD_QUALITY_ITEM_MEAN_SSIM_V:
790 offset = BASE_OF_NODE(perfDataIndex) + OFFSET_OF(PerfEntry, DWMeanSsimLayer1_V);
791 break;
792 default:
793 status = MOS_STATUS_INVALID_PARAMETER;
794 break;
795 }
796
797 if (status == MOS_STATUS_SUCCESS)
798 {
799 CHK_STATUS_RETURN(CopyMemData(miItf, cmdBuffer, pOsContext, presSrc, dwSrcOffset, offset));
800 }
801
802 return status;
803 }
804
805 MOS_STATUS MediaPerfProfiler::SavePerfData(MOS_INTERFACE *osInterface)
806 {
807 MOS_STATUS status = MOS_STATUS_SUCCESS;
808
809 CHK_NULL_RETURN(osInterface);
810
811 PMOS_CONTEXT pOsContext = osInterface->pOsContext;
812 CHK_NULL_RETURN(pOsContext);
813
814 if (m_multiprocesssinglebin)
815 {
816 uint32_t cnt = 0;
817 MOS_LOCK_PARAMS LockFlagsNoOverWrite = {};
818
819 MOS_ZeroMemory(&LockFlagsNoOverWrite, sizeof(MOS_LOCK_PARAMS));
820 LockFlagsNoOverWrite.WriteOnly = 1;
821 LockFlagsNoOverWrite.NoOverWrite = 1;
822
823 if (m_perfDataCombined == nullptr)
824 {
825 m_perfDataCombinedSize = 96;
826
827 for (auto iter = m_perfDataIndexMap.begin(); iter != m_perfDataIndexMap.end(); ++iter)
828 {
829 if (iter->second > 0)
830 {
831 m_perfDataCombinedSize += BASE_OF_NODE(m_perfDataIndexMap[iter->first]) + 4;
832 cnt += 1;
833 }
834 }
835
836 if (cnt == 0)
837 {
838 return status;
839 }
840
841 m_perfDataCombined = (uint32_t *)MOS_AllocAndZeroMemory(m_perfDataCombinedSize);
842 CHK_NULL_RETURN(m_perfDataCombined);
843
844 m_perfDataCombined[0] = 0x8086;
845 m_perfDataCombined[2] = m_perfDataCombinedSize - (cnt * 4);
846 m_perfDataCombined[3] = cnt;
847
848 m_perfDataCombinedOffset = 96 + (cnt * 4);
849 }
850
851 if (m_perfDataIndexMap[pOsContext] > 0)
852 {
853 uint8_t* pData = (uint8_t*)osInterface->pfnLockResource(
854 osInterface,
855 m_perfStoreBufferMap[pOsContext],
856 &LockFlagsNoOverWrite);
857
858 CHK_NULL_RETURN(pData);
859 MOS_SecureMemcpy(((uint8_t *)m_perfDataCombined) + m_perfDataCombinedOffset, BASE_OF_NODE(m_perfDataIndexMap[pOsContext]), pData, BASE_OF_NODE(m_perfDataIndexMap[pOsContext]));
860
861 osInterface->pfnUnlockResource(
862 osInterface,
863 m_perfStoreBufferMap[pOsContext]);
864
865 m_perfDataCombinedOffset += BASE_OF_NODE(m_perfDataIndexMap[pOsContext]);
866 m_perfDataCombined[24 + m_perfDataCombinedIndex] = BASE_OF_NODE(m_perfDataIndexMap[pOsContext]);
867 m_perfDataCombinedIndex ++;
868
869 if (m_perfDataCombinedOffset == m_perfDataCombinedSize)
870 {
871 MosUtilities::MosWriteFileFromPtr(m_outputFileName.c_str(), m_perfDataCombined, m_perfDataCombinedSize);
872 MOS_SafeFreeMemory(m_perfDataCombined);
873 m_perfDataCombined = nullptr;
874 m_perfDataCombinedIndex = 0;
875 m_perfDataCombinedOffset = 0;
876 m_perfDataCombinedSize = 0;
877 }
878 }
879
880 return status;
881 }
882 else if (m_perfDataIndexMap[pOsContext] > 0)
883 {
884 MOS_LOCK_PARAMS LockFlagsNoOverWrite;
885 MOS_ZeroMemory(&LockFlagsNoOverWrite, sizeof(MOS_LOCK_PARAMS));
886
887 LockFlagsNoOverWrite.WriteOnly = 1;
888 LockFlagsNoOverWrite.NoOverWrite = 1;
889
890 uint8_t* pData = (uint8_t*)osInterface->pfnLockResource(
891 osInterface,
892 m_perfStoreBufferMap[pOsContext],
893 &LockFlagsNoOverWrite);
894
895 CHK_NULL_RETURN(pData);
896
897 if (m_multiprocess)
898 {
899 int32_t pid = MosUtilities::MosGetPid();
900 tm localtime = { 0 };
901 MosUtilities::MosGetLocalTime(&localtime);
902 char outputFileName[MOS_MAX_PATH_LENGTH + 1];
903
904 MOS_SecureStringPrint(outputFileName, MOS_MAX_PATH_LENGTH + 1, MOS_MAX_PATH_LENGTH + 1, "%s-pid%d-context%p-%04d%02d%02d%02d%02d%02d.bin",
905 m_outputFileName.c_str(), pid, pOsContext, localtime.tm_year + 1900, localtime.tm_mon + 1, localtime.tm_mday, localtime.tm_hour, localtime.tm_min, localtime.tm_sec);
906
907 MosUtilities::MosWriteFileFromPtr(outputFileName, pData, BASE_OF_NODE(m_perfDataIndexMap[pOsContext]));
908 }
909 else if (m_mergeheader)
910 {
911 NodeHeader *header = reinterpret_cast<NodeHeader *>(pData);
912 char outputFileName[MOS_MAX_PATH_LENGTH + 1];
913 MOS_SecureStringPrint(outputFileName, MOS_MAX_PATH_LENGTH + 1, MOS_MAX_PATH_LENGTH + 1, "%s-header%u.bin", m_outputFileName.c_str(), *reinterpret_cast<uint32_t*>(header));
914 HANDLE hFile = nullptr;
915 if (MosUtilities::MosCreateFile(&hFile, outputFileName, 0) != MOS_STATUS_SUCCESS)
916 {
917 MosUtilities::MosWriteFileFromPtr(outputFileName, pData, BASE_OF_NODE(m_perfDataIndexMap[pOsContext]));
918 }
919 else
920 {
921 MosUtilities::MosCloseHandle(hFile);
922 MosUtilities::MosAppendFileFromPtr(outputFileName, pData + sizeof(NodeHeader), BASE_OF_NODE(m_perfDataIndexMap[pOsContext]) - sizeof(NodeHeader));
923 }
924 }
925 else
926 {
927 MosUtilities::MosWriteFileFromPtr(m_outputFileName.c_str(), pData, BASE_OF_NODE(m_perfDataIndexMap[pOsContext]));
928 }
929
930 osInterface->pfnUnlockResource(
931 osInterface,
932 m_perfStoreBufferMap[pOsContext]);
933 }
934
935 return status;
936 }
937
938 PerfGPUNode MediaPerfProfiler::GpuContextToGpuNode(MOS_GPU_CONTEXT context)
939 {
940 PerfGPUNode node = PERF_GPU_NODE_UNKNOW;
941
942 switch (context)
943 {
944 case MOS_GPU_CONTEXT_RENDER:
945 case MOS_GPU_CONTEXT_RENDER2:
946 case MOS_GPU_CONTEXT_RENDER3:
947 case MOS_GPU_CONTEXT_RENDER4:
948 case MOS_GPU_OVERLAY_CONTEXT:
949 case MOS_GPU_CONTEXT_RENDER_RA:
950 node = PERF_GPU_NODE_3D;
951 break;
952 case MOS_GPU_CONTEXT_COMPUTE:
953 case MOS_GPU_CONTEXT_CM_COMPUTE:
954 case MOS_GPU_CONTEXT_COMPUTE_RA:
955 node = PERF_GPU_NODE_3D;
956 break;
957 case MOS_GPU_CONTEXT_VIDEO:
958 case MOS_GPU_CONTEXT_VIDEO2:
959 case MOS_GPU_CONTEXT_VIDEO3:
960 case MOS_GPU_CONTEXT_VIDEO4:
961 case MOS_GPU_CONTEXT_VIDEO5:
962 case MOS_GPU_CONTEXT_VIDEO6:
963 case MOS_GPU_CONTEXT_VIDEO7:
964 node = PERF_GPU_NODE_VIDEO;
965 break;
966 case MOS_GPU_CONTEXT_VDBOX2_VIDEO:
967 case MOS_GPU_CONTEXT_VDBOX2_VIDEO2:
968 case MOS_GPU_CONTEXT_VDBOX2_VIDEO3:
969 node = PERF_GPU_NODE_VIDEO2;
970 break;
971 case MOS_GPU_CONTEXT_VEBOX:
972 case MOS_GPU_CONTEXT_VEBOX2:
973 node = PERF_GPU_NODE_VE;
974 break;
975 case MOS_GPU_CONTEXT_BLT:
976 node = PERF_GPU_NODE_BLT;
977 break;
978 case MOS_GPU_CONTEXT_TEE:
979 node = PERF_GPU_NODE_TEE;
980 break;
981 default:
982 node = PERF_GPU_NODE_UNKNOW;
983 break;
984 }
985
986 return node;
987 }
988
989 uint32_t MediaPerfProfiler::PlatFormIdMap(PLATFORM platform)
990 {
991 uint32_t perfPlatFormId = 0;
992
993 if (GFX_GET_CURRENT_RENDERCORE(platform) > IGFX_GEN12LP_CORE)
994 {
995 perfPlatFormId = ((((uint32_t)(GFX_GET_CURRENT_RENDERCORE(platform)) >> 8) - 0xc) << 2) + (GFX_GET_CURRENT_RENDERCORE(platform) & 0x3) + (uint32_t)(IGFX_GEN12LP_CORE);
996 }
997 else
998 {
999 perfPlatFormId = (uint32_t)(GFX_GET_CURRENT_RENDERCORE(platform));
1000 }
1001
1002 return perfPlatFormId;
1003 }
1004
1005 bool MediaPerfProfiler::IsPerfModeWidthMemInfo(uint32_t *regs)
1006 {
1007 int8_t index = 0;
1008 bool ret = false;
1009
1010 for (index = 0; index < 8; index++)
1011 {
1012 if (regs[index] != 0)
1013 {
1014 ret = true;
1015 break;
1016 }
1017 }
1018
1019 return ret;
1020 }