AI/rocm-systems
2
0
Çatalla 0
Kod Konular Değişiklik İstekleri İşlemler Paketler Projeler Sürüm Viki Aktivite

Revert "Update amdgpu-windows-interop with latest changes (#1718)" (#1725)

Kaynağa Gözat 
This reverts commit 321e497048.
Bu işleme şunda yer alıyor:
Joseph Macaranas
2025-11-05 15:38:23 -05:00
işlemeyi yapan: GitHub
ebeveyn 321e497048
işleme 865a8d4d59
136 değiştirilmiş dosya ile 44160 ekleme ve 44376 silme
Yama Dosyasını İndir Diff Dosyasını İndir Tüm dosyaları genişlet Tüm dosyaları daralt
shared/amdgpu-windows-interop/pal/inc/core/palCmdBuffer.h
+27 -113
Dosyayı Görüntüle
@@ -298,21 +298,12 @@ enum ImageLayoutUsageFlags : uint32
/// display engine. /// display engine.
LayoutUncompressed = 0x00001000, ///< Metadata fully decompressed/expanded layout LayoutUncompressed = 0x00001000, ///< Metadata fully decompressed/expanded layout
LayoutSampleRate = 0x00002000, ///< CmdBindSampleRateImage() source. LayoutSampleRate = 0x00002000, ///< CmdBindSampleRateImage() source.
LayoutVideoEncodeRead = 0x00004000, ///< Video encoder input image layout, output is buffer so no layout. LayoutAllUsages = 0x00003FFF
LayoutVideoDecodeWrite = 0x00008000, ///< Video decoder output image layout, input is buffer so no layout.
LayoutAllUsages = 0x0000FFFF,
}; };
/// Bitmask values that can be ORed together to specify all potential engines an image might be used on. Such a /// Bitmask values that can be ORed together to specify all potential engines an image might be used on. Such a
/// mask should be specified in the engines field of ImageLayout. /// mask should be specified in the engines field of ImageLayout.
/// ///
/// Generally speaking, image transition inside the all video queues doesn't require barrier including stall, cache
/// sync and layout transition. For transition across queues, we rely inter-queue sync to guarantee the stall
/// and cache sync. However, it's possible the layout transition is incompatible and we need handle it. Clients can
/// call @ref IImage::IsLayoutTransitionCompatible() to check if the transition is compatible or not; if not,
/// must issue a barrier to do the layout transition. Note that Layout transitions must always be executed on Universal
/// or Compute queues; and DMA queue only supports metadata initialization transition.
///
/// If the client API is unable to determine which engines might be used, it should specify all possible engines /// If the client API is unable to determine which engines might be used, it should specify all possible engines
/// corresponding to the usage flags. /// corresponding to the usage flags.
enum ImageLayoutEngineFlags : uint32 enum ImageLayoutEngineFlags : uint32
@@ -370,35 +361,25 @@ enum CacheCoherencyUsageFlags : uint32
/// Bitmask values for the flags parameter of ICmdBuffer::CmdClearColorImage(). /// Bitmask values for the flags parameter of ICmdBuffer::CmdClearColorImage().
enum ClearColorImageFlags : uint32 enum ClearColorImageFlags : uint32
{ {
ColorClearAutoSync = 0x01, ///< PAL will automatically insert required barrier synchronization before ColorClearAutoSync = 0x00000001, ///< PAL will automatically insert required barrier synchronization before
/// and after the clear assuming all subresources to be cleared are currently /// and after the clear assuming all subresources to be cleared are currently
/// ready for rendering as a color target (as is required by API convention in /// ready for rendering as a color target (as is required by API convention in
/// DX12). Allows reduced sync costs in some situations since PAL knows /// DX12). Allows reduced sync costs in some situations since PAL knows
/// the details of how the clear will be performed. /// the details of how the clear will be performed.
ColorClearForceSlow = 0x02, ///< Force these to use slow clears. ColorClearForceSlow = 0x00000002, ///< Force these to use slow clears.
ColorClearSkipIfSlow = 0x04, ///< Only issue the clear if it is a fast clear. ColorClearSkipIfSlow = 0x00000004, ///< Only issue the clear if it is a fast clear.
ColorClearInitMetaData = 0x08, ///< PAL will make sure initialize all metadata (including internal metadata state ColorClearAllFlags = 0x00000007 ///< Clients should NOT use it, for internal static_assert purpose only.
/// data) for this image to be cleared. This is typically used for placed resource
/// initialization (as required by API convention in DX12); should only be used
/// when this is a full box clear.
ColorClearAllFlags = 0x0F ///< Clients should NOT use it, for internal static_assert purpose only.
}; };
/// Bitmask values for the flags parameter of ICmdBuffer::CmdClearDepthStencil(). /// Bitmask values for the flags parameter of ICmdBuffer::CmdClearDepthStencil().
enum ClearDepthStencilFlags : uint32 enum ClearDepthStencilFlags : uint32
{ {
DsClearAutoSync = 0x01, ///< PAL will automatically insert required barrier synchronization before DsClearAutoSync = 0x00000001, ///< PAL will automatically insert required barrier synchronization before
/// and after the clear assuming all subresources to be cleared are currently /// and after the clear assuming all subresources to be cleared are currently
/// ready for rendering as a depth/stencil target (as is required by API convention /// ready for rendering as a depth/stencil target (as is required by API convention
/// in DX12). Allows reduced sync costs in some situations since PAL knows the /// in DX12). Allows reduced sync costs in some situations since PAL knows the
/// details of how the clear will be performed. /// details of how the clear will be performed.
DsClearInitMetaData = 0x02, ///< PAL will make sure initialize all metadata (including internal metadata state DsClearAllFlags = 0x00000001 ///< Clients should NOT use it, for internal static_assert purpose only.
/// data) for this image to be cleared. This is typically used for placed resource
/// initialization (as is required by API convention in DX12); should only be used
/// when this is a full box clear. Note that if clients call @ref
/// CmdClearDepthStencil() with this flag, MUST call @ref CmdUpdateHiSPretests()
/// after clear call otherwise HiSPretests will be overridden to initialized state.
DsClearAllFlags = 0x03 ///< Clients should NOT use it, for internal static_assert purpose only.
}; };
/// Bitmask values for the flags parameter of ICmdBuffer::CmdResolveImage(). /// Bitmask values for the flags parameter of ICmdBuffer::CmdResolveImage().
@@ -559,12 +540,7 @@ union CmdBufferBuildFlags
/// non-TMZ memory, the results are undefined. Only valid for graphics and compute. /// non-TMZ memory, the results are undefined. Only valid for graphics and compute.
uint32 enableTmz : 1; uint32 enableTmz : 1;
/// @internal uint32 placeholder3 : 1;
/// Build this command buffer in system memory
///
/// @warning This is an internal flag and its existence, its signature and its semantics are not guaranteed
/// across different PAL versions.
uint32 buildInSysMem : 1;
/// If set, internal operations such as blits, copies, etc. will not affect active Query results. /// If set, internal operations such as blits, copies, etc. will not affect active Query results.
/// Otherwise they may affect the results. /// Otherwise they may affect the results.
@@ -1309,35 +1285,16 @@ extern const ColorSpaceConversionTable DefaultCscTableYuvToRgb;
/// to perform a RGB to YUV color space conversion. Represents the BT.601 standard (standard-definition TV). /// to perform a RGB to YUV color space conversion. Represents the BT.601 standard (standard-definition TV).
extern const ColorSpaceConversionTable DefaultCscTableRgbToYuv; extern const ColorSpaceConversionTable DefaultCscTableRgbToYuv;
/// Specifies flags controlling GPU copy behavior in @ref CmdCopyImage. Format related flags are ignored by DMA queues. /// Specifies flags controlling GPU copy behavior. Format related flags are ignored by DMA queues.
enum CopyImageControlFlags : uint32
{
CopyImageFormatConversion = 0x1, ///< Requests that the copy convert between two compatible formats. This is
/// ignored unless both formats support @ref FormatFeatureFormatConversion.
CopyImageRawSwizzle = 0x2, ///< If possible, raw copies will swizzle from the source channel format into the
/// destination channel format (e.g., RGBA to BGRA).
CopyImageEnableScissorTest = 0x4, ///< If set, do scissor test using the specified scissor rectangle.
CopyImageInitDstMetadata = 0x8, ///< Requests copy initializes dst image's metadata; requires full box copy.
CopyImageControlAllFlags = 0xF ///< Clients should NOT use it, for internal static_assert purpose only.
};
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 955
enum CopyControlFlags : uint32 enum CopyControlFlags : uint32
{ {
CopyFormatConversion = CopyImageFormatConversion, CopyFormatConversion = 0x1, ///< Requests that the copy convert between two compatible formats. This is ignored
CopyRawSwizzle = CopyImageRawSwizzle, /// unless both formats support @ref FormatFeatureFormatConversion.
CopyEnableScissorTest = CopyImageEnableScissorTest, CopyRawSwizzle = 0x2, ///< If possible, raw copies will swizzle from the source channel format into the
/// destination channel format (e.g., RGBA to BGRA).
CopyEnableScissorTest = 0x4, ///< If set, do scissor test using the specified scissor rectangle.
CopyControlAllFlags = 0x7 ///< Clients should NOT use it, for internal static_assert purpose only. CopyControlAllFlags = 0x7 ///< Clients should NOT use it, for internal static_assert purpose only.
}; };
#endif
/// Specifies flags controlling GPU copy behavior in @ref CmdCopyMemoryToImage.
/// Format related flags are ignored by DMA queues.
enum CopyMemoryToImageControlFlags : uint32
{
CopyMemoryToImageInitDstMetadata = 0x1, ///< Requests copy initializes dst image's metadata; requires full box copy.
CopyMemoryToImageControlAllFlags = 0x1 ///< Clients should NOT use it, for internal static_assert purpose only.
};
/// Specifies parameters for a resolve of one region in an MSAA source image to a region of the same size in a single /// Specifies parameters for a resolve of one region in an MSAA source image to a region of the same size in a single
/// sample destination image. Used as an input to ICmdBuffer::CmdResolveImage(). /// sample destination image. Used as an input to ICmdBuffer::CmdResolveImage().
@@ -1752,19 +1709,12 @@ struct DispatchAqlParams
}; };
/// This structure holds the parameters used during kernel dispatch.
struct DispatchAqlFeedback
{
uint32 tmpRingSize; ///< Content of the compute_tmpring_size register.
};
/// @internal Function pointer type definition for issuing AQL dispatches. /// @internal Function pointer type definition for issuing AQL dispatches.
/// ///
/// @see ICmdBuffer::CmdDispatchAql(). /// @see ICmdBuffer::CmdDispatchAql().
typedef void (PAL_STDCALL *CmdDispatchAqlFunc)( typedef void (PAL_STDCALL *CmdDispatchAqlFunc)(
ICmdBuffer* pCmdBuffer, ICmdBuffer* pCmdBuffer,
const DispatchAqlParams& dispatchInfo, const DispatchAqlParams& dispatchInfo);
DispatchAqlFeedback* pFeedback);
/// Specifies input assembler state for draws. /// Specifies input assembler state for draws.
/// @see ICmdBuffer::CmdSetInputAssemblyState /// @see ICmdBuffer::CmdSetInputAssemblyState
@@ -1978,13 +1928,6 @@ struct Viewport
PointOrigin origin; ///< Origin of the viewport relative to NDC. UpperLeft or LowerLeft. PointOrigin origin; ///< Origin of the viewport relative to NDC. UpperLeft or LowerLeft.
}; };
/// Specifies the range for user-defined depth clamp.
struct DepthClamp
{
float minDepth; ///< Minimum depth value after viewport transform.
float maxDepth; ///< Maximum depth value after viewport transform.
};
/// Specifies the viewport transform parameters for setting a single viewport. /// Specifies the viewport transform parameters for setting a single viewport.
/// @see ICmdBuffer::CmdSetViewport /// @see ICmdBuffer::CmdSetViewport
struct ViewportParams struct ViewportParams
@@ -1998,7 +1941,6 @@ struct ViewportParams
float horzClipRatio; ///< The ratio between guardband clip rect width and viewport width. float horzClipRatio; ///< The ratio between guardband clip rect width and viewport width.
float vertClipRatio; ///< The ratio between guardband clip rect height and viewport height. float vertClipRatio; ///< The ratio between guardband clip rect height and viewport height.
DepthRange depthRange; ///< Specifies the target range of Z values DepthRange depthRange; ///< Specifies the target range of Z values
DepthClamp userDepthClamp; ///< Specifies the clamp range of Z values for DepthClampMode::UserDefined.
// Define viewports array at the end of the structure as it is common to only access the first N from the CPU. // Define viewports array at the end of the structure as it is common to only access the first N from the CPU.
Viewport viewports[MaxViewports]; ///< Array of desciptors for each viewport. Viewport viewports[MaxViewports]; ///< Array of desciptors for each viewport.
}; };
@@ -2147,9 +2089,7 @@ struct CmdBufInfo
uint32 captureCamera : 1; ///< Has Direct Capture camera matrix capture uint32 captureCamera : 1; ///< Has Direct Capture camera matrix capture
uint32 hudLessImagePropChanged : 1; ///< Indicates whether HUD less image properties changed uint32 hudLessImagePropChanged : 1; ///< Indicates whether HUD less image properties changed
uint32 captureHudLessImage : 1; ///< Has Direct Capture HUD less image capture uint32 captureHudLessImage : 1; ///< Has Direct Capture HUD less image capture
uint32 llmDecodeStart : 1; ///< Has LLM decode Start Enabled in the CmdBufInfo packet uint32 reserved : 3; ///< Reserved for future usage.
uint32 llmDecodeStop : 1; ///< Has LLM decode Stop Enabled in the CmdBufInfo packet
uint32 reserved : 1; ///< Reserved for future usage.
}; };
uint32 u32All; ///< Flags packed as uint32. uint32 u32All; ///< Flags packed as uint32.
}; };
@@ -3352,27 +3292,12 @@ public:
/// @param [in] regionCount Number of regions to copy; size of the pRegions array. /// @param [in] regionCount Number of regions to copy; size of the pRegions array.
/// @param [in] pRegions Array of copy regions, each entry specifying a source offset, a destination /// @param [in] pRegions Array of copy regions, each entry specifying a source offset, a destination
/// subresource, destination x/y/z offset, and copy size in the x/y/z dimensions. /// subresource, destination x/y/z offset, and copy size in the x/y/z dimensions.
/// @param [in] flags A mask of ORed @ref CopyMemoryToImageControlFlags that can be used to control copy
/// behavior.
virtual void CmdCopyMemoryToImage( virtual void CmdCopyMemoryToImage(
const IGpuMemory& srcGpuMemory, const IGpuMemory& srcGpuMemory,
const IImage& dstImage, const IImage& dstImage,
ImageLayout dstImageLayout, ImageLayout dstImageLayout,
uint32 regionCount, uint32 regionCount,
const MemoryImageCopyRegion* pRegions, const MemoryImageCopyRegion* pRegions) = 0;
uint32 flags) = 0;
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 955
void CmdCopyMemoryToImage(
const IGpuMemory& srcGpuMemory,
const IImage& dstImage,
ImageLayout dstImageLayout,
uint32 regionCount,
const MemoryImageCopyRegion* pRegions)
{
CmdCopyMemoryToImage(srcGpuMemory, dstImage, dstImageLayout, regionCount, pRegions, 0);
}
#endif
/// Copies data directly (without format conversion) from an image to a GPU memory object. /// Copies data directly (without format conversion) from an image to a GPU memory object.
/// ///
@@ -4894,25 +4819,14 @@ public:
/// Emulates AQL dispatch with PM4 commands. /// Emulates AQL dispatch with PM4 commands.
/// NOTE: Available for compute queues when created with aqlQueue set in the QueueCreateInfo. /// NOTE: Available for compute queues when created with aqlQueue set in the QueueCreateInfo.
/// ///
/// @param [in] dispatchInfo Pointer to kernel dispatch info /// @param [in] dispatchInfo Pointer to kernel dispatch info
/// @param [out] pFeedback Pointer to the structure where information about the
/// dispatch can be stored if != nullptr.
/// ///
/// @note This function is to support OpenCL AQL submissions. /// @note This function is to support OpenCL AQL submissions.
void CmdDispatchAql( void CmdDispatchAql(
const DispatchAqlParams& dispatchInfo,
DispatchAqlFeedback* pFeedback)
{
m_funcTable.pfnCmdDispatchAql(this, dispatchInfo, pFeedback);
}
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 954
inline void CmdDispatchAql(
const DispatchAqlParams& dispatchInfo) const DispatchAqlParams& dispatchInfo)
{ {
CmdDispatchAql(dispatchInfo, nullptr); m_funcTable.pfnCmdDispatchAql(this, dispatchInfo);
} }
#endif
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 888 #if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 888
/// XDMA was retired starting in gfx10 so this function has no use anymore. /// XDMA was retired starting in gfx10 so this function has no use anymore.
shared/amdgpu-windows-interop/pal/inc/core/palDeveloperHooks.h
+12 -13
Dosyayı Görüntüle
@@ -214,19 +214,18 @@ struct BarrierOperations
{ {
struct struct
{ {
uint16 depthStencilExpand : 1; ///< Decompression of depth/stencil image. uint16 depthStencilExpand : 1; ///< Decompression of depth/stencil image.
uint16 htileHiZRangeExpand : 1; ///< Expansion of HTile's HiZ range. uint16 htileHiZRangeExpand : 1; ///< Expansion of HTile's HiZ range.
uint16 depthStencilResummarize : 1; ///< Resummarization of depth stencil. uint16 depthStencilResummarize : 1; ///< Resummarization of depth stencil.
uint16 dccDecompress : 1; ///< DCC decompress BLT for color images. uint16 dccDecompress : 1; ///< DCC decompress BLT for color images.
uint16 fmaskDecompress : 1; ///< Fmask decompression for shader readability. uint16 fmaskDecompress : 1; ///< Fmask decompression for shader readability.
uint16 fastClearEliminate : 1; ///< Expand latest specified clear color into pixel data for the fast uint16 fastClearEliminate : 1; ///< Expand latest specified clear color into pixel data for the fast
/// cleared color/depth resource. /// cleared color/depth resource.
uint16 fmaskColorExpand : 1; ///< Completely decompresses the specified color resource. uint16 fmaskColorExpand : 1; ///< Completely decompresses the specified color resource.
uint16 initMaskRam : 1; ///< Memsets uninitialized memory to prepare it for use as uint16 initMaskRam : 1; ///< Memsets uninitialized memory to prepare it for use as
/// CMask/FMask/DCC/HTile. /// CMask/FMask/DCC/HTile.
uint16 updateDccStateMetadata : 1; ///< DCC state metadata was updated. uint16 updateDccStateMetadata : 1; ///< DCC state metadata was updated.
uint16 retileGfxDccToDisplayDcc : 1; ///< Gfx dcc is retiled to display dcc. uint16 reserved : 7; ///< Reserved for future use.
uint16 reserved : 6; ///< Reserved for future use.
}; };
uint16 u16All; ///< Unsigned integer containing all the values. uint16 u16All; ///< Unsigned integer containing all the values.
shared/amdgpu-windows-interop/pal/inc/core/palDevice.h
+4 -38
Dosyayı Görüntüle
@@ -583,7 +583,6 @@ struct PalPublicSettings
bool forceLoadObjectFailure; bool forceLoadObjectFailure;
#endif #endif
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 956
/// Controls the distribution mode for tessellation, which affects how patches are processed by different VGT /// Controls the distribution mode for tessellation, which affects how patches are processed by different VGT
/// units. 0: None - No distribution across VGTs (legacy mode). 1: Default - Optimal settings are chosen depending /// units. 0: None - No distribution across VGTs (legacy mode). 1: Default - Optimal settings are chosen depending
/// on the gfxip. 2: Patch - Individual patches are distributed to different VGTs. 3: Donut - Patches are split /// on the gfxip. 2: Patch - Individual patches are distributed to different VGTs. 3: Donut - Patches are split
@@ -591,7 +590,6 @@ struct PalPublicSettings
/// distributed to different VGTs. Falls back to donut mode if HW does not support this mode. 5: Trapezoid only - /// distributed to different VGTs. Falls back to donut mode if HW does not support this mode. 5: Trapezoid only -
/// Distribution turned off if HW does not support this mode. /// Distribution turned off if HW does not support this mode.
uint32 distributionTessMode; uint32 distributionTessMode;
#endif
/// Flags that control PAL optimizations to reduce context rolls. 0: Optimization disabled. 1: Pad parameter cache /// Flags that control PAL optimizations to reduce context rolls. 0: Optimization disabled. 1: Pad parameter cache
/// space. Sets VS export count and PS interpolant number to per-command buffer maximum value. Reduces context rolls /// space. Sets VS export count and PS interpolant number to per-command buffer maximum value. Reduces context rolls
@@ -689,12 +687,10 @@ struct PalPublicSettings
/// Disables MCBP on demand. This is a temporary setting until ATOMIC_MEM packet issue with MCBP is resolved. /// Disables MCBP on demand. This is a temporary setting until ATOMIC_MEM packet issue with MCBP is resolved.
bool disableCommandBufferPreemption; bool disableCommandBufferPreemption;
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 956
/// Disable the fast clear eliminate skipping optimization. This optimization will conservatively track the usage /// Disable the fast clear eliminate skipping optimization. This optimization will conservatively track the usage
/// of clear values to allow the vast majority of images that never clear to a value that isn't TC-compatible to /// of clear values to allow the vast majority of images that never clear to a value that isn't TC-compatible to
/// skip the CPU and front-end GPU overhead of issuing a predicated fast clear eliminate BLT. /// skip the CPU and front-end GPU overhead of issuing a predicated fast clear eliminate BLT.
bool disableSkipFceOptimization; bool disableSkipFceOptimization;
#endif
/// Sets the minimum BPP of surfaces which will have DCC enabled /// Sets the minimum BPP of surfaces which will have DCC enabled
uint32 dccBitsPerPixelThreshold; uint32 dccBitsPerPixelThreshold;
@@ -748,10 +744,8 @@ struct PalPublicSettings
/// 0x12 - Forced Opaque White /// 0x12 - Forced Opaque White
uint32 dccInitialClearKind; uint32 dccInitialClearKind;
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 956
/// Allows the client to not create internal VrsImage. Pal internal will create a 16M image as vrsImageSize. /// Allows the client to not create internal VrsImage. Pal internal will create a 16M image as vrsImageSize.
bool disableInternalVrsImage; bool disableInternalVrsImage;
#endif
/// Allows the client to control binning persistent and context states per bin. /// Allows the client to control binning persistent and context states per bin.
/// A value of 0 tells PAL to pick the number of states per bin. /// A value of 0 tells PAL to pick the number of states per bin.
@@ -1401,17 +1395,9 @@ struct DeviceProperties
/// any compute shader on any queue. /// any compute shader on any queue.
uint32 maxAsyncComputeThreadGroupSize; uint32 maxAsyncComputeThreadGroupSize;
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION >= 951
DispatchDims maxComputeThreadGroupCount; ///< Maximum number of thread groups supported for compute pipelines
DispatchDims maxTaskMeshThreadGroupCount; ///< Maximum number of thread groups supported for task+mesh pipelines
DispatchDims maxMeshThreadGroupCount; ///< Maximum number of thread groups supported for mesh-only pipelines
uint32 maxTaskPayloadSize; ///< Maximum size in bytes of payload passed from task shader to mesh shader
#else
uint32 maxComputeThreadGroupCountX; ///< Maximum number of thread groups supported uint32 maxComputeThreadGroupCountX; ///< Maximum number of thread groups supported
uint32 maxComputeThreadGroupCountY; ///< Maximum number of thread groups supported uint32 maxComputeThreadGroupCountY; ///< Maximum number of thread groups supported
uint32 maxComputeThreadGroupCountZ; ///< Maximum number of thread groups supported uint32 maxComputeThreadGroupCountZ; ///< Maximum number of thread groups supported
#endif
uint32 maxBufferViewStride; ///< Maximum stride, in bytes, that can be specified in a buffer view. uint32 maxBufferViewStride; ///< Maximum stride, in bytes, that can be specified in a buffer view.
@@ -1654,10 +1640,8 @@ struct DeviceProperties
uint32 tessFactorBufSizePerSe; ///< Size of GPU's the tessellatio-factor buffer, per shader engine. uint32 tessFactorBufSizePerSe; ///< Size of GPU's the tessellatio-factor buffer, per shader engine.
uint32 tccSizeInBytes; ///< Size of total L2 TCC cache in bytes. uint32 tccSizeInBytes; ///< Size of total L2 TCC cache in bytes.
uint32 tcpSizeInBytes; ///< Size of one L1 TCP cache in bytes. There is one TCP per CU. uint32 tcpSizeInBytes; ///< Size of one L1 TCP cache in bytes. There is one TCP per CU.
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 959
uint32 maxLateAllocVsLimit; ///< Maximum number of VS waves that can be in flight without uint32 maxLateAllocVsLimit; ///< Maximum number of VS waves that can be in flight without
/// having param cache and position buffer space. /// having param cache and position buffer space.
#endif
uint32 shaderPrefetchBytes; ///< Number of bytes the SQ will prefetch, if any. uint32 shaderPrefetchBytes; ///< Number of bytes the SQ will prefetch, if any.
uint32 gl1cSizePerSa; ///< Size in bytes of GL1 cache per SA. uint32 gl1cSizePerSa; ///< Size in bytes of GL1 cache per SA.
uint32 instCacheSizePerCu; ///< Size in bytes of instruction cache per CU/WGP. uint32 instCacheSizePerCu; ///< Size in bytes of instruction cache per CU/WGP.
@@ -1975,7 +1959,6 @@ struct GpuCompatibilityInfo
uint32 sharedMemory : 1; ///< Devices can share memory objects with. IDevice::OpenSharedMemory(). uint32 sharedMemory : 1; ///< Devices can share memory objects with. IDevice::OpenSharedMemory().
uint32 sharedSync : 1; ///< Devices can share queue semaphores with uint32 sharedSync : 1; ///< Devices can share queue semaphores with
/// IDevice::OpenSharedQueueSemaphore(). /// IDevice::OpenSharedQueueSemaphore().
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 948
uint32 shareThisGpuScreen : 1; ///< Either device can present to this device. Means that the device uint32 shareThisGpuScreen : 1; ///< Either device can present to this device. Means that the device
/// indicated by the otherDevice param in /// indicated by the otherDevice param in
/// IDevice::GetMultiGpuCompatibility() can present to the device the /// IDevice::GetMultiGpuCompatibility() can present to the device the
@@ -1983,9 +1966,6 @@ struct GpuCompatibilityInfo
uint32 shareOtherGpuScreen : 1; ///< Either device can present to the other device. Means that the uint32 shareOtherGpuScreen : 1; ///< Either device can present to the other device. Means that the
/// device IDevice::GetMultiGpuCompatibility() was called on can present /// device IDevice::GetMultiGpuCompatibility() was called on can present
/// to the GPU indicated by the otherGpu param. /// to the GPU indicated by the otherGpu param.
#else
uint32 reserved1 : 2;
#endif
uint32 peerEncode : 1; ///< whether encoding HW can access FB memory of remote GPU in chain uint32 peerEncode : 1; ///< whether encoding HW can access FB memory of remote GPU in chain
uint32 peerDecode : 1; ///< whether decoding HW can access FB memory of remote GPU in chain uint32 peerDecode : 1; ///< whether decoding HW can access FB memory of remote GPU in chain
uint32 peerTransferProtected : 1; ///< whether protected content can be transferred over P2P uint32 peerTransferProtected : 1; ///< whether protected content can be transferred over P2P
@@ -2705,16 +2685,12 @@ struct GetPrimaryInfoOutput
{ {
struct struct
{ {
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 948
/// MGPU flag: this primary surface supports DVO HW compositing mode. /// MGPU flag: this primary surface supports DVO HW compositing mode.
uint32 dvoHwMode : 1; uint32 dvoHwMode : 1;
/// MGPU flag: this primary surface supports XDMA HW compositing mode. /// MGPU flag: this primary surface supports XDMA HW compositing mode.
uint32 xdmaHwMode : 1; uint32 xdmaHwMode : 1;
/// MGPU flag: this primary surface supports client doing SW compositing mode. /// MGPU flag: this primary surface supports client doing SW compositing mode.
uint32 swMode : 1; uint32 swMode : 1;
#else
uint32 reserved1 : 3;
#endif
/// MGPU flag: this primary surface supports freesync. /// MGPU flag: this primary surface supports freesync.
uint32 isFreeSyncEnabled : 1; uint32 isFreeSyncEnabled : 1;
/// Single-GPU flag: gives hint to the client that they should use rotated tiling mode. /// Single-GPU flag: gives hint to the client that they should use rotated tiling mode.
@@ -2761,7 +2737,6 @@ struct SetClockModeInput
DeviceClockMode clockMode; ///< Used to specify the clock mode for the device. DeviceClockMode clockMode; ///< Used to specify the clock mode for the device.
}; };
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 948
/// Specifies primary surface MGPU compositing mode. /// Specifies primary surface MGPU compositing mode.
enum MgpuMode : uint32 enum MgpuMode : uint32
{ {
@@ -2771,9 +2746,7 @@ enum MgpuMode : uint32
MgpuModeXdma = 3, ///< MGPU XDMA HW compositing mode MgpuModeXdma = 3, ///< MGPU XDMA HW compositing mode
MgpuModeCount MgpuModeCount
}; };
#endif
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 943
/// Specifies input arguments for IDevice::SetMgpuMode(). A client set a particular MGPU compositing mode and whether /// Specifies input arguments for IDevice::SetMgpuMode(). A client set a particular MGPU compositing mode and whether
/// frame pacing is enabled for a display. /// frame pacing is enabled for a display.
struct SetMgpuModeInput struct SetMgpuModeInput
@@ -2783,9 +2756,7 @@ struct SetMgpuModeInput
bool isFramePacingEnabled; ///< True if frame pacing enabled. If so, the client creates a timer queue bool isFramePacingEnabled; ///< True if frame pacing enabled. If so, the client creates a timer queue
/// to delay the present, and the delay value is calculated by KMD. /// to delay the present, and the delay value is calculated by KMD.
}; };
#endif
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 948
constexpr uint32 XdmaMaxDevices = 8; ///< Maximum number of Devices for XDMA compositing. constexpr uint32 XdmaMaxDevices = 8; ///< Maximum number of Devices for XDMA compositing.
/// Specifies XDMA cache buffer info for each gpu. /// Specifies XDMA cache buffer info for each gpu.
@@ -2801,7 +2772,6 @@ struct GetXdmaInfoOutput
{ {
XdmaBufferInfo xdmaBufferInfo[XdmaMaxDevices]; ///< Output XDMA cache buffer info XdmaBufferInfo xdmaBufferInfo[XdmaMaxDevices]; ///< Output XDMA cache buffer info
}; };
#endif
/// Specifies flipping status flags on a specific VidPnSource. It's Windows specific. /// Specifies flipping status flags on a specific VidPnSource. It's Windows specific.
union FlipStatusFlags union FlipStatusFlags
@@ -3621,7 +3591,6 @@ public:
virtual Result SetStaticVmidMode( virtual Result SetStaticVmidMode(
bool enable) = 0; bool enable) = 0;
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 943
/// Set up MGPU compositing mode of a display provided by client. /// Set up MGPU compositing mode of a display provided by client.
/// ///
/// This function should not be called by clients that rely on PAL for compositor management. Basically, if your /// This function should not be called by clients that rely on PAL for compositor management. Basically, if your
@@ -3630,11 +3599,9 @@ public:
/// @param [in] setMgpuModeInput Set MGPU compositing mode input arguments. /// @param [in] setMgpuModeInput Set MGPU compositing mode input arguments.
/// ///
/// @returns Success if the MGPU compositing mode were successfully set. /// @returns Success if the MGPU compositing mode were successfully set.
inline Result SetMgpuMode( virtual Result SetMgpuMode(
const SetMgpuModeInput& setMgpuModeInput) const { return Result::Success; } const SetMgpuModeInput& setMgpuModeInput) const = 0;
#endif
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 948
/// Get XDMA cache buffer information of each GPU based upon video present source ID provided by client. /// Get XDMA cache buffer information of each GPU based upon video present source ID provided by client.
/// ///
/// This function should not be called by clients that rely on PAL for compositor management. Basically, if your /// This function should not be called by clients that rely on PAL for compositor management. Basically, if your
@@ -3645,11 +3612,10 @@ public:
/// @param [in,out] pGetXdmaInfoOutput Set XDMA cache buffer info output arguments. /// @param [in,out] pGetXdmaInfoOutput Set XDMA cache buffer info output arguments.
/// ///
/// @returns Success if the XDMA cache buffer information were successfully queried. /// @returns Success if the XDMA cache buffer information were successfully queried.
inline Result GetXdmaInfo( virtual Result GetXdmaInfo(
uint32 vidPnSrcId, uint32 vidPnSrcId,
const IGpuMemory& gpuMemory, const IGpuMemory& gpuMemory,
GetXdmaInfoOutput* pGetXdmaInfoOutput) const { return Result::ErrorUnavailable; } GetXdmaInfoOutput* pGetXdmaInfoOutput) const = 0;
#endif
/// Polls current fullscreen frame metadata controls on given vidPnSourceId, including extended data. /// Polls current fullscreen frame metadata controls on given vidPnSourceId, including extended data.
/// ///
shared/amdgpu-windows-interop/pal/inc/core/palGpuMemory.h
+1 -7
Dosyayı Görüntüle
@@ -133,12 +133,8 @@ union GpuMemoryCreateFlags
/// indicating the driver must manage both /// indicating the driver must manage both
/// CPU caches and GPU caches that are not flushed on /// CPU caches and GPU caches that are not flushed on
/// command buffer boundaries. /// command buffer boundaries.
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 948
uint64 xdmaBuffer : 1; ///< GPU memory will be used for an XDMA cache buffer for uint64 xdmaBuffer : 1; ///< GPU memory will be used for an XDMA cache buffer for
/// transferring data /// transferring data
#else
uint64 reserved1 : 1; ///< Delete this bit when the MAJOR_VERSION backcompat is removed.
#endif
/// between GPUs in a multi-GPU configuration. /// between GPUs in a multi-GPU configuration.
uint64 turboSyncSurface : 1; ///< The memory will be used for TurboSync private swapchain primary. uint64 turboSyncSurface : 1; ///< The memory will be used for TurboSync private swapchain primary.
uint64 typedBuffer : 1; ///< GPU memory will be permanently considered a single uint64 typedBuffer : 1; ///< GPU memory will be permanently considered a single
@@ -207,9 +203,7 @@ union GpuMemoryCreateFlags
#endif #endif
uint64 directCaptureSource : 1; ///< Memory will be mapped to DirectCapture resource's KMD-managed uint64 directCaptureSource : 1; ///< Memory will be mapped to DirectCapture resource's KMD-managed
/// private VA. /// private VA.
uint64 videoEncoder : 1; ///< Video encoder output butffer stream. uint64 reserved : 28; ///< Reserved for future use.
uint64 videoDecoder : 1; ///< Video decoder input butffer stream.
uint64 reserved : 26; ///< Reserved for future use.
}; };
uint64 u64All; ///< Flags packed as 64-bit uint. uint64 u64All; ///< Flags packed as 64-bit uint.
}; };
shared/amdgpu-windows-interop/pal/inc/core/palImage.h
+3 -49
Dosyayı Görüntüle
@@ -96,7 +96,7 @@ enum class MetadataMode : uint16
{ {
Default = 0, ///< Default behavior. PAL chooses if metadata should be present or not. Default = 0, ///< Default behavior. PAL chooses if metadata should be present or not.
ForceEnabled, ///< Optimization Hint: The client would prefer Metadata if possible. Useful for scenarios where ForceEnabled, ///< Optimization Hint: The client would prefer Metadata if possible. Useful for scenarios where
/// metadata isn't an obvious win and clients can enable based on some heuristic or app-detect. /// metadata isn't an obvious win and clients can enable based on some hueristic or app-detect.
Disabled, ///< The Image will not contain any compression metadata. Disabled, ///< The Image will not contain any compression metadata.
FmaskOnly, ///< The color msaa Image will only contain Cmask/Fmask metadata; this mode is only valid for color FmaskOnly, ///< The color msaa Image will only contain Cmask/Fmask metadata; this mode is only valid for color
/// msaa Image. On GPUs with GFX12-style distributed compression (see supportDistributedCompression /// msaa Image. On GPUs with GFX12-style distributed compression (see supportDistributedCompression
@@ -186,12 +186,8 @@ union ImageCreateFlags
/// "Uninitialized" state at any time. Otherwise, both planes must be /// "Uninitialized" state at any time. Otherwise, both planes must be
/// transitioned in the same barrier call. Only meaningful if /// transitioned in the same barrier call. Only meaningful if
/// "perSubresInit" is set. /// "perSubresInit" is set.
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 957
uint32 repetitiveResolve : 1; ///< Optimization: Is this image resolved multiple times to an image which uint32 repetitiveResolve : 1; ///< Optimization: Is this image resolved multiple times to an image which
/// is mostly similar to this image? /// is mostly similar to this image?
#else
uint32 reservedRepResolve : 1; ///< Reserved for future use.
#endif
uint32 preferSwizzleEqs : 1; ///< Image prefers valid swizzle equations, but an invalid swizzle uint32 preferSwizzleEqs : 1; ///< Image prefers valid swizzle equations, but an invalid swizzle
/// equation is also acceptable. /// equation is also acceptable.
uint32 fixedTileSwizzle : 1; ///< Fix this image's tile swizzle to ImageCreateInfo::tileSwizzle. This uint32 fixedTileSwizzle : 1; ///< Fix this image's tile swizzle to ImageCreateInfo::tileSwizzle. This
@@ -204,14 +200,10 @@ union ImageCreateFlags
uint32 fullResolveDstOnly : 1; ///< Indicates any ICmdBuffer::CmdResolveImage using this image as a uint32 fullResolveDstOnly : 1; ///< Indicates any ICmdBuffer::CmdResolveImage using this image as a
/// desination will overwrite the entire image (width and height of /// desination will overwrite the entire image (width and height of
/// resolve region is same as width and height of resolve dst). /// resolve region is same as width and height of resolve dst).
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 960
uint32 fullCopyDstOnly : 1; ///< Indicates any copy to this image will overwrite the entire image. uint32 fullCopyDstOnly : 1; ///< Indicates any copy to this image will overwrite the entire image.
/// A perf optimization of using post-copy metadata fixup to replace heavy /// A perf optimization of using post-copy metadata fixup to replace heavy
/// expand at barrier to LayoutCopyDst. Unsafe to enable it if there is /// expand at barrier to LayoutCopyDst. Unsafe to enable it if there is
/// potential partial copy to the image. /// potential partial copy to the image.
#else
uint32 reserved956 : 1;
#endif
uint32 pipSwapChain : 1; ///< Indicates this image is PIP swap-chain. It is only supported on uint32 pipSwapChain : 1; ///< Indicates this image is PIP swap-chain. It is only supported on
/// Windows platforms. /// Windows platforms.
uint32 view3dAs2dArray : 1; ///< If set client can view 3D image as 2D with its depth as array slices. uint32 view3dAs2dArray : 1; ///< If set client can view 3D image as 2D with its depth as array slices.
@@ -274,8 +266,7 @@ union ImageUsageFlags
///< for this image. ///< for this image.
uint32 vrsRateImage : 1; ///< This image is potentially used with CmdBindSampleRateImage uint32 vrsRateImage : 1; ///< This image is potentially used with CmdBindSampleRateImage
uint32 videoDecoder : 1; ///< Indicating this Image is video decoder target uint32 videoDecoder : 1; ///< Indicating this Image is video decoder target
uint32 videoEncoder : 1; ///< Indicating this Image is video encoder input. uint32 reserved : 12; ///< Reserved for future use.
uint32 reserved : 11; ///< Reserved for future use.
}; };
uint32 u32All; ///< Flags packed as 32-bit uint. uint32 u32All; ///< Flags packed as 32-bit uint.
}; };
@@ -824,12 +815,6 @@ public:
/// @returns the reference to ImageCreateInfo /// @returns the reference to ImageCreateInfo
virtual const ImageMemoryLayout& GetMemoryLayout() const = 0; virtual const ImageMemoryLayout& GetMemoryLayout() const = 0;
/// Reports information on the full range of the image's subresources.
///
/// @returns Reports info on the full range of the image's subresources such as number of mips and planes.
virtual SubresRange GetFullSubresourceRange() const = 0;
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 953
/// Reports information on the full range of the image's subresources. /// Reports information on the full range of the image's subresources.
/// ///
/// @param [out] pRange Reports info on the full range of the image's subresources such as number of mips and /// @param [out] pRange Reports info on the full range of the image's subresources such as number of mips and
@@ -838,17 +823,7 @@ public:
/// @returns Success if the layout was successfully reported. Otherwise, one of the following error codes may be /// @returns Success if the layout was successfully reported. Otherwise, one of the following error codes may be
/// returned: /// returned:
/// + ErrorInvalidPointer if pRange is null. /// + ErrorInvalidPointer if pRange is null.
Result GetFullSubresourceRange(SubresRange* pRange) const virtual Result GetFullSubresourceRange(SubresRange* pRange) const = 0;
{
Result result = Result::ErrorInvalidPointer;
if (pRange != nullptr)
{
*pRange = GetFullSubresourceRange();
result = Result::Success;
}
return result;
}
#endif
/// Reports information on the layout of the specified subresource in memory. /// Reports information on the layout of the specified subresource in memory.
/// ///
@@ -984,27 +959,6 @@ public:
const ImageCopyRegion* pImgRegions, const ImageCopyRegion* pImgRegions,
const uint32 regionCount) const = 0; const uint32 regionCount) const = 0;
/// Check if the provided layout transition is compatible (no layout transition blt necessary) or not (requires
/// layout transition blt).
///
/// @param [in] subresRange Image subresource range.
/// @param [in] oldLayout Specifies the current image layout based on bitmasks of allowed operations and
/// engines up to this point. These masks imply the previous compression state. No
/// usage flags should ever be set in oldLayout.usages that correspond to usages
/// that are not supported by the engine that is performing the transition. The engine
/// type performing the transition must be set in oldLayout.engines.
/// @param [in] newLayout Specifies the upcoming image layout based on bitmasks of allowed operations and
/// engines after this point. These masks imply the upcoming compression state.
/// A difference between oldLayoutUsageMask and newLayoutUsageMask may result in layout
/// transition blt (e.g. decompression) and returns compatible = false.
///
/// @returns True if the layout transition is compatible which indicates no need layout transition blt.
/// False otherwise if layout transition is incompatible and requires layout transition blt.
virtual bool IsLayoutTransitionCompatible(
const SubresRange subresRange,
const ImageLayout oldLayout,
const ImageLayout newLayout) const = 0;
protected: protected:
/// @internal Constructor. /// @internal Constructor.
/// ///
shared/amdgpu-windows-interop/pal/inc/core/palLib.h
+1 -3
Dosyayı Görüntüle
@@ -43,7 +43,7 @@
/// compatible, it is assumed that the client will default-initialize all structs. /// compatible, it is assumed that the client will default-initialize all structs.
/// ///
/// @ingroup LibInit /// @ingroup LibInit
#define PAL_INTERFACE_MAJOR_VERSION 960 #define PAL_INTERFACE_MAJOR_VERSION 942
/// Minimum major interface version. This is the minimum interface version PAL supports in order to support backward /// Minimum major interface version. This is the minimum interface version PAL supports in order to support backward
/// compatibility. When it is equal to PAL_INTERFACE_MAJOR_VERSION, only the latest interface version is supported. /// compatibility. When it is equal to PAL_INTERFACE_MAJOR_VERSION, only the latest interface version is supported.
@@ -112,8 +112,6 @@ enum class NullGpuId : uint32
Navi44, ///< 12.0.0 Navi44, ///< 12.0.0
Navi48, ///< 12.0.1 Navi48, ///< 12.0.1
#if (PAL_CLIENT_INTERFACE_MAJOR_VERSION>= 888) #if (PAL_CLIENT_INTERFACE_MAJOR_VERSION>= 888)
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 958
#endif
#endif #endif
Max, ///< The maximum count of null devices. Max, ///< The maximum count of null devices.
All, ///< If you want to enumerate all null devices. All, ///< If you want to enumerate all null devices.
shared/amdgpu-windows-interop/pal/inc/core/palPerfExperiment.h
+7 -2
Dosyayı Görüntüle
@@ -343,9 +343,12 @@ struct ThreadTraceInfo
uint32 threadTraceTokenConfig : 1; uint32 threadTraceTokenConfig : 1;
uint32 threadTraceStallAllSimds : 1; uint32 threadTraceStallAllSimds : 1;
uint32 threadTraceExcludeNonDetailShaderData : 1; uint32 threadTraceExcludeNonDetailShaderData : 1;
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION >= 899
uint32 threadTraceEnableExecPop : 1; uint32 threadTraceEnableExecPop : 1;
uint32 placeholder3 : 1; #else
uint32 reserved : 15; uint32 placeholder2 : 1;
#endif
uint32 reserved : 16;
}; };
uint32 u32All; uint32 u32All;
} optionFlags; } optionFlags;
@@ -370,7 +373,9 @@ struct ThreadTraceInfo
uint32 threadTraceStallBehavior; uint32 threadTraceStallBehavior;
bool threadTraceStallAllSimds; bool threadTraceStallAllSimds;
bool threadTraceExcludeNonDetailShaderData; bool threadTraceExcludeNonDetailShaderData;
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION >= 899
bool threadTraceEnableExecPop; bool threadTraceEnableExecPop;
#endif
} optionValues; } optionValues;
}; };
shared/amdgpu-windows-interop/pal/inc/core/palPipeline.h
+1 -14
Dosyayı Görüntüle
@@ -218,15 +218,10 @@ enum class DepthClampMode : uint32
{ {
Viewport = 0x0, ///< Clamps to the viewport min/max depth bounds Viewport = 0x0, ///< Clamps to the viewport min/max depth bounds
_None = 0x1, ///< Disables depth clamping _None = 0x1, ///< Disables depth clamping
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 950 #if PAL_BUILD_SUPPORT_DEPTHCLAMPMODE_ZERO_TO_ONE
ZeroToOne = 0x2, ///< Clamps between 0.0 and 1.0. ZeroToOne = 0x2, ///< Clamps between 0.0 and 1.0.
UserDefined = 0x3, ///< Clamps based on ViewportParams::userDepthClamp.
#else
UserDefined = 0x2, ///< Clamps based on ViewportParams::userDepthClamp.
#endif #endif
/// @note Do not add entries 0x4 or higher. DynamicGraphicsState::depthClampMode is a 2-bit field.
// Unfortunately for Linux clients, X.h includes a "#define None 0" macro. Clients have their choice of either // Unfortunately for Linux clients, X.h includes a "#define None 0" macro. Clients have their choice of either
// undefing None before including this header or using _None when dealing with PAL. // undefing None before including this header or using _None when dealing with PAL.
#ifndef None #ifndef None
@@ -419,20 +414,12 @@ struct GraphicsPipelineCreateInfo
size_t pipelineBinarySize; ///< Size of Pipeline ELF binary in bytes. size_t pipelineBinarySize; ///< Size of Pipeline ELF binary in bytes.
const IShaderLibrary** ppShaderLibraries; ///< An array of graphics @ref IShaderLibrary object. pPipelineBinary const IShaderLibrary** ppShaderLibraries; ///< An array of graphics @ref IShaderLibrary object. pPipelineBinary
/// and ppShaderLibraries can't be valid at the same time. /// and ppShaderLibraries can't be valid at the same time.
/// If the client does not know whether the pipeline is complete,
/// it can add the shader library for a "dummy partial pipeline" to
/// the end of the array to ensure the pipeline is complete.
/// In practice, "complete" means "has a PS on hardware that requires
/// it", although that is an implementation detail that the client
/// does not need to know.
size_t numShaderLibraries; ///< Number of graphics shaderLibrary object in ppShaderLibraries. size_t numShaderLibraries; ///< Number of graphics shaderLibrary object in ppShaderLibraries.
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 959
bool useLateAllocVsLimit; ///< If set, use the specified lateAllocVsLimit instead of PAL internally bool useLateAllocVsLimit; ///< If set, use the specified lateAllocVsLimit instead of PAL internally
/// determining the limit. /// determining the limit.
uint32 lateAllocVsLimit; ///< The number of VS waves that can be in flight without having param uint32 lateAllocVsLimit; ///< The number of VS waves that can be in flight without having param
/// cache and position buffer space. If useLateAllocVsLimit flag is set, /// cache and position buffer space. If useLateAllocVsLimit flag is set,
/// PAL will use this limit instead of the PAL-specified limit. /// PAL will use this limit instead of the PAL-specified limit.
#endif
bool useLateAllocGsLimit; ///< If set, use the specified lateAllocVsLimit instead of PAL internally bool useLateAllocGsLimit; ///< If set, use the specified lateAllocVsLimit instead of PAL internally
/// determining the limit. /// determining the limit.
uint32 lateAllocGsLimit; ///< Controls GS LateAlloc val (for pos/prim allocations NOT param cache) uint32 lateAllocGsLimit; ///< Controls GS LateAlloc val (for pos/prim allocations NOT param cache)
shared/amdgpu-windows-interop/pal/inc/core/palPlatform.h
+2 -6
Dosyayı Görüntüle
@@ -168,7 +168,6 @@ enum class ApplicationProfileClient : uint32
Count Count
}; };
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 948
/// Describes a primary surface view /// Describes a primary surface view
/// ///
/// @see IPlatform::GetPrimaryLayout() /// @see IPlatform::GetPrimaryLayout()
@@ -199,7 +198,6 @@ struct GetPrimaryLayoutOutput
uint32 u32All; ///< Flags packed as 32-bit uint. uint32 u32All; ///< Flags packed as 32-bit uint.
} flags; ///< specifies primary surface layout flags. } flags; ///< specifies primary surface layout flags.
}; };
#endif
/// Specifies TurboSync control mode /// Specifies TurboSync control mode
enum class TurboSyncControlMode : uint32 enum class TurboSyncControlMode : uint32
@@ -465,7 +463,6 @@ public:
/// @returns A reference to a PalPlatformSettings structure. /// @returns A reference to a PalPlatformSettings structure.
virtual const PalPlatformSettings& PlatformSettings() const = 0; virtual const PalPlatformSettings& PlatformSettings() const = 0;
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 948
/// Get primary surface layout based upon VidPnSource provided by client. /// Get primary surface layout based upon VidPnSource provided by client.
/// ///
/// This function is used by client to query the layout of the primary surface. The layout describes how primary /// This function is used by client to query the layout of the primary surface. The layout describes how primary
@@ -484,10 +481,9 @@ public:
/// + ErrorInvalidValue if pPrimaryLayoutOutput is invalid. /// + ErrorInvalidValue if pPrimaryLayoutOutput is invalid.
/// + ErrorUnavailable if no implementation on current platform. /// + ErrorUnavailable if no implementation on current platform.
/// + ErrorOutOfMemory if there is not enough system memory. /// + ErrorOutOfMemory if there is not enough system memory.
inline Result GetPrimaryLayout( virtual Result GetPrimaryLayout(
uint32 vidPnSourceId, uint32 vidPnSourceId,
GetPrimaryLayoutOutput* pPrimaryLayoutOutput) { return Result::ErrorUnavailable; } GetPrimaryLayoutOutput* pPrimaryLayoutOutput) = 0;
#endif
/// Calls TurboSyncControl escape to control TurboSync on specific vidPnSourceId. /// Calls TurboSyncControl escape to control TurboSync on specific vidPnSourceId.
/// ///
shared/amdgpu-windows-interop/pal/inc/core/palShaderLibrary.h
+3 -5
Dosyayı Görüntüle
@@ -92,11 +92,9 @@ struct ShaderLibraryCreateInfo
/// Reports properties of a compiled library. /// Reports properties of a compiled library.
struct LibraryInfo struct LibraryInfo
{ {
PipelineHash internalLibraryHash; ///< 128-bit identifier extracted from this library's ELF binary, composed of PipelineHash internalLibraryHash; ///< 128-bit identifier extracted from this library's ELF binary, composed of
/// the state the compiler decided was appropriate to identify the compiled /// the state the compiler decided was appropriate to identify the compiled
/// library. The lower 64 bits are "stable"; the upper 64 bits are "unique". /// library. The lower 64 bits are "stable"; the upper 64 bits are "unique".
Util::StringView<char> colorExports; ///< For a Graphics Partial Pipeline pixel shader, an opaque
/// string to pass to the compiler to build the color export shader.
}; };
/// Reports shader stats. Multiple bits set in the shader stage mask indicates that multiple shaders have been combined /// Reports shader stats. Multiple bits set in the shader stage mask indicates that multiple shaders have been combined
shared/amdgpu-windows-interop/pal/inc/gpuUtil/palCodeObjectTraceSource.h
-2
Dosyayı Görüntüle
@@ -147,9 +147,7 @@ public:
Pal::Result UnregisterElfBinary(const ElfBinaryInfo& elfBinaryInfo); Pal::Result UnregisterElfBinary(const ElfBinaryInfo& elfBinaryInfo);
// ==== Base Class Overrides =================================================================================== // // ==== Base Class Overrides =================================================================================== //
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < COMPRESSION_ARG_VERSION
virtual void OnConfigUpdated(DevDriver::StructuredValue* pJsonConfig) override { } virtual void OnConfigUpdated(DevDriver::StructuredValue* pJsonConfig) override { }
#endif
virtual Pal::uint64 QueryGpuWorkMask() const override { return 0; } virtual Pal::uint64 QueryGpuWorkMask() const override { return 0; }
shared/amdgpu-windows-interop/pal/inc/gpuUtil/palGpaSession.h
+4
Dosyayı Görüntüle
@@ -278,7 +278,11 @@ struct GpaSampleConfig
Pal::uint32 stallAllSimds : 1; ///< Stall all SIMDs for thread trace stall. Pal::uint32 stallAllSimds : 1; ///< Stall all SIMDs for thread trace stall.
Pal::uint32 excludeNonDetailShaderData : 1; ///< Only emit shader tokens from the SIMD that have been Pal::uint32 excludeNonDetailShaderData : 1; ///< Only emit shader tokens from the SIMD that have been
/// selected for detail instruction tracing /// selected for detail instruction tracing
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION >= 899
Pal::uint32 enableExecPopTokens : 1; ///< Output exec tokens Pal::uint32 enableExecPopTokens : 1; ///< Output exec tokens
#else
Pal::uint32 placeholder2 : 1;
#endif
Pal::uint32 reserved : 25; ///< Reserved for future use. Pal::uint32 reserved : 25; ///< Reserved for future use.
}; };
Pal::uint32 u32All; ///< Bit flags packed as uint32. Pal::uint32 u32All; ///< Bit flags packed as uint32.
shared/amdgpu-windows-interop/pal/inc/gpuUtil/palQueueTimingsTraceSource.h
+1 -3
Dosyayı Görüntüle
@@ -186,9 +186,7 @@ public:
bool IsTimingInProgress() const; bool IsTimingInProgress() const;
// ==== Base Class Overrides =================================================================================== // // ==== Base Class Overrides =================================================================================== //
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION < COMPRESSION_ARG_VERSION virtual void OnConfigUpdated(DevDriver::StructuredValue* pJsonConfig) override { };
virtual void OnConfigUpdated(DevDriver::StructuredValue* pJsonConfig) override { }
#endif
virtual Pal::uint64 QueryGpuWorkMask() const override { return 0; } virtual Pal::uint64 QueryGpuWorkMask() const override { return 0; }
shared/amdgpu-windows-interop/pal/inc/gpuUtil/palRenderOpTraceController.h
-5
Dosyayı Görüntüle
@@ -97,11 +97,6 @@ public:
/// the trace controller may advance its state. /// the trace controller may advance its state.
void RecordRenderOps(Pal::IQueue* pQueue, const RenderOpCounts& renderOpCounts); void RecordRenderOps(Pal::IQueue* pQueue, const RenderOpCounts& renderOpCounts);
// Force a controller update
virtual void OnUpdated() override { OnRenderOpUpdated(0); }
virtual Pal::IQueue* GetTraceQueue() const override { return m_pQueue; }
private: private:
/// Controls whether the trace proceeds on absolute render op counts or relative /// Controls whether the trace proceeds on absolute render op counts or relative
enum class CaptureMode : Pal::uint8 enum class CaptureMode : Pal::uint8
shared/amdgpu-windows-interop/pal/inc/gpuUtil/palTraceSession.h
+11 -103
Dosyayı Görüntüle
@@ -38,7 +38,6 @@
#include "palHashMap.h" #include "palHashMap.h"
#include "palMutex.h" #include "palMutex.h"
#include "palPipeline.h" #include "palPipeline.h"
#include "palQueue.h"
#include "palSysMemory.h" #include "palSysMemory.h"
#include "palGpuMemory.h" #include "palGpuMemory.h"
#include "palMemTrackerImpl.h" #include "palMemTrackerImpl.h"
@@ -57,7 +56,6 @@ class StructuredValue;
namespace GpuUtil namespace GpuUtil
{ {
class TraceSession;
class ITraceController; class ITraceController;
class ITraceSource; class ITraceSource;
@@ -84,18 +82,17 @@ enum class TraceSessionState : Pal::uint32
Ready = 0, ///< New trace ready to begin Ready = 0, ///< New trace ready to begin
Requested = 1, ///< A trace has been requested and awaiting acceptance Requested = 1, ///< A trace has been requested and awaiting acceptance
Preparing = 2, ///< Trace has been accepted and is preparing resources before beginning Preparing = 2, ///< Trace has been accepted and is preparing resources before beginning
Beginning = 3, ///< Commands are now being submitted to the GPU to begin tracing Running = 3, ///< Trace is in progress
Running = 4, ///< Trace is in progress
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION >= 939 #if PAL_CLIENT_INTERFACE_MAJOR_VERSION >= 939
Postamble = 5, ///< The detailed frame trace has ended but its data has not yet been written Postamble = 4, ///< The detailed frame trace has ended but its data has not yet been written
/// into the session. Some trace sources may still collect data during this time. /// into the session. Some trace sources may still collect data during this time.
PostambleWaiting = 6, ///< Waiting for Postamble to complete. PostambleWaiting = 5, ///< Waiting for Postamble to complete.
Completed = 7, ///< Trace has fully completed. RDF trace data is ready to be pulled out by CollectTrace().
Count = 8
#else
Waiting = 5, ///< Trace has ended, but data has not been written into the session
Completed = 6, ///< Trace has fully completed. RDF trace data is ready to be pulled out by CollectTrace(). Completed = 6, ///< Trace has fully completed. RDF trace data is ready to be pulled out by CollectTrace().
Count = 7 Count = 7
#else
Waiting = 4, ///< Trace has ended, but data has not been written into the session
Completed = 5, ///< Trace has fully completed. RDF trace data is ready to be pulled out by CollectTrace().
Count = 6
#endif #endif
}; };
@@ -118,12 +115,6 @@ struct TraceErrorHeader
constexpr char ErrorChunkTextIdentifier[TextIdentifierSize] = "TraceError"; constexpr char ErrorChunkTextIdentifier[TextIdentifierSize] = "TraceError";
constexpr Pal::uint32 ErrorTraceChunkVersion = 1; constexpr Pal::uint32 ErrorTraceChunkVersion = 1;
/// Function type for TraceSession state change callback
typedef void (PAL_STDCALL *TraceStateChangeCallback)(
const TraceSession& pTraceSession,
TraceSessionState newState,
void* pPrivateData);
/** /**
*********************************************************************************************************************** ***********************************************************************************************************************
* @interface ITraceController * @interface ITraceController
@@ -252,25 +243,8 @@ public:
virtual Pal::Result OnEndPostambleGpuWork( virtual Pal::Result OnEndPostambleGpuWork(
Pal::uint32 gpuIndex, Pal::uint32 gpuIndex,
Pal::ICmdBuffer** ppCmdBuf) = 0; Pal::ICmdBuffer** ppCmdBuf) = 0;
/// Called by the associated session to force a controller update and drive the session to completion when there
/// is an insufficient number of update events to accomplish that. This is primarily used in single frame/dispatch
/// captures, during which, the controller won't be automatically updated and we have to force it to return the
/// trace session to a clean state.
virtual void OnUpdated() = 0;
/// Returns the queue tracked in the active trace controller
///
/// Returns the queue used for submitting begin and end-trace gpu-work. The queue is tracked by the active
/// controller
///
/// @returns A valid queue pointer used for submitting gpu-work
//// Or a nullptr if no such queue exists
virtual Pal::IQueue* GetTraceQueue() const = 0;
}; };
#define COMPRESSION_ARG_VERSION 949
/** /**
*********************************************************************************************************************** ***********************************************************************************************************************
* @interface ITraceSource * @interface ITraceSource
@@ -284,23 +258,10 @@ public:
class ITraceSource class ITraceSource
{ {
public: public:
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION >= COMPRESSION_ARG_VERSION
/// Base class constructor
ITraceSource() : m_useCompression(false)
{ }
/// Called by the associated session to update the current trace configuration. Will parse out common config options
/// then pass to OnConfigUpdated to allow derived classes to parse other options.
///
/// @param [in] pJsonConfig Configuration data formatted as json and stored as DevDriver's StructuredValue object
void OnConfigUpdated(DevDriver::StructuredValue* pJsonConfig);
#else
/// Called by the associated session to update the current trace configuration /// Called by the associated session to update the current trace configuration
/// ///
/// @param [in] pJsonConfig Configuration data formatted as json and stored as DevDriver's StructuredValue object /// @param [in] pJsonConfig Configuration data formatted as json and stored as DevDriver's StructuredValue object
virtual void OnConfigUpdated(DevDriver::StructuredValue* pJsonConfig) = 0; virtual void OnConfigUpdated(DevDriver::StructuredValue* pJsonConfig) = 0;
#endif
/// Returns a bitmask that represents which GPUs are relevant to this trace source /// Returns a bitmask that represents which GPUs are relevant to this trace source
/// ///
@@ -394,17 +355,6 @@ public:
/// ///
/// @returns true if multiple instances of this trace sources can co-exist in one session, false otherwise. /// @returns true if multiple instances of this trace sources can co-exist in one session, false otherwise.
virtual bool AllowMultipleInstances() const { return false; } virtual bool AllowMultipleInstances() const { return false; }
#if PAL_CLIENT_INTERFACE_MAJOR_VERSION >= COMPRESSION_ARG_VERSION
protected:
/// Called by OnConfigUpdated to allow derived classes to update the current trace configuration.
/// Default implementation is empty.
///
/// @param [in] pJsonConfig Configuration data formatted as json and stored as DevDriver's StructuredValue object
virtual void OnConfigUpdatedDerived(DevDriver::StructuredValue* pJsonConfig) { }
bool m_useCompression;
#endif
}; };
/** /**
@@ -482,12 +432,6 @@ public:
/// + ErrorUnknown if an internal PAL error occurs. /// + ErrorUnknown if an internal PAL error occurs.
Pal::Result CancelTrace(); Pal::Result CancelTrace();
/// Cancels an invalid trace in progress.
///
/// Cancels traces that have not been cleanly collected cleanly or actively canceled and returns the trace session
/// to a clean state. It forces a controller update, drives the session to completion and discards any trace data.
void CancelInvalidTrace();
/// Cleans up the RDF chunk stream and makes it ready for a new trace again. /// Cleans up the RDF chunk stream and makes it ready for a new trace again.
/// ///
/// @returns Success if the trace session and rdf streams were successfully cleaned up and returned to the /// @returns Success if the trace session and rdf streams were successfully cleaned up and returned to the
@@ -685,7 +629,10 @@ public:
/// Sets the TraceSession state based on external operations /// Sets the TraceSession state based on external operations
/// ///
/// @param [in] sessionState TraceSessionState value to be assigned as the current state /// @param [in] sessionState TraceSessionState value to be assigned as the current state
void SetTraceSessionState(TraceSessionState sessionState); void SetTraceSessionState(TraceSessionState sessionState)
{
m_sessionState = sessionState;
}
/// Returns the current active controller /// Returns the current active controller
/// ///
@@ -743,28 +690,6 @@ public:
/// @return true if a cancelation is in progress. /// @return true if a cancelation is in progress.
bool IsCancelingTrace() const { return m_cancelingTrace; } bool IsCancelingTrace() const { return m_cancelingTrace; }
/// Register a function to be called when the Trace Session state changes.
///
/// @param [in] pfnCallback The function to be called
/// @param [in] pPrivateData A pointer to pass to the callback function when called
///
/// @returns Success if the callback was successfully registered
/// AlreadyExists if the given Callback+PrivateData has already been registered
/// ErrorInvalidValue if the given callback is not valid
Pal::Result RegisterTraceStateChangeCallback(
TraceStateChangeCallback pfnCallback,
void* pPrivateData);
/// Unregister a previously registered Trace Session state change callback.
///
/// @param [in] pfnCallback The function which was previously registered as a callback
/// @param [in] pPrivateData The pointer which is associated with the callback to unregister
///
/// @returns Success if the callback was successfully unregistered
/// NotFound if the given pfnCallback+pPrivateData pair was not found
Pal::Result UnregisterTraceStateChangeCallback(
TraceStateChangeCallback pfnCallback,
void* pPrivateData);
private: private:
typedef Pal::IPlatform TraceAllocator; typedef Pal::IPlatform TraceAllocator;
@@ -808,22 +733,5 @@ private:
size_t m_configDataSize; // Size of the cached trace config buffer size_t m_configDataSize; // Size of the cached trace config buffer
bool m_cancelingTrace; // Indicates that a cancel signal has been received and trace cancelation bool m_cancelingTrace; // Indicates that a cancel signal has been received and trace cancelation
// is in progress. // is in progress.
Util::Mutex m_stateChangeCallbackLock; // RW lock for state change callbacks
// Default capacity for the Trace Session state change callback vector
static constexpr Pal::uint32 TraceStateChangeCallbacksVecDefaultCapacity = 4;
/// The data required to call a state change callback
struct TraceStateChangeCallbackInfo
{
TraceStateChangeCallback pfnCallback;
void* pPrivateData;
};
using TraceStateChangeCallbacksVec = Util::Vector<TraceStateChangeCallbackInfo,
TraceStateChangeCallbacksVecDefaultCapacity,
TraceAllocator>;
TraceStateChangeCallbacksVec m_traceStateChangeCallbacks; // Registered state change callbacks
}; };
} // GpuUtil } // GpuUtil
shared/amdgpu-windows-interop/pal/inc/util/palHashBase.h
+4 -39
Dosyayı Görüntüle
@@ -53,11 +53,11 @@ template<typename Key,
typename AllocFunc, typename AllocFunc,
size_t GroupSize> class HashBase; size_t GroupSize> class HashBase;
/// Pointer hash functor. /// Default hash functor.
/// ///
/// Just directly returns bits 31-6 of the key's first dword. This is a decent hash if the key is a pointer. /// Just directly returns bits 31-6 of the key's first dword. This is a decent hash if the key is a pointer.
template<typename Key> template<typename Key>
struct PointerHashFunc struct DefaultHashFunc
{ {
/// Shifts the key to the right and use the resulting bits as a uint hash. /// Shifts the key to the right and use the resulting bits as a uint hash.
/// ///
@@ -74,7 +74,7 @@ struct PointerHashFunc
void Init(uint32 minNumBits) const void Init(uint32 minNumBits) const
{ {
PAL_ASSERT((Min(sizeof(Key), sizeof(uint32)) * 8) >= (minNumBits + ShiftNum)); PAL_ASSERT((Min(sizeof(Key), sizeof(uint32)) * 8) >= (minNumBits + ShiftNum));
static_assert(std::is_pointer_v<Key>, "Usage of PointerHashFunc for non-pointer types!"); PAL_ALERT_MSG(sizeof(Key) > sizeof(void*), "Usage of DefaultHashFunc for non-pointer types!");
} }
}; };
@@ -147,9 +147,6 @@ struct StringEqualFunc
bool operator()(const Key& key1, const Key& key2) const; bool operator()(const Key& key1, const Key& key2) const;
}; };
template<typename Key>
using DefaultHashFunc = std::conditional_t<std::is_pointer_v<Key>, PointerHashFunc<Key>, JenkinsHashFunc<Key>>;
/** /**
*********************************************************************************************************************** ***********************************************************************************************************************
* @brief Fixed-size, growable, and lazy-free memory pool allocator. * @brief Fixed-size, growable, and lazy-free memory pool allocator.
@@ -372,20 +369,6 @@ public:
/// Empty the hash container. /// Empty the hash container.
void Reset(); void Reset();
/// Removes an entry that matches the specified key.
///
/// @param [in] key Key of the entry to erase.
///
/// @returns True if the erase completed successfully, false if an entry for this key did not exist.
bool Erase(const Key& key);
/// Returns true if the specified key exists in the set.
///
/// @param [in] key Key to search for.
///
/// @returns True if the specified key exists in the set.
bool Contains(const Key& key) const;
protected: protected:
/// @internal Constructor /// @internal Constructor
/// ///
@@ -393,7 +376,7 @@ protected:
/// take (buckets * GroupSize) bytes. /// take (buckets * GroupSize) bytes.
/// @param [in] pAllocator The allocator that will allocate memory if required. /// @param [in] pAllocator The allocator that will allocate memory if required.
explicit HashBase(uint32 numBuckets, Allocator*const pAllocator); explicit HashBase(uint32 numBuckets, Allocator*const pAllocator);
~HashBase() { PAL_SAFE_FREE(m_pMemory, &m_allocator); } virtual ~HashBase() { PAL_SAFE_FREE(m_pMemory, &m_allocator); }
/// @internal Ensures that the hash table has been allocated, then finds the bucket that matches /// @internal Ensures that the hash table has been allocated, then finds the bucket that matches
/// the specified key /// the specified key
@@ -412,24 +395,6 @@ protected:
/// @returns Pointer to the bucket corresponding to the specified key. /// @returns Pointer to the bucket corresponding to the specified key.
Entry* FindBucket(const Key& key) const; Entry* FindBucket(const Key& key) const;
/// @internal Finds a given entry.
///
/// @param [in] key Key to find matching bucket for.
///
/// @returns Pointer to the entry corresponding to the specified key or nullptr.
Entry* FindEntry(const Key& key) const;
/// @internal Finds a given entry; if no entry was found, allocate it.
///
/// @param [in] key Key to search for.
/// @param [out] pExisted True if an entry for the specified key existed before this call was made. False indicates
/// that a new entry was allocated as a result of this call.
/// @param [out] ppValue Readable/writeable value in the hash map corresponding to the specified key.
///
/// @returns @ref Success if the operation completed successfully, or @ref ErrorOutOfMemory if the operation failed
/// because an internal memory allocation failed.
Result FindAllocateEntry(const Key& key, bool* pExisted, Entry** ppValue);
/// @internal Returns pointer to the next group of the specified group. /// @internal Returns pointer to the next group of the specified group.
/// ///
/// @param [in] pGroup Current group to find next group for. /// @param [in] pGroup Current group to find next group for.
shared/amdgpu-windows-interop/pal/inc/util/palHashBaseImpl.h
+2 -196
Dosyayı Görüntüle
@@ -37,9 +37,9 @@ namespace Util
{ {
// ===================================================================================================================== // =====================================================================================================================
// Hash function for pointers. Simply shift the key to the right and use the resulting bits as the hash. // Default hash function implementation. Simply shift the key to the right and use the resulting bits as the hash.
template<typename Key> template<typename Key>
uint32 PointerHashFunc<Key>::operator()( uint32 DefaultHashFunc<Key>::operator()(
const void* pVoidKey, const void* pVoidKey,
uint32 keyLen uint32 keyLen
) const ) const
@@ -460,84 +460,6 @@ void HashBase<Key, Entry, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>:
m_allocator.Reset(); m_allocator.Reset();
} }
// =====================================================================================================================
// Removes an entry with the specified key.
template<typename Key,
typename Entry,
typename Allocator,
typename HashFunc,
typename EqualFunc,
typename AllocFunc,
size_t GroupSize>
bool HashBase<Key, Entry, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::Erase(
const Key& key)
{
// Get the bucket base address.
Entry* pGroup = this->FindBucket(key);
Entry* pFoundEntry = nullptr;
Entry* pLastEntry = nullptr;
Entry* pLastEntryGroup = nullptr;
// Find the entry to delete
while (pGroup != nullptr)
{
const uint32 numEntries = this->GetGroupFooterNumEntries(pGroup);
// Search each group
uint32 i = 0;
for (; i < numEntries; i++)
{
if (this->m_equalFunc(pGroup[i].key, key) == true)
{
// We shouldn't find the same key twice.
PAL_ASSERT(pFoundEntry == nullptr);
pFoundEntry = &(pGroup[i]);
}
// keep track of last entry of all groups in bucket
pLastEntry = &(pGroup[i]);
pLastEntryGroup = pGroup;
}
// Chain to the next entry group.
pGroup = this->GetNextGroup(pGroup);
}
// Copy the last entry's data into the entry that we are removing and invalidate the last entry as it now appears
// earlier in the list. This also handles the case where the entry to be removed is the last entry.
if (pFoundEntry != nullptr)
{
PAL_ASSERT(pLastEntry != nullptr);
*pFoundEntry = std::move(*pLastEntry);
memset(pLastEntry, 0, sizeof(Entry));
PAL_ASSERT(this->m_numEntries > 0);
this->m_numEntries--;
const uint32 numEntries = this->GetGroupFooterNumEntries(pLastEntryGroup);
this->SetGroupFooterNumEntries(pLastEntryGroup, numEntries - 1);
}
return (pFoundEntry != nullptr);
}
// =====================================================================================================================
// Check if the given hashtable contains the given key.
template<typename Key,
typename Entry,
typename Allocator,
typename HashFunc,
typename EqualFunc,
typename AllocFunc,
size_t GroupSize>
bool HashBase<Key, Entry, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::Contains(
const Key& key) const
{
return FindEntry(key) != nullptr;
}
// ===================================================================================================================== // =====================================================================================================================
// Ensures that the hash table has been allocated, then returns pointer to start group of the bucket // Ensures that the hash table has been allocated, then returns pointer to start group of the bucket
// corresponding to the specified key. A return of nullptr means out of memory. // corresponding to the specified key. A return of nullptr means out of memory.
@@ -578,122 +500,6 @@ Entry* HashBase<Key, Entry, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize
return (m_pMemory != nullptr) ? static_cast<Entry*>(VoidPtrInc(m_pMemory, bucket * GroupSize)) : nullptr; return (m_pMemory != nullptr) ? static_cast<Entry*>(VoidPtrInc(m_pMemory, bucket * GroupSize)) : nullptr;
} }
// =====================================================================================================================
// Gets a pointer to the entry that matches the key. Returns null if no entry is present matching the specified key.
template<typename Key,
typename Entry,
typename Allocator,
typename HashFunc,
typename EqualFunc,
typename AllocFunc,
size_t GroupSize>
Entry* HashBase<Key, Entry, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::FindEntry(
const Key& key
) const
{
// Get the bucket base address.
Entry* pGroup = this->FindBucket(key);
Entry* pMatchingEntry = nullptr;
while (pGroup != nullptr)
{
const uint32 numEntries = this->GetGroupFooterNumEntries(pGroup);
// Search this entry group
uint32 i = 0;
for (; i < numEntries; i++)
{
if (this->m_equalFunc(pGroup[i].key, key))
{
// We've found the entry.
pMatchingEntry = &(pGroup[i]);
break;
}
}
if ((pMatchingEntry != nullptr) || (i < EntriesInGroup))
{
break;
}
// Chain to the next entry group.
pGroup = this->GetNextGroup(pGroup);
}
return pMatchingEntry;
}
// =====================================================================================================================
// Gets a pointer to the entry that matches the key. If the key is not present, a pointer to empty space for the value
// is returned.
template<typename Key,
typename Entry,
typename Allocator,
typename HashFunc,
typename EqualFunc,
typename AllocFunc,
size_t GroupSize>
Result HashBase<Key, Entry, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::FindAllocateEntry(
const Key& key, // Key to search for.
bool* pExisted, // [out] True if a matching key was found.
Entry** ppEntry) // [out] Pointer to the value entry of the hash map's entry for the specified key.
{
PAL_ASSERT(pExisted != nullptr);
PAL_ASSERT(ppEntry != nullptr);
Result result = Result::ErrorOutOfMemory;
// Get the bucket base address....
Entry* pGroup = this->InitAndFindBucket(key);
*pExisted = false;
*ppEntry = nullptr;
Entry* pMatchingEntry = nullptr;
while (pGroup != nullptr)
{
const uint32 numEntries = this->GetGroupFooterNumEntries(pGroup);
// Search this entry group.
uint32 i = 0;
for (; i < numEntries; i++)
{
if (this->m_equalFunc(pGroup[i].key, key))
{
// We've found the entry.
pMatchingEntry = &(pGroup[i]);
*pExisted = true;
break;
}
}
// We've reached the end of the allocated buckets and the entry was not found.
// Allocate this entry for the key.
if ((pMatchingEntry == nullptr) && (i < EntriesInGroup))
{
pGroup[i].key = key;
pMatchingEntry = &(pGroup[i]);
this->m_numEntries++;
this->SetGroupFooterNumEntries(pGroup, numEntries + 1);
}
if (pMatchingEntry != nullptr)
{
*ppEntry= pMatchingEntry;
result = Result::Success;
break;
}
// Chain to the next entry group.
pGroup = this->AllocateNextGroup(pGroup);
}
PAL_ASSERT(result == Result::Success);
return result;
}
// ===================================================================================================================== // =====================================================================================================================
// Returns pointer to the next group of the spcified group. // Returns pointer to the next group of the spcified group.
template< template<
shared/amdgpu-windows-interop/pal/inc/util/palHashMap.h
+9 -3
Dosyayı Görüntüle
@@ -57,8 +57,7 @@ struct HashMapEntry
* *
* HashFunc is a functor for hashing keys. Built-in choices for HashFunc are: * HashFunc is a functor for hashing keys. Built-in choices for HashFunc are:
* *
* - DefaultHashFunc: Default hash function, selects best hash function based on type of key. * - DefaultHashFunc: Good choice when the key is a pointer.
* - PointerHashFunc: Good choice when the key is a pointer.
* - JenkinsHashFunc: Good choice when the key is arbitrary binary data. * - JenkinsHashFunc: Good choice when the key is arbitrary binary data.
* - StringJenkinsHashFunc: Good choice when the key is a C-style string. * - StringJenkinsHashFunc: Good choice when the key is a C-style string.
* *
@@ -93,7 +92,7 @@ public:
/// take (buckets * GroupSize) bytes. /// take (buckets * GroupSize) bytes.
/// @param [in] pAllocator Pointer to an allocator that will create system memory requested by this hash container. /// @param [in] pAllocator Pointer to an allocator that will create system memory requested by this hash container.
explicit HashMap(uint32 numBuckets, Allocator*const pAllocator): Base::HashBase(numBuckets, pAllocator) { } explicit HashMap(uint32 numBuckets, Allocator*const pAllocator): Base::HashBase(numBuckets, pAllocator) { }
~HashMap() { } virtual ~HashMap() { }
/// Finds a given entry; if no entry was found, allocate it. /// Finds a given entry; if no entry was found, allocate it.
/// ///
@@ -125,6 +124,13 @@ public:
/// because an internal memory allocation failed. /// because an internal memory allocation failed.
Result Insert(const Key& key, const Value& value); Result Insert(const Key& key, const Value& value);
/// Removes an entry that matches the specified key.
///
/// @param [in] key Key of the entry to erase.
///
/// @returns True if the erase completed successfully, false if an entry for this key did not exist.
bool Erase(const Key& key);
private: private:
// Typedef for the specialized 'HashBase' object we're inheriting from so we can use properly qualified names when // Typedef for the specialized 'HashBase' object we're inheriting from so we can use properly qualified names when
// accessing members of HashBase. // accessing members of HashBase.
shared/amdgpu-windows-interop/pal/inc/util/palHashMapImpl.h
+145 -9
Dosyayı Görüntüle
@@ -55,13 +55,56 @@ Result HashMap<Key, Value, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>
PAL_ASSERT(pExisted != nullptr); PAL_ASSERT(pExisted != nullptr);
PAL_ASSERT(ppValue != nullptr); PAL_ASSERT(ppValue != nullptr);
Entry* pEntry = nullptr; Result result = Result::ErrorOutOfMemory;
Result result = Base::FindAllocateEntry(key, pExisted, &pEntry);
if (result == Result::Success) // Get the bucket base address....
Entry* pGroup = this->InitAndFindBucket(key);
*pExisted = false;
*ppValue = nullptr;
Entry* pMatchingEntry = nullptr;
while (pGroup != nullptr)
{ {
*ppValue = &pEntry->value; const uint32 numEntries = this->GetGroupFooterNumEntries(pGroup);
// Search this entry group.
uint32 i = 0;
for (; i < numEntries; i++)
{
if (this->m_equalFunc(pGroup[i].key, key))
{
// We've found the entry.
pMatchingEntry = &(pGroup[i]);
*pExisted = true;
break;
}
}
// We've reached the end of the allocated buckets and the entry was not found.
// Allocate this entry for the key.
if ((pMatchingEntry == nullptr) && (i < Base::EntriesInGroup))
{
pGroup[i].key = key;
pMatchingEntry = &(pGroup[i]);
this->m_numEntries++;
this->SetGroupFooterNumEntries(pGroup, numEntries + 1);
}
if (pMatchingEntry != nullptr)
{
*ppValue = &(pMatchingEntry->value);
result = Result::Success;
break;
}
// Chain to the next entry group.
pGroup = this->AllocateNextGroup(pGroup);
} }
PAL_ASSERT(result == Result::Success);
return result; return result;
} }
@@ -78,8 +121,36 @@ Value* HashMap<Key, Value, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>
const Key& key const Key& key
) const ) const
{ {
Entry* pEntry = Base::FindEntry(key); // Get the bucket base address.
return (pEntry != nullptr) ? &pEntry->value : nullptr; Entry* pGroup = this->FindBucket(key);
Entry* pMatchingEntry = nullptr;
while (pGroup != nullptr)
{
const uint32 numEntries = this->GetGroupFooterNumEntries(pGroup);
// Search this entry group
uint32 i = 0;
for (; i < numEntries; i++)
{
if (this->m_equalFunc(pGroup[i].key, key))
{
// We've found the entry.
pMatchingEntry = &(pGroup[i]);
break;
}
}
if ((pMatchingEntry != nullptr) || (i < Base::EntriesInGroup))
{
break;
}
// Chain to the next entry group.
pGroup = this->GetNextGroup(pGroup);
}
return (pMatchingEntry != nullptr) ? &(pMatchingEntry->value) : nullptr;
} }
// ===================================================================================================================== // =====================================================================================================================
@@ -96,14 +167,14 @@ Result HashMap<Key, Value, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>
const Value& value) const Value& value)
{ {
bool existed = true; bool existed = true;
Entry* pEntry = nullptr; Value* pValue = nullptr;
Result result = Base::FindAllocateEntry(key, &existed, &pEntry); Result result = FindAllocate(key, &existed, &pValue);
// Add the new value if it did not exist already. If FindAllocate returns Success, pValue != nullptr. // Add the new value if it did not exist already. If FindAllocate returns Success, pValue != nullptr.
if ((result == Result::Success) && (existed == false)) if ((result == Result::Success) && (existed == false))
{ {
pEntry->value = value; *pValue = value;
} }
PAL_ASSERT(result == Result::Success); PAL_ASSERT(result == Result::Success);
@@ -111,4 +182,69 @@ Result HashMap<Key, Value, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>
return result; return result;
} }
// =====================================================================================================================
// Removes an entry with the specified key.
template<typename Key,
typename Value,
typename Allocator,
template<typename> class HashFunc,
template<typename> class EqualFunc,
typename AllocFunc,
size_t GroupSize>
bool HashMap<Key, Value, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::Erase(
const Key& key)
{
// Get the bucket base address.
Entry* pGroup = this->FindBucket(key);
Entry* pFoundEntry = nullptr;
Entry* pLastEntry = nullptr;
Entry* pLastEntryGroup = nullptr;
// Find the entry to delete
while (pGroup != nullptr)
{
const uint32 numEntries = this->GetGroupFooterNumEntries(pGroup);
// Search each group
uint32 i = 0;
for (; i < numEntries; i++)
{
if (this->m_equalFunc(pGroup[i].key, key) == true)
{
// We shouldn't find the same key twice.
PAL_ASSERT(pFoundEntry == nullptr);
pFoundEntry = &(pGroup[i]);
}
// keep track of last entry of all groups in bucket
pLastEntry = &(pGroup[i]);
pLastEntryGroup = pGroup;
}
// Chain to the next entry group.
pGroup = this->GetNextGroup(pGroup);
}
// Copy the last entry's data into the entry that we are removing and invalidate the last entry as it now appears
// earlier in the list. This also handles the case where the entry to be removed is the last entry.
if (pFoundEntry != nullptr)
{
PAL_ASSERT(pLastEntry != nullptr);
pFoundEntry->key = pLastEntry->key;
pFoundEntry->value = pLastEntry->value;
memset(pLastEntry, 0, sizeof(Entry));
PAL_ASSERT(this->m_numEntries > 0);
this->m_numEntries--;
const uint32 numEntries = this->GetGroupFooterNumEntries(pLastEntryGroup);
this->SetGroupFooterNumEntries(pLastEntryGroup, numEntries - 1);
}
return (pFoundEntry != nullptr);
}
} // Util } // Util
shared/amdgpu-windows-interop/pal/inc/util/palHashSet.h
+16 -3
Dosyayı Görüntüle
@@ -56,8 +56,7 @@ struct HashSetEntry
* *
* HashFunc is a functor for hashing keys. Built-in choices for HashFunc are: * HashFunc is a functor for hashing keys. Built-in choices for HashFunc are:
* *
* - DefaultHashFunc: Default hash function, selects best hash function based on type of key. * - DefaultHashFunc: Good choice when the key is a pointer.
* - PointerHashFunc: Good choice when the key is a pointer.
* - JenkinsHashFunc: Good choice when the key is arbitrary binary data. * - JenkinsHashFunc: Good choice when the key is arbitrary binary data.
* - StringJenkinsHashFunc: Good choice when the key is a C-style string. * - StringJenkinsHashFunc: Good choice when the key is a C-style string.
* *
@@ -97,7 +96,7 @@ public:
/// take (buckets * GroupSize) bytes. /// take (buckets * GroupSize) bytes.
/// @param [in] pAllocator Pointer to an allocator that will create system memory requested by this hash container. /// @param [in] pAllocator Pointer to an allocator that will create system memory requested by this hash container.
explicit HashSet(uint32 numBuckets, Allocator*const pAllocator) : Base::HashBase(numBuckets, pAllocator) {} explicit HashSet(uint32 numBuckets, Allocator*const pAllocator) : Base::HashBase(numBuckets, pAllocator) {}
~HashSet() { } virtual ~HashSet() { }
/// Finds a given entry; if no entry was found, allocate it. /// Finds a given entry; if no entry was found, allocate it.
/// ///
@@ -109,6 +108,13 @@ public:
/// @ref ErrorOutOfMemory if the operation failed because an internal memory allocation failed. /// @ref ErrorOutOfMemory if the operation failed because an internal memory allocation failed.
Result FindAllocate(Key** ppKey, bool* pExisted); Result FindAllocate(Key** ppKey, bool* pExisted);
/// Returns true if the specified key exists in the set.
///
/// @param [in] key Key to search for.
///
/// @returns True if the specified key exists in the set.
bool Contains(const Key& key) const;
/// Inserts an entry. /// Inserts an entry.
/// ///
/// No action will be taken if an entry matching this key already exists in the set. /// No action will be taken if an entry matching this key already exists in the set.
@@ -119,6 +125,13 @@ public:
/// because an internal memory allocation failed. /// because an internal memory allocation failed.
Result Insert(const Key& key); Result Insert(const Key& key);
/// Removes an entry that matches the specified key.
///
/// @param [in] key Key of the entry to erase.
///
/// @returns True if the erase completed successfully, false if an entry for this key did not exist.
bool Erase(const Key& key);
private: private:
// Typedef for the specialized 'HashBase' object we're inheriting from so we can use properly qualified names when // Typedef for the specialized 'HashBase' object we're inheriting from so we can use properly qualified names when
// accessing members of HashBase. // accessing members of HashBase.
shared/amdgpu-windows-interop/pal/inc/util/palHashSetImpl.h
+161 -5
Dosyayı Görüntüle
@@ -48,9 +48,14 @@ template<typename Key,
Result HashSet<Key, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::Insert( Result HashSet<Key, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::Insert(
const Key& key) const Key& key)
{ {
Entry* pEntry = nullptr; Key* pKey = const_cast<Key*>(&key);
bool existed = false; bool existed;
return Base::FindAllocateEntry(key, &existed, &pEntry); const Result result = FindAllocate(&pKey, &existed);
if (existed == false)
{
*pKey = key;
}
return result;
} }
// ===================================================================================================================== // =====================================================================================================================
@@ -68,8 +73,159 @@ Result HashSet<Key, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::FindA
PAL_ASSERT(ppKey != nullptr); PAL_ASSERT(ppKey != nullptr);
PAL_ASSERT(pExisted != nullptr); PAL_ASSERT(pExisted != nullptr);
static_assert(offsetof(Entry, key) == 0); Result result = Result::ErrorOutOfMemory;
return Base::FindAllocateEntry(**ppKey, pExisted, reinterpret_cast<Entry**>(ppKey));
// Get the bucket base address.
Entry* pGroup = this->InitAndFindBucket(**ppKey);
Entry* pMatchingEntry = nullptr;
while (pGroup != nullptr)
{
const uint32 numEntries = this->GetGroupFooterNumEntries(pGroup);
// Search this entry group.
uint32 i = 0;
for (; i < numEntries; i++)
{
if (this->m_equalFunc(pGroup[i].key, **ppKey))
{
// We've found the entry.
pMatchingEntry = &(pGroup[i]);
*pExisted = true;
break;
}
}
if ((pMatchingEntry == nullptr) && (i < Base::EntriesInGroup))
{
// We've reached the end of the bucket and the entry was not found. Allocate this entry for the key.
*pExisted = false;
*ppKey = &pGroup[i].key;
pMatchingEntry = &(pGroup[i]);
this->m_numEntries++;
this->SetGroupFooterNumEntries(pGroup, numEntries + 1);
}
if (pMatchingEntry != nullptr)
{
result = Result::Success;
break;
}
// Chain to the next entry group.
pGroup = this->AllocateNextGroup(pGroup);
}
PAL_ASSERT(result == Result::Success);
return result;
}
// =====================================================================================================================
// Searches for the specified key to see if it exists.
template<typename Key,
typename Allocator,
template<typename> class HashFunc,
template<typename> class EqualFunc,
typename AllocFunc,
size_t GroupSize>
bool HashSet<Key, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::Contains(
const Key& key
) const
{
// Get the bucket base address.
Entry* pGroup = this->FindBucket(key);
Entry* pMatchingEntry = nullptr;
while (pGroup != nullptr)
{
const uint32 numEntries = this->GetGroupFooterNumEntries(pGroup);
// Search this entry group.
uint32 i = 0;
for (; i < numEntries; i++)
{
if (this->m_equalFunc(pGroup[i].key, key))
{
// We've found the entry.
pMatchingEntry = &(pGroup[i]);
break;
}
}
if ((pMatchingEntry != nullptr) || (i < Base::EntriesInGroup))
{
break;
}
// Chain to the next entry group.
pGroup = this->GetNextGroup(pGroup);
}
return (pMatchingEntry != nullptr);
}
// =====================================================================================================================
// Removes an entry with the specified key.
template<typename Key,
typename Allocator,
template<typename> class HashFunc,
template<typename> class EqualFunc,
typename AllocFunc,
size_t GroupSize>
bool HashSet<Key, Allocator, HashFunc, EqualFunc, AllocFunc, GroupSize>::Erase(
const Key& key)
{
// Get the bucket base address.
Entry* pGroup = this->FindBucket(key);
Entry* pFoundEntry = nullptr;
Entry* pLastEntry = nullptr;
Entry* pLastEntryGroup = nullptr;
// Find the entry to delete.
while ((pGroup != nullptr))
{
const uint32 numEntries = this->GetGroupFooterNumEntries(pGroup);
// Search this entry
uint32 i = 0;
for (; i < numEntries; i++)
{
if (this->m_equalFunc(pGroup[i].key, key) == true)
{
// We shouldn't find the same key twice.
PAL_ASSERT(pFoundEntry == nullptr);
pFoundEntry = &(pGroup[i]);
}
// keep track of last entry of all groups in bucket
pLastEntry = &(pGroup[i]);
pLastEntryGroup = pGroup;
}
// Chain to the next entry group
pGroup = this->GetNextGroup(pGroup);
}
// Copy the last entry's data into the entry that we are removing and invalidate the last entry as it now appears
// earlier in the list. This also handles the case where the entry to be removed is the last entry.
if (pFoundEntry != nullptr)
{
PAL_ASSERT(pLastEntry != nullptr);
pFoundEntry->key = pLastEntry->key;
memset(pLastEntry, 0, sizeof(Entry));
PAL_ASSERT(this->m_numEntries > 0);
this->m_numEntries--;
const uint32 numEntries = this->GetGroupFooterNumEntries(pLastEntryGroup);
this->SetGroupFooterNumEntries(pLastEntryGroup, numEntries - 1);
}
return (pFoundEntry != nullptr);
} }
} // Util } // Util
shared/amdgpu-windows-interop/pal/inc/util/palUtil.h
-12
Dosyayı Görüntüle
@@ -99,7 +99,6 @@ static_assert(false, "Clients may not define macros named \"min\" or \"max\".");
// Equates to [__declspec(align(__x))](https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/align-cpp.md) on Windows. // Equates to [__declspec(align(__x))](https://github.com/MicrosoftDocs/cpp-docs/blob/master/docs/cpp/align-cpp.md) on Windows.
#define PAL_ALIGN(__x) __declspec(align(__x)) #define PAL_ALIGN(__x) __declspec(align(__x))
#define PAL_FORCE_INLINE __forceinline #define PAL_FORCE_INLINE __forceinline
#define PAL_NO_INLINE __declspec(noinline)
#else #else
/// Undefined on GCC platforms. /// Undefined on GCC platforms.
#define PAL_STDCALL #define PAL_STDCALL
@@ -108,7 +107,6 @@ static_assert(false, "Clients may not define macros named \"min\" or \"max\".");
/// Undefined on GCC platforms. /// Undefined on GCC platforms.
#define PAL_ALIGN(__x) #define PAL_ALIGN(__x)
#define PAL_FORCE_INLINE __attribute__((always_inline)) inline #define PAL_FORCE_INLINE __attribute__((always_inline)) inline
#define PAL_NO_INLINE __attribute__((noinline))
#endif #endif
/// Platform cache line size in bytes. /// Platform cache line size in bytes.
@@ -601,16 +599,6 @@ constexpr bool IsErrorResult(Result result) { return (static_cast<int32>(result)
constexpr Result CollapseResults(Result lhs, Result rhs) constexpr Result CollapseResults(Result lhs, Result rhs)
{ return (IsErrorResult(lhs) || (static_cast<uint32>(lhs) > static_cast<uint32>(rhs))) ? lhs : rhs; } { return (IsErrorResult(lhs) || (static_cast<uint32>(lhs) > static_cast<uint32>(rhs))) ? lhs : rhs; }
/// A simple enum-to-string helper function. Given a result like Result::ErrorOutOfMemory, it returns a pointer to a
/// global string containing "ErrorOutOfMemory". The caller must not try to free the returned string.
///
/// @param [in] result The Result code to turn into a string.
///
/// @returns A valid pointer to the appropriate global string or to "FixTheTables!!!" if someone forgot to update the
/// internal string tables when they added a new Result value. It's impossible for this to return nullptr.
extern const char* ResultToString(
Result result);
/** /**
*********************************************************************************************************************** ***********************************************************************************************************************
* @page UtilOverview Utility Collection * @page UtilOverview Utility Collection
shared/amdgpu-windows-interop/pal/lib/Release/x64/DriverUtilsService.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 99a0c403b1f71c5d5837c25874f0a270 - md5: fd5f7481a122f40f73d1f638e3b9b027
size: 130 size: 16738
hash: md5 hash: md5
path: DriverUtilsService.lib path: DriverUtilsService.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/SettingsRpcService2.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: b8765422699642586b41f2f346b89236 - md5: e09dbb1896128ac2b2bcac2b35878a40
size: 129 size: 9460
hash: md5 hash: md5
path: SettingsRpcService2.lib path: SettingsRpcService2.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/UberTraceService.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 559a03f0105295747eea440ad9ad1e32 - md5: 364bc94b5b81ef5bb337e6afb0060c55
size: 130 size: 13912
hash: md5 hash: md5
path: UberTraceService.lib path: UberTraceService.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/addrlib.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: fb0920f5343de93cd4530c145e3f35f3 - md5: 56362998d9feb9b0ce6ccad8441bf1c8
size: 131 size: 820446
hash: md5 hash: md5
path: addrlib.lib path: addrlib.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/amdrdf.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 08d2d9b8535d06b5b621f4c40b3b9393 - md5: 35af646710d883bfe6184113cb88e96a
size: 131 size: 702568
hash: md5 hash: md5
path: amdrdf.lib path: amdrdf.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/cwpack.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 37d5258a4bb3e9cf7cffc3c1569503a8 - md5: 06c7697ce380a8127e7478041aed7fc8
size: 130 size: 27894
hash: md5 hash: md5
path: cwpack.lib path: cwpack.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddCommon.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 8b15abd3b8618e8b70ee2549a9002dcf - md5: 7c6ba83c44ee8bd70397a1458dbea7e0
size: 130 size: 82210
hash: md5 hash: md5
path: ddCommon.lib path: ddCommon.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddCore.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 33f2d4ac9e29e04077530848f5be2de6 - md5: 32f4aa9943ab5fde0da6f09bcbacf9be
size: 130 size: 72778
hash: md5 hash: md5
path: ddCore.lib path: ddCore.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddEventClient.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: c8aeab161984f07a0b9eaaf4f17b538c - md5: 09fc5ce2eb8653cbd8ddda5d983ce836
size: 131 size: 137794
hash: md5 hash: md5
path: ddEventClient.lib path: ddEventClient.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddEventParser.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 1b8d22c521cdbaec139a6fd3113b9169 - md5: 2f5e7eb06485bebea0ec2779d8df9f97
size: 130 size: 46862
hash: md5 hash: md5
path: ddEventParser.lib path: ddEventParser.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddEventServer.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 08ee8eb3d02ba8e3e504f5a42c626d1b - md5: bdb3738c5bbd4ac6abd3a805930b89fe
size: 130 size: 30582
hash: md5 hash: md5
path: ddEventServer.lib path: ddEventServer.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddEventStreamer.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 92252e55f1a9b12383238b05223cbdfa - md5: 43ea2bd7328593fab054754f9fd1a7c9
size: 130 size: 35768
hash: md5 hash: md5
path: ddEventStreamer.lib path: ddEventStreamer.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddNet.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: bc9348766c22907da6c9a093b40c8f82 - md5: d91f19ed479fd51b481f6b25566dfd31
size: 130 size: 13230
hash: md5 hash: md5
path: ddNet.lib path: ddNet.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddRpcClient.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: e26c24d78e41cfef26378c731c0dd4e9 - md5: 5b37ae9cc29dfaba3cb0d08a30bd684a
size: 130 size: 23224
hash: md5 hash: md5
path: ddRpcClient.lib path: ddRpcClient.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddRpcServer.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 06759abda0390d9712fd2b9514a07c43 - md5: b3f63ef6d9a9d6bfb3e5934a9a34465e
size: 131 size: 179024
hash: md5 hash: md5
path: ddRpcServer.lib path: ddRpcServer.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddRpcShared.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: c1064f8b6bbae1c8ee5b4324f5286335 - md5: db87375bafb0d667ac054dbf7dc0dc36
size: 130 size: 16268
hash: md5 hash: md5
path: ddRpcShared.lib path: ddRpcShared.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddSocket.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 60adefcf279bce2d512b72e64e913566 - md5: f88897c7d989d95f0352cf6e1a21df99
size: 131 size: 106228
hash: md5 hash: md5
path: ddSocket.lib path: ddSocket.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/ddYaml.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: a4cddc4b38e2972ecac0ee31cd5bfba9 - md5: 4d64cf4c3b034f09a8a3abd1b7e657b4
size: 130 size: 35902
hash: md5 hash: md5
path: ddYaml.lib path: ddYaml.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/dd_common.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 7de1910b7130cdf3ba928dbfcdddabdb - md5: 2394b7141b71f0b738dd3ad024dcbfc0
size: 131 size: 661222
hash: md5 hash: md5
path: dd_common.lib path: dd_common.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/dd_libyaml.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 19e5d9fead8533ecaa00c98194f45bfd - md5: 2b9f0af04b216527b49338cc1b8fa1a5
size: 131 size: 264022
hash: md5 hash: md5
path: dd_libyaml.lib path: dd_libyaml.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/dd_settings.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 8d67e1aa63cbc171631ef1723ca8cfef - md5: d9a1105679db9411bf2365aae2b6d2a5
size: 131 size: 212936
hash: md5 hash: md5
path: dd_settings.lib path: dd_settings.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/devdriver.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 0609a7a43f6d10f3e5baae8a7b371935 - md5: 18e7d04c4ecc9fb872de2e0ac9dffd61
size: 132 size: 2700190
hash: md5 hash: md5
path: devdriver.lib path: devdriver.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/metrohash.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 562ddbd333acbb87399ea93e1c276c7b - md5: 64dbdb1c2d7c68e7ae3083ea35878a83
size: 130 size: 28682
hash: md5 hash: md5
path: metrohash.lib path: metrohash.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/mpack.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: a0b7fd219e03be6ac7a411503da22da1 - md5: 43f91cf1e53eef1411a6e4a40776cd79
size: 131 size: 218874
hash: md5 hash: md5
path: mpack.lib path: mpack.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/pal.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: d7c2fd5ef188ad35c1d4c69933e73883 - md5: 852e161ac4115309a2591db0b80f13dd
size: 133 size: 24025742
hash: md5 hash: md5
path: pal.lib path: pal.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/palCompilerDeps.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: b81c7e445969441fb8995a815e3b20a4 - md5: a929ad3103021925d382e419b0e5343d
size: 131 size: 433780
hash: md5 hash: md5
path: palCompilerDeps.lib path: palCompilerDeps.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/palUtil.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: d5c6cc0e882e43c3f0b6438a13238dd4 - md5: 3cca5923fa12cf564360058254c2c6db
size: 131 size: 799750
hash: md5 hash: md5
path: palUtil.lib path: palUtil.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/pal_lz4.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: a111eae8bf916115055a36750ed885c8 - md5: 36731971681f4a89f4e89b5ad44473ac
size: 131 size: 291664
hash: md5 hash: md5
path: pal_lz4.lib path: pal_lz4.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/pal_uuid.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: e374e100d7140ba4f0c71a4d891f15e7 - md5: 1ad5de7ebbb13b41f7d7dc0367d7d1d8
size: 129 size: 3460
hash: md5 hash: md5
path: pal_uuid.lib path: pal_uuid.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/stb_sprintf.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: cd8f26e0b9083b607ac0aa145138c759 - md5: b2a1cd0f59d07aaa0cf21afa9235dbda
size: 130 size: 25990
hash: md5 hash: md5
path: stb_sprintf.lib path: stb_sprintf.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/vam.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: d99dd374e9774cc79137a5fa724d29f0 - md5: 02784ea9d25a9a9c94c20acca001456c
size: 131 size: 215198
hash: md5 hash: md5
path: vam.lib path: vam.lib
shared/amdgpu-windows-interop/pal/lib/Release/x64/zstd.lib.dvc
+2 -2
Dosyayı Görüntüle
@@ -1,5 +1,5 @@
outs: outs:
- md5: 81d0c624f04a25bb31115c45a4fe9d7c - md5: 6a1ac31db298434da1573cda69d9e4d3
size: 132 size: 1356642
hash: md5 hash: md5
path: zstd.lib path: zstd.lib