Merge branch 'internal_master_prm' into dev

Author: JaxLinAMD

cmake/PalCompileDefinitions.cmake

@@ -79,6 +79,7 @@ function(pal_compile_definitions_gpu TARGET)
         if(PAL_BUILD_GFX9)
             pal_compile_definitions_gfx9(${TARGET})
         endif()
+
     endif()
 endfunction()
 
@@ -104,7 +105,7 @@ function(pal_compile_definitions TARGET)
     )
 
     # If this build is part of a release branch, define the variable
-    if (DEFINED PAL_BUILD_BRANCH)
+    if (PAL_BUILD_BRANCH)
         target_compile_definitions(${TARGET} PRIVATE PAL_BUILD_BRANCH=${PAL_BUILD_BRANCH})
     endif()
 

cmake/PalCompilerOptions.cmake

@@ -79,17 +79,6 @@ function(pal_compiler_options TARGET)
             -fno-rtti
         >)
 
-        # Align the stack pointer on a 64 byte boundary (2^6) on compilers that support it.
-        # This was added to resolve some issues after enabling SSE.
-        # These options are specific to GCC and Clang but also may not exist on certain CPU archs.
-        check_cxx_compiler_flag(-mpreferred-stack-boundary=6 HAS_STACK_BOUNDARY)
-        check_cxx_compiler_flag(-mstack-alignment=64 HAS_STACK_ALIGNMENT)
-        if (HAS_STACK_BOUNDARY)
-            target_compile_options(${TARGET} PRIVATE -mpreferred-stack-boundary=6)
-        elseif(HAS_STACK_ALIGNMENT)
-            target_compile_options(${TARGET} PRIVATE -mstack-alignment=64)
-        endif()
-
         # If we're using a build type that generates debug syms, compress them to save significant disk space.
         check_cxx_compiler_flag(-gz HAS_COMPRESSED_DEBUG)
         if (HAS_COMPRESSED_DEBUG)

cmake/PalOptions.cmake

@@ -54,10 +54,11 @@ option(PAL_BUILD_DRI3 "Build PAL with DRI3 support?" ON)
 option(PAL_BUILD_WAYLAND "Build PAL with WAYLAND support?" OFF)
 
 # Paths to PAL's dependencies
-set(PAL_METROHASH_PATH ${PROJECT_SOURCE_DIR}/src/util/imported/metrohash CACHE PATH "Specify the path to the MetroHash project.")
-set(   PAL_CWPACK_PATH ${PROJECT_SOURCE_DIR}/src/util/imported/cwpack    CACHE PATH "Specify the path to the CWPack project.")
-set(      PAL_VAM_PATH ${PROJECT_SOURCE_DIR}/src/core/imported/vam       CACHE PATH "Specify the path to the VAM project.")
-set(     PAL_ADDR_PATH ${PROJECT_SOURCE_DIR}/src/core/imported/addrlib   CACHE PATH "Specify the path to the ADDRLIB project.")
+set(PAL_METROHASH_PATH ${PROJECT_SOURCE_DIR}/src/util/imported/metrohash      CACHE PATH "Specify the path to the MetroHash project.")
+set(   PAL_CWPACK_PATH ${PROJECT_SOURCE_DIR}/src/util/imported/cwpack         CACHE PATH "Specify the path to the CWPack project.")
+set(      PAL_VAM_PATH ${PROJECT_SOURCE_DIR}/src/core/imported/vam            CACHE PATH "Specify the path to the VAM project.")
+set(     PAL_ADDR_PATH ${PROJECT_SOURCE_DIR}/src/core/imported/addrlib        CACHE PATH "Specify the path to the ADDRLIB project.")
+set(      PAL_SWD_PATH ${PROJECT_SOURCE_DIR}/src/core/imported/SwWarDetection CACHE PATH "Specify the path to the SwWarDetection project.")
 
 set(PAL_GPUOPEN_PATH "default" CACHE PATH "Specify the path to the GPUOPEN_PATH project.")
 

doc/process/palCodingStandards.md

@@ -408,6 +408,27 @@ documentation:
     ***should*** use the capabilities of doxygen as appropriate with a
     focus on generating good-looking, useful documentation.
 
+Use multi-line style Doxygen comments for file headers and class declarations.
+```cpp
+/**
+ ***********************************************************************************************************************
+ * @brief Summary of what the following body of code does.
+ *
+ * A more detailed description goes here.
+ ***********************************************************************************************************************
+ */
+```
+
+Use triple-slash style Doxygen comments for functions, methods, enums, structs, and unions.
+```cpp
+/// @brief Summary of what the following body of code does.
+///
+/// @param [in]  parameterName0  Description of this input parameter.
+/// @param [out] parameterName1  Description of this output parameter.
+///
+/// @returns Omit if this isn't a function/method, or it's a void one.
+```
+
 ### Internal code
 
 Internal PAL code (anything not in inc/, and private members of classes
@@ -485,6 +506,13 @@ class Platform
     synchronization assumptions made by a class or function (i.e., this
     function should *never* be called from multiple threads, etc.).
 
+#### Motivation
+The PAL team decided on this unique commenting style universally. We used to work on drivers that required full Doxygen comments in every file. It was a poor experience because:
+
+- If we're going to use Doxygen, we want to do it right. That means exhaustively commenting every function parameter and every member variable. This is a huge waste of time when almost all member variables and function parameters are trivially understandable based on their name alone. Otherwise, a simple informal block comment above the variables or above the function gets the point across.
+- Doxygen is meant to generate docs, and such the formatting is rather tedious and complex if you're never going to generate those docs. The only thing worth formally documenting in PAL is the interface, everything else is just "read the code" documented. Thus we're much better served with a very plain style that just gets the point across internally.
+- The only good thing about Doxygen is the generated docs. We assume client driver engineers would generate Doxygen docs to help them read up on our interface headers. This is the only reason we still Doxygen for the public interface.
+
 <!--
 -->
 Types and Declarations

inc/core/palCmdBuffer.h

@@ -86,7 +86,7 @@ enum class PrimitiveTopology : uint32
     LineStrip        = 0x2,
     TriangleList     = 0x3,
     TriangleStrip    = 0x4,
-    RectList         = 0x5,
+    RectList         = 0x5,  ///< Each rect is three 2D axis-aligned rectangle vertices.
     QuadList         = 0x6,
     QuadStrip        = 0x7,
     LineListAdj      = 0x8,
@@ -96,7 +96,9 @@ enum class PrimitiveTopology : uint32
     Patch            = 0xC,
     TriangleFan      = 0xD,
     LineLoop         = 0xE,
-    Polygon          = 0xF
+    Polygon          = 0xF,
+    TwoDRectList     = 0x10  ///< Each rect is the bounding box of an arbitrary 2D triangle.
+                             ///  Support is optional, see support2DRectList in DeviceProperties.
 };
 
 /// Specifies how triangle primitives should be rasterized.
@@ -1424,6 +1426,16 @@ typedef void (PAL_STDCALL *CmdDispatchOffsetFunc)(
     uint32      yDim,
     uint32      zDim);
 
+/// @internal Function pointer type definition for issuing dynamic compute dispatches.
+///
+/// @see ICmdBuffer::CmdDispatchDynamic().
+typedef void (PAL_STDCALL* CmdDispatchDynamicFunc)(
+    ICmdBuffer* pCmdBuffer,
+    gpusize     gpuVa,
+    uint32      xDim,
+    uint32      yDim,
+    uint32      zDim);
+
 /// @internal Function pointer type definition for issuing direct mesh dispatches.
 ///
 /// @see ICmdBuffer::CmdDispatchMesh().
@@ -1786,13 +1798,14 @@ struct CmdBufInfo
     {
         struct
         {
-            uint32 isValid      : 1;    ///< Indicate if this CmdBufInfo is valid and should be submitted
-            uint32 frameBegin   : 1;    ///< First command buffer after Queue creation or Present.
-            uint32 frameEnd     : 1;    ///< Last command buffer before Present.
-            uint32 p2pCmd       : 1;    ///< Is P2P copy command. See CmdBufInfo comments for details.
-            uint32 captureBegin : 1;    ///< This command buffer begins a Direct Capture frame capture.
-            uint32 captureEnd   : 1;    ///< This command buffer ends a Direct Capture frame capture.
-            uint32 reserved     : 26;   ///< Reserved for future usage.
+            uint32 isValid            : 1;  ///< Indicate if this CmdBufInfo is valid and should be submitted
+            uint32 frameBegin         : 1;  ///< First command buffer after Queue creation or Present.
+            uint32 frameEnd           : 1;  ///< Last command buffer before Present.
+            uint32 p2pCmd             : 1;  ///< Is P2P copy command. See CmdBufInfo comments for details.
+            uint32 captureBegin       : 1;  ///< This command buffer begins a Direct Capture frame capture.
+            uint32 captureEnd         : 1;  ///< This command buffer ends a Direct Capture frame capture.
+            uint32 rayTracingExecuted : 1;  ///< This command buffer contains ray tracing work.
+            uint32 reserved           : 25; ///< Reserved for future usage.
         };
         uint32 u32All;                  ///< Flags packed as uint32.
     };
@@ -2302,7 +2315,7 @@ class ICmdBuffer : public IDestroyable
     ///
     /// @param [in] rasterizerDiscardEnable  Parameters for dynamically setting rasterizer discard enable bit
     virtual void CmdSetRasterizerDiscardEnable(
-	bool rasterizerDiscardEnable) = 0;
+        bool rasterizerDiscardEnable) = 0;
 
     /// Inserts a barrier in the current command stream that can stall GPU execution, flush/invalidate caches, or
     /// decompress images before further, dependent work can continue in this command buffer.
@@ -2722,6 +2735,28 @@ class ICmdBuffer : public IDestroyable
         m_funcTable.pfnCmdDispatchOffset(this, xOffset, yOffset, zOffset, xDim, yDim, zDim);
     }
 
+    /// Dispatches a compute workload of the given dimensions using the command buffer's currently bound compute state
+    /// and dynamic pipeline state from GPU memory. The memory address provided contains the gpuVa of the pipeline
+    /// launch descriptor previously obtained by calling @ref IPipeline::CreateLaunchDescriptor on a pipeline
+    /// that supports dynamic dispatch (@see PipelineCreateFlags)
+    ///
+    /// The thread group size is defined in the compute shader.
+    ///
+    /// @note DynamicComputeShaderInfo.ldsBytesPerTg is not applicable to dynamic launch descriptors.
+    ///
+    /// @param [in] gpuVa GPU virtual address of memory containing pipeline launch descriptor address.
+    /// @param [in] xDim  Thread groups to dispatch in the X dimension.  If zero, the dispatch will be discarded.
+    /// @param [in] yDim  Thread groups to dispatch in the Y dimension.  If zero, the dispatch will be discarded.
+    /// @param [in] zDim  Thread groups to dispatch in the Z dimension.  If zero, the dispatch will be discarded.
+    PAL_INLINE void CmdDispatchDynamic(
+        gpusize gpuVa,
+        uint32  xDim,
+        uint32  yDim,
+        uint32  zDim)
+    {
+        m_funcTable.pfnCmdDispatchDynamic(this, gpuVa, xDim, yDim, zDim);
+    }
+
     /// Dispatches a mesh shader workload using the command buffer's currently bound graphics state.  It is an error if
     /// the currently bound graphics pipeline does not contain a mesh and/or task shader.
     ///
@@ -4048,6 +4083,7 @@ class ICmdBuffer : public IDestroyable
         CmdDispatchFunc                  pfnCmdDispatch;                  ///< CmdDispatch function pointer.
         CmdDispatchIndirectFunc          pfnCmdDispatchIndirect;          ///< CmdDispatchIndirect function pointer.
         CmdDispatchOffsetFunc            pfnCmdDispatchOffset;            ///< CmdDispatchOffset function pointer.
+        CmdDispatchDynamicFunc           pfnCmdDispatchDynamic;           ///< CmdDispatchDynamic function pointer.
         CmdDispatchMeshFunc              pfnCmdDispatchMesh;              ///< CmdDispatchmesh function pointer.
         CmdDispatchMeshIndirectMultiFunc pfnCmdDispatchMeshIndirectMulti; ///< CmdDispatchMeshIndirect function pointer.
     } m_funcTable;     ///< Function pointer table for Cmd* functions.

inc/core/palDeveloperHooks.h

@@ -389,6 +389,7 @@ enum class DrawDispatchType : uint32
     CmdDispatchAce,               ///< Direct Compute dispatch through implicit ganged-submit ACE stream.
     CmdDispatchIndirect,          ///< Indirect compute dispatch
     CmdDispatchOffset,            ///< Direct compute dispatch (offsetted start)
+    CmdDispatchDynamic,           ///< Dynamic compute dispatch
 
     Count,
     FirstDispatch = CmdDispatch   ///< All callbacks with an enum value greater or equal than this are dispatches

inc/core/palDevice.h

@@ -1122,6 +1122,9 @@ struct DeviceProperties
         uint32 maxGsOutputVert;             ///< Maximum number of GS output vertices.
         uint32 maxGsTotalOutputComponents;  ///< Maximum number of GS output components totally.
 
+        uint32 dynamicLaunchDescSize;   ///< Dynamic launch descriptor size. Zero indicates this feature is not
+                                        ///  supported. @ref IPipeline::CreateLaunchDescriptor()
+
         RayTracingIpLevel rayTracingIp;     ///< HW RayTracing IP version
 
         union
@@ -1198,7 +1201,8 @@ struct DeviceProperties
                 uint64 supportTextureGatherBiasLod        :  1; ///< HW supports SQ_IMAGE_GATHER4_L_O
                 uint64 supportInt8Dot                     :  1; ///< Hardware supports a dot product 8bit.
                 uint64 supportInt4Dot                     :  1; ///< Hardware supports a dot product 4bit.
-                uint64 reserved                           : 21; ///< Reserved for future use.
+                uint64 support2DRectList                  :  1; ///< HW supports PrimitiveTopology::TwoDRectList.
+                uint64 reserved                           : 20; ///< Reserved for future use.
             };
             uint64 u64All;           ///< Flags packed as 32-bit uint.
         } flags;                     ///< Device IP property flags.

inc/core/palLib.h

@@ -43,7 +43,7 @@
 ///            compatible, it is not assumed that the client will initialize all input structs to 0.
 ///
 /// @ingroup LibInit
-#define PAL_INTERFACE_MAJOR_VERSION 669
+#define PAL_INTERFACE_MAJOR_VERSION 673
 
 /// Minor interface version.  Note that the interface version is distinct from the PAL version itself, which is returned
 /// in @ref Pal::PlatformProperties.
@@ -53,7 +53,7 @@
 /// of the existing enum values will change.  This number will be reset to 0 when the major version is incremented.
 ///
 /// @ingroup LibInit
-#define PAL_INTERFACE_MINOR_VERSION 1
+#define PAL_INTERFACE_MINOR_VERSION 0
 
 /// 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.
@@ -90,6 +90,27 @@ class      IPlatform;
 /// This is a list of GPUs that the NULL OS layer can compile shaders to in offline mode.
 enum class NullGpuId : uint32
 {
+#if PAL_CLIENT_INTERFACE_MAJOR_VERSION >= 672
+    Polaris10 = 0x00,
+    Polaris11 = 0x01,
+    Polaris12 = 0x02,
+
+    Vega10 = 0x04,
+    Raven  = 0x05,
+    Vega12 = 0x06,
+    Vega20 = 0x07,
+    Raven2 = 0x08,
+    Renoir = 0x09,
+
+    Navi10           = 0x0A,
+    Navi12           = 0x0B,
+    Navi14           = 0x0D,
+    Navi21           = 0x0F,
+    Navi22           = 0x10,
+
+    Max = 0x1B,
+    All = 0x1C,
+#else // PAL_CLIENT_INTERFACE_MAJOR_VERSION >= 672
     Tahiti    = 0x00,
     Pitcairn  = 0x01,
     Capeverde = 0x02,
@@ -113,7 +134,7 @@ enum class NullGpuId : uint32
     Polaris10 = 0x12,
     Polaris11 = 0x13,
     Polaris12 = 0x14,
-    Stoney    = 0x16,
+    Stoney = 0x16,
 
     Vega10 = 0x17,
     Raven  = 0x18,
@@ -130,6 +151,7 @@ enum class NullGpuId : uint32
 
     Max = 0x2E,
     All = 0x2F,
+#endif
 };
 
 /// Maps a null GPU ID to its associated text name.

inc/core/palPipeline.h

@@ -154,12 +154,18 @@ union PipelineCreateFlags
 {
     struct
     {
-        uint32 clientInternal     : 1;  ///< Internal pipeline not created by the application.
+        uint32 clientInternal         : 1;  ///< Internal pipeline not created by the application.
 #if PAL_CLIENT_INTERFACE_MAJOR_VERSION < 631
-        uint32 overrideGpuHeap    : 1;  ///< Override the default GPU heap (local invisible) the pipeline resides in.
-        uint32 reserved           : 30; ///< Reserved for future use.
+        uint32 overrideGpuHeap        : 1;  ///< Override the default GPU heap (local invisible) the pipeline
+                                            ///  resides in.
+        uint32 reserved               : 30; ///< Reserved for future use.
+#elif PAL_CLIENT_INTERFACE_MAJOR_VERSION >= 673
+        uint32 supportDynamicDispatch : 1;  ///< Pipeline will be used with @ref ICmdBuffer::CmdDynamicDispatch.
+                                            ///  This flag must only be set if the device reports support
+                                            ///  via DeviceProperties.
+        uint32 reserved               : 30; ///< Reserved for future use.
 #else
-        uint32 reserved           : 31; ///< Reserved for future use.
+        uint32 reserved               : 31; ///< Reserved for future use.
 #endif
     };
     uint32 u32All;                  ///< Flags packed as 32-bit uint.
@@ -549,6 +555,25 @@ class IPipeline : public IDestroyable
         size_t*                  pSize,
         void*                    pBuffer) = 0;
 
+    /// Creates a new dynamic launch descriptor for this pipeline.  These descriptors are only usable as input to
+    /// @ref ICmdBuffer::CmdDispatchDynamic().  Each launch descriptor acts as a GPU-side "handle" to a pipeline and
+    /// a set of shader libraries it is linked with. The size of the launch descriptor can be queried from
+    /// @ref DeviceProperties. A size of 0 reported in DeviceProperties indicates that this feature is not supported.
+    ///
+    /// Currently only supported on compute pipelines.
+    ///
+    /// @param [in, out] pOut     Launch descriptor to create or update. Must not be null.
+    /// @param [in]      resolve  The launch descriptor contains state from a previous link operation. Need to update
+    ///                           the descriptor during this operation.
+    ///
+    /// @returns Success if the operation was successful.  Other error codes may include:
+    ///          + ErrorUnavailable if called on a graphics pipeline or a pipeline that does not support dynamic
+    ///                             launch. @ref PipelineCreateFlags
+    ///          + ErrorInvalidPointer if pCpuAddr is null.
+    virtual Result CreateLaunchDescriptor(
+        void* pCpuAddr,
+        bool  resolve) = 0;
+
     /// Notifies PAL that this pipeline may make indirect function calls to any function contained within any of the
     /// specified @ref IShaderLibrary objects.  This gives PAL a chance to perform any late linking steps required to
     /// valid execution of the possible function calls (this could include adjusting hardware resources such as GPRs