/* * Copyright (c) 2019-2020, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ //! //! \file mos_graphicsresource_next.h //! \brief Container class for the basic gpu resource //! #ifndef __MOS_GRAPHICS_RESOURCE_NEXT_H__ #define __MOS_GRAPHICS_RESOURCE_NEXT_H__ #include #include "mos_os.h" #include "mos_resource_defs.h" class GraphicsResourceNext { public: enum ResourceType { undefinedResource = 0, //!< Undefined Resource Type osSpecificResource = 1, //!< Os Specific Resource Type soloResource = 2, //!< MediaSolo based Resource Type invalidResource = 0xff //!< Ceil Guard for Resource Type }; constexpr static uint32_t m_maxBufNameLength = 256; //! //! \brief Structure to Resource allocation parameters //! struct CreateParams { public: //! //! \brief 0,1: 1 element. >1: N elements //! uint32_t m_arraySize = 1; //! //! \brief Compression mode. //! MOS_RESOURCE_MMC_MODE m_compressionMode = MOS_MMC_DISABLED; //! //! \brief depth information. //! uint32_t m_depth = 0; //! //! \brief Pixel format. //! MOS_FORMAT m_format = Format_Invalid; //! //! \brief Type == 2D || VOLUME, height in rows. Type == BUFFER, n/a //! uint32_t m_height = 1; //! //! \brief Resource is compressible or not. //! bool m_isCompressible = false; //! //! \brief Optional parameter. Used to indicate that resource //! can not be evicted //! bool m_isPersistent = false; //! //! \brief Optional parameter only used in Linux. A string indicates the buffer //! name and is used for debugging. NULL is OK. //! std::string m_name = ""; //! //! \brief Optional parameter. If non null, TileType must be set to linear. //! void* m_pSystemMemory = nullptr; //! //! \brief Whether SVM is in use. //! bool m_svm = false; //! //! \brief Defines the layout of a physical page. Optimal choice depends on usage //! model. //! MOS_TILE_TYPE m_tileType = MOS_TILE_INVALID; //! //! \brief A tile Encoding (aligned w/ GMM defination) needs set by force, take effects when implicitly tile handling //! MOS_TILE_MODE_GMM m_tileModeByForce = MOS_TILE_UNSET_GMM; //! //! \brief Basic resource geometry //! MOS_GFXRES_TYPE m_type = MOS_GFXRES_INVALID; //! //! \brief Flags to describe attributes //! MOS_GFXRES_FLAGS m_flags = {}; //! //! \brief width in pixels //! uint32_t m_width = 0; //! //! \brief allocation memory type //! uint32_t m_memType = MOS_MEMPOOL_VIDEOMEMORY; //! //! \brief gmm resource usage type, set patusage or mocs usage //! GMM_RESOURCE_USAGE_TYPE m_gmmResUsageType = GMM_RESOURCE_USAGE_UNKNOWN; //! //! \brief mos resource usage type, set mocs index //! MOS_HW_RESOURCE_DEF m_mocsMosResUsageType = MOS_MP_RESOURCE_USAGE_DEFAULT; //! \brief Flag as hint that Resource can be used as hw protected //! bool m_hardwareProtected = false; //! //! \brief Create the graphics buffer from a PMOS_ALLOC_GFXRES_PARAMS, for wrapper usage, to be deleted //! CreateParams(PMOS_ALLOC_GFXRES_PARAMS pParams); CreateParams() = default; }; //! //! \brief Structure to Structure to Lock params //! struct LockParams { public: bool m_forceCached = false; bool m_noDecompress = false; bool m_readRequest = false; bool m_tileAsTiled = false; bool m_uncached = false; bool m_writeRequest = false; bool m_noOverWrite = false; //! //! \brief For wrapper usage, to be removed //! LockParams(PMOS_LOCK_PARAMS pLockFlags) { m_forceCached = pLockFlags->ForceCached; m_noDecompress = pLockFlags->NoDecompress; m_readRequest = pLockFlags->ReadOnly; m_tileAsTiled = pLockFlags->TiledAsTiled; m_uncached = pLockFlags->Uncached; m_writeRequest = pLockFlags->WriteOnly; m_noOverWrite = pLockFlags->NoOverWrite; }; LockParams() { }; }; //! //! \brief Structure to OS sync parameters //! struct SyncParams { MOS_GPU_CONTEXT m_gpuContext = {}; //!< GPU context you would like to signal on or wait in GraphicsResourceNext* m_resSyncResource = nullptr; //!< Has 2 meanings: //!< 1) a resource that requires sync, like a destination surface //!< 2) a resource used by HW/OS to sync between engines, like for MI_SEMAPHORE_MBOX uint32_t m_semaphoreCount = 0; //!< Semaphore count uint32_t m_semaphoreValue = 0; //!< Tag value in the case of resource tagging uint32_t m_semaphoreOffset = 0; //!< Offset into the sync resource for value read/write bool m_readOnly = false; //!< Marks the resource as read or write for future waits bool m_disableDecodeSyncLock = false; //!< Disable the lock function for decode. bool m_disableLockForTranscode = false; //!< Disable the lock function for transcode perf. //! //! \brief For wrapper usage, to be removed //! SyncParams(PMOS_SYNC_PARAMS pParams) { m_gpuContext = pParams->GpuContext; m_resSyncResource = pParams->presSyncResource->pGfxResourceNext; m_semaphoreCount = pParams->uiSemaphoreCount; m_semaphoreValue = pParams->uiSemaphoreValue; m_semaphoreOffset = pParams->uiSemaphoreOffset; m_readOnly = (pParams->bReadOnly == 1) ? true : false; m_disableDecodeSyncLock = (pParams->bDisableDecodeSyncLock == 1) ? true : false; m_disableLockForTranscode = (pParams->bDisableLockForTranscode == 1) ? true : false; }; SyncParams() { }; } ; protected: //! //! \brief Constructor //! \return N/A //! GraphicsResourceNext(); public: //! //! \brief Create Graphic resource based on specific resource type //! \param [in] resourceType //! Resource type, either os specific resoure or solo resource //! \return One specific Graphic Resource //! static class GraphicsResourceNext *CreateGraphicResource(ResourceType resourceType); //! //! \brief Destructor //! \return N/A //! virtual ~GraphicsResourceNext(); //! //! \brief Get the size of the graphic resource //! \return buf size of the graphic resource //! uint32_t GetSize() { return m_size; }; //! //! \brief Get the locked address of resource //! \return address locked //! uint8_t* GetLockedAddr() {return m_pData; }; //! //! \brief Get allocation index of resource //! \param [in] gpuContextHandle //! Gpu context handle used to get the alloc index //! \return index got from current resource //! int32_t GetAllocationIndex(GPU_CONTEXT_HANDLE gpuContextHandle); //! //! \brief Dump the content of the graphic resource into a specific file //! \param [in] osContextPtr //! Pointer to the osContext handle //! \param [in] overrideOffset //! the offset inside the dump file //! \param [in] overrideSize //! the dump length //! \param [in] outputFileName //! the dump file name //! \param [in] outputPath //! the dump file path //! \return MOS_STATUS_SUCCESS on success case, MOS error status on fail cases //! MOS_STATUS Dump(OsContextNext* osContextPtr, uint32_t overrideOffset, uint32_t overrideSize, std::string outputFileName, std::string outputPath); //! //! \brief Check whether the resource is nullptr //! \param [in] pResource //! ptr to the graphics resource to be checked //! \return ture if the resource is nullptr, false on other cases //! virtual bool ResourceIsNull() = 0; //! //! \brief Allocate the graphic memory to back up the graphic resource //! \param [in] osContextPtr //! Pointer to the osContext handle //! \param [in] params //! Resource creation Params //! \return MOS_STATUS_SUCCESS on success case, MOS error status on fail cases //! virtual MOS_STATUS Allocate(OsContextNext* osContextPtr, CreateParams& params) = 0; //! //! \brief Frees the specified resource with specific flag, if locked, unlocks it. //! \param [in] osContextPtr //! Pointer to the osContext handle //! \param [in] freeFlag //! specific flag to free the resource //! virtual void Free(OsContextNext* osContextPtr, uint32_t freeFlag = 0) = 0; //! //! \brief check whether the current graphic resource is equal to another one //! \param [in] toCompare //! ptr to the graphics resource to be compared with //! \return ture if equal, false if not //! virtual bool IsEqual(GraphicsResourceNext* toCompare) = 0; //! //! \brief Check whether the current graphic resource is valid //! \return Returns true if the two resources are equal and false otherwise. //! virtual bool IsValid() = 0; //! //! \brief Locks a resource and returns a mapped system memory pointer. //! \param [in] osContextPtr //! Pointer to the osContext handle //! \param [in] params //! Resource lock Params //! \return CPU side lock address in success case, nullptr in fail cases //! virtual void* Lock(OsContextNext* osContextPtr, LockParams& params) = 0; //! //! \brief Unlocks a resource that has already been locked, if no lock has //! occurred, this function does nothing //! \param [in] osContextPtr //! Pointer to the osContext handle //! \return MOS_SUCCESS in success case, MOS error status in fail cases //! virtual MOS_STATUS Unlock(OsContextNext* osContextPtr) = 0; //! //! \brief Converts an OS specific resource to a MOS resource. //! \param [out] pMosResource //! ptr to the MOS_RESOURCE as the convertion result //! \return MOS_SUCCESS in success case, MOS error status in fail cases //! virtual MOS_STATUS ConvertToMosResource(MOS_RESOURCE* pMosResource) = 0; //! //! \brief For MemNinja support. //! \return Global memory alloction counter //! static uint32_t GetMemAllocCounterGfx() { return m_memAllocCounterGfx; }; //! //! \brief For MemNinja support. //! \return Global memory alloction counter //! static void SetMemAllocCounterGfx(uint32_t memAllocCounterGfx) { m_memAllocCounterGfx = memAllocCounterGfx; }; //! //! \brief Reset allocation index of all Gpu context in the resource //! \return void //! void ResetResourceAllocationIndex(); protected: //! //! \brief Global graphic resource counter //! static uint32_t m_memAllocCounterGfx; //! //! \brief buf name of the graphic resource //! std::string m_name = ""; //! //! \brief CPU side lock address for the graphic resource //! uint8_t* m_pData = nullptr; //! //! \brief 0,1: 1 element. >1: N elements //! uint32_t m_arraySize = 0; //! //! \brief Graphic resource compressiable or not //! bool m_compressible = false; //! //! \brief compression mode for the Graphic resource //! MOS_RESOURCE_MMC_MODE m_compressionMode = MOS_MMC_DISABLED; //!MOS_MMC_DISABLED //! \brief 0: Implies 2D resource. >=1: volume resource //! uint32_t m_depth = 0; //! //! \brief wheather the flip chain is in use //! bool m_flipChain = false; //! //! \brief Pixel format //! MOS_FORMAT m_format = Format_Invalid; //! //! \brief Type == 2D || VOLUME, height in rows. Type == BUFFER, n/a //! uint32_t m_height = 0; //! //! \brief the Graphic resource is compressed or not //! bool m_isCompressed = false; //! //! \brief the flag to indicate if overlay is in use //! bool m_overlay = false; //! //! \brief < RenderPitch > pitch in bytes used for programming HW //! uint32_t m_pitch = 0; //! //! \brief distance in rows between R-Planes used for programming HW //! uint32_t m_qPitch = 0; //! //! \brief the active m_count for the graphic resource //! uint32_t m_count = 0; //! //! \brief the size of the graphic resource //! uint32_t m_size = 0; //! //! \brief Type == VOLUME, byte offset to next slice. Type != VOLUME, n/a //! uint32_t m_slicePitch = 0; //! //! \brief Defines the layout of a physical page. Optimal choice depends on usage //! MOS_TILE_TYPE m_tileType = MOS_TILE_INVALID; //! //! \brief Transparent GMM Tiletype specifying in hwcmd finally //! MOS_TILE_MODE_GMM m_tileModeGMM = MOS_TILE_LINEAR_GMM; //! //! \brief GMM defined Tile mode flag //! bool m_isGMMTileEnabled = false; //! //! \brief Basic resource geometry //! MOS_GFXRES_TYPE m_type = MOS_GFXRES_INVALID; //! //! \brief Type == 2D || VOLUME, width in pixels. //! uint32_t m_width = 0; //! //! \brief This is used by MDF when a wrapper MOS Resource is used to //! set surface state for a given VA, not necessary from start, //! in another actual MOS resource //! uint64_t m_userProvidedVA = 0; //! //! \brief Array of Gpu context and alloctaion index tuple. //! std::vector > m_allocationIndexArray; //! \brief Mutex for allocation index array PMOS_MUTEX m_allocationIndexMutex = nullptr; //! \brief Mutex for allocation index array MEMORY_OBJECT_CONTROL_STATE m_memObjCtrlState = {}; //! //! \brief mos resource usage type, set mocs index //! MOS_HW_RESOURCE_DEF m_mocsMosResUsageType = MOS_MP_RESOURCE_USAGE_DEFAULT; OsContextNext *m_osContextPtr = nullptr; MEDIA_CLASS_DEFINE_END(GraphicsResourceNext) }; #endif // #ifndef __MOS_GRAPHICS_RESOURCE_NEXT_H__