Merge branch 'master' into dev

cmake/XglCompileDefinitions.cmake

@@ -83,6 +83,10 @@ macro(xgl_set_compile_definitions)
         target_compile_definitions(xgl PRIVATE VKI_BUILD_PHOENIX1=1)
     endif()
 
+    if(XGL_BUILD_PHOENIX2)
+        target_compile_definitions(xgl PRIVATE VKI_BUILD_PHOENIX2=1)
+    endif()
+
     if(XGL_BUILD_REMBRANDT)
         target_compile_definitions(xgl PRIVATE VKI_BUILD_REMBRANDT=1)
     endif()

cmake/XglOptions.cmake

@@ -63,6 +63,8 @@ macro(xgl_options)
 
     option(XGL_BUILD_PHOENIX1 "Build vulkan for PHOENIX1" ON)
 
+    option(XGL_BUILD_PHOENIX2 "Build vulkan for PHOENIX2" ON)
+
     option(XGL_BUILD_TESTS "Build tests?" OFF)
 
     option(XGL_BUILD_TOOLS "Build tools?" OFF)

cmake/XglOverrides.cmake

@@ -107,6 +107,8 @@ macro(xgl_overrides_pal)
         set(PAL_BUILD_GFX11 1 CACHE BOOL "${PROJECT_NAME} override." FORCE)
     endif()
 
+    set(PAL_BUILD_PHOENIX2 ${XGL_BUILD_PHOENIX2} CACHE BOOL "${PROJECT_NAME} override." FORCE)
+
     # Wayland
     set(PAL_BUILD_WAYLAND ${BUILD_WAYLAND_SUPPORT} CACHE BOOL "Build PAL with Wayland support" FORCE)
 
@@ -157,6 +159,8 @@ macro(xgl_overrides_vkgc)
 
     set(LLPC_BUILD_PHOENIX1 ${XGL_BUILD_PHOENIX1} CACHE BOOL "${PROJECT_NAME} override." FORCE)
 
+    set(LLPC_BUILD_PHOENIX2 ${XGL_BUILD_PHOENIX2} CACHE BOOL "${PROJECT_NAME} override." FORCE)
+
     set(LLPC_ENABLE_WERROR ${ICD_ANALYSIS_WARNINGS_AS_ERRORS} CACHE BOOL "${PROJECT_NAME} override." FORCE)
 
 endmacro()

cmake/XglVersions.cmake

@@ -28,7 +28,7 @@ include_guard()
 # This will become the value of PAL_CLIENT_INTERFACE_MAJOR_VERSION.  It describes the version of the PAL interface
 # that the ICD supports.  PAL uses this value to enable backwards-compatibility for older interface versions.
 # It must be updated on each PAL promotion after handling all of the interface changes described in palLib.h.
-set(ICD_PAL_CLIENT_MAJOR_VERSION "856")
+set(ICD_PAL_CLIENT_MAJOR_VERSION "867")
 
 # This will become the value of GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION if ICD_GPUOPEN_DEVMODE_BUILD=1.
 # It describes the interface version of the gpuopen shared module (part of PAL) that the ICD supports.
@@ -42,4 +42,4 @@ set(ICD_GPURT_CLIENT_MAJOR_VERSION "46")
 
 # This will become the value of LLPC_CLIENT_INTERFACE_MAJOR_VERSION if ICD_BUILD_LLPC=1.
 # It describes the version of the interface version of LLPC that the ICD supports.
-set(ICD_LLPC_CLIENT_MAJOR_VERSION "70")
+set(ICD_LLPC_CLIENT_MAJOR_VERSION "71")

icd/CMakeLists.txt

@@ -150,6 +150,7 @@ target_sources(xgl PRIVATE
     api/vk_gpa_session.cpp
     api/vk_descriptor_update_template.cpp
     api/vk_utils.cpp
+    api/vk_indirect_commands_layout.cpp
     api/appopt/barrier_filter_layer.cpp
     api/appopt/strange_brigade_layer.cpp
     api/appopt/g_shader_profile.cpp
@@ -302,6 +303,34 @@ target_sources(xgl PRIVATE
     settings/settings_xgl.json
 )
 
+add_custom_command(
+    OUTPUT ${ICD_SETTINGS_DIR}/g_experiments.cpp ${ICD_SETTINGS_DIR}/g_experiments.h
+    COMMAND ${PYTHON_CMD} ${ICD_GEN_SETTINGS}
+        -i ${ICD_SETTINGS_DIR}/experiments_settings_xgl.json
+        -o ${ICD_SETTINGS_DIR}
+        -g experiments
+        -s settings/experimentsLoader.h
+        --namespaces vk
+        --settings-struct-name ExpSettings
+        --classname ExperimentsLoader
+    DEPENDS ${ICD_GEN_SETTINGS_FILES} ${ICD_SETTINGS_DIR}/experiments_settings_xgl.json
+    COMMENT "Generating Vulkan settings code from experiments_settings_xgl.json"
+)
+
+add_custom_target(
+    RunVKExperimentsGenerator
+    DEPENDS ${ICD_GEN_SETTINGS_FILES} ${ICD_SETTINGS_DIR}/experiments_settings_xgl.json
+    COMMENT "Checking if re-generation is required for settings"
+)
+
+add_dependencies(xgl RunVKExperimentsGenerator)
+
+target_sources(xgl PRIVATE
+    settings/g_experiments.cpp
+    settings/experimentsLoader.cpp
+    settings/experiments_settings_xgl.json
+)
+
 ### ICD api/sqtt ##############################################################
 target_sources(xgl PRIVATE
     api/sqtt/sqtt_layer.cpp
@@ -311,7 +340,10 @@ target_sources(xgl PRIVATE
 
 ### ICD api/devmode ###########################################################
 if(ICD_GPUOPEN_DEVMODE_BUILD)
-    target_sources(xgl PRIVATE api/devmode/devmode_mgr.cpp)
+    target_sources(xgl PRIVATE
+        api/devmode/devmode_rgp.cpp
+        api/devmode/devmode_ubertrace.cpp
+    )
 endif()
 
 ### ICD layer ##################################################################

icd/Loader/LunarG/Lnx/amd-icd.json

@@ -2,13 +2,13 @@
   "file_format_version": "1.0.0",
   "ICD": {
     "library_path": "@AMDVLK_INSTALL_PATH@/amdvlk@[email protected]",
-    "api_version": "1.3.279"
+    "api_version": "1.3.280"
   },
   "layer": {
     "name": "VK_LAYER_AMD_switchable_graphics_@ISABITS@",
     "type": "GLOBAL",
     "library_path": "@AMDVLK_INSTALL_PATH@/amdvlk@[email protected]",
-    "api_version": "1.3.279",
+    "api_version": "1.3.280",
     "implementation_version": "1",
     "description": "AMD switchable graphics layer",
     "functions": {

icd/api/app_profile.cpp

@@ -40,6 +40,7 @@
 
 #if defined(__unix__)
 #include <unistd.h>
+#include <fcntl.h>
 #include <linux/limits.h>
 #endif
 
@@ -731,18 +732,6 @@ constexpr AppProfilePatternEntry AppEngineQuanticDream
     "quantic dream engine"
 };
 
-constexpr AppProfilePatternEntry AppNameEnshrouded =
-{
-    PatternAppNameLower,
-    "enshrouded"
-};
-
-constexpr AppProfilePatternEntry AppEngineHolistic =
-{
-    PatternEngineNameLower,
-    "holistic"
-};
-
 constexpr AppProfilePatternEntry PatternEnd = {};
 
 // This is a table of patterns.  The first matching pattern in this table will be returned.
@@ -1477,23 +1466,6 @@ AppProfilePattern AppPatternTable[] =
         }
     },
 
-    {
-        AppProfile::Enshrouded,
-        {
-            AppNameEnshrouded,
-            AppEngineHolistic,
-            PatternEnd
-        }
-    },
-
-    {
-        AppProfile::HolisticEngine,
-        {
-            AppEngineHolistic,
-            PatternEnd
-        }
-    },
-
     {
         AppProfile::Zink,
         {
@@ -1702,24 +1674,14 @@ static char* GetExecutableName(
     size_t* pLength,
     bool    includeExtension)  // true if you want the extension on the file name.
 {
-    pid_t pid = getpid();
     char* pExecutable = nullptr;
-    char* pModuleFileName = nullptr;
     char  path[PATH_MAX] = {0};
-    char  commandStringBuffer[PATH_MAX] = {0};
-    sprintf(commandStringBuffer, "cat /proc/%d/cmdline", pid);
-    FILE* pCommand = popen(commandStringBuffer, "r");
-    if (pCommand != nullptr)
+    pExecutable = static_cast<char*>(malloc(PATH_MAX));
+
+    if (pExecutable != nullptr)
     {
-        if (fgets(path, PATH_MAX, pCommand) != nullptr)
-        {
-            pExecutable = static_cast<char*>(malloc(PATH_MAX));
-            pModuleFileName = strrchr(path, '/') ? strrchr(path, '/') + 1 : path;
-            pModuleFileName = strrchr(pModuleFileName, '\\') ? strrchr(pModuleFileName, '\\') + 1 : pModuleFileName;
-            strcpy(pExecutable, pModuleFileName);
-            *pLength = strlen(pExecutable);
-        }
-        pclose(pCommand);
+        utils::GetExecutableNameAndPath(pExecutable, &path[0]);
+        *pLength = strlen(pExecutable);
     }
     return pExecutable;
 }

icd/api/app_shader_optimizer.cpp

@@ -592,14 +592,20 @@ void ShaderOptimizer::ApplyProfileToDynamicComputeShaderInfo(
 }
 
 // =====================================================================================================================
-void ShaderOptimizer::ApplyProfileToDynamicGraphicsShaderInfo(
+bool ShaderOptimizer::ApplyProfileToDynamicGraphicsShaderInfo(
     const ShaderProfileAction&      action,
     Pal::DynamicGraphicsShaderInfo* pGraphicsShaderInfo) const
 {
+    bool hasUpdate = false;
+
     if (action.dynamicShaderInfo.apply.maxWavesPerCu)
     {
         pGraphicsShaderInfo->maxWavesPerCu = static_cast<float>(action.dynamicShaderInfo.maxWavesPerCu);
+
+        hasUpdate = true;
     }
+
+    return hasUpdate;
 }
 
 // =====================================================================================================================
@@ -631,25 +637,32 @@ void ShaderOptimizer::ApplyProfileToGraphicsPipelineCreateInfo(
                     switch (vkgcStage)
                     {
                     case ShaderStage::ShaderStageTask:
-                        ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->ts);
+                        pGraphicsShaderInfos->enable.ts |=
+                            ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->ts);
                         break;
                     case ShaderStage::ShaderStageVertex:
-                        ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->vs);
+                        pGraphicsShaderInfos->enable.vs |=
+                            ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->vs);
                         break;
                     case ShaderStage::ShaderStageTessControl:
-                        ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->hs);
+                        pGraphicsShaderInfos->enable.hs |=
+                            ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->hs);
                         break;
                     case ShaderStage::ShaderStageTessEval:
-                        ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->ds);
+                        pGraphicsShaderInfos->enable.ds |=
+                            ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->ds);
                         break;
                     case ShaderStage::ShaderStageGeometry:
-                        ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->gs);
+                        pGraphicsShaderInfos->enable.gs |=
+                            ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->gs);
                         break;
                     case ShaderStage::ShaderStageMesh:
-                        ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->ms);
+                        pGraphicsShaderInfos->enable.ms |=
+                            ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->ms);
                         break;
                     case ShaderStage::ShaderStageFragment:
-                        ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->ps);
+                        pGraphicsShaderInfos->enable.ps |=
+                            ApplyProfileToDynamicGraphicsShaderInfo(shaders[vkgcStage], &pGraphicsShaderInfos->ps);
                         break;
                     default:
                         PAL_ASSERT_ALWAYS();

icd/api/cmd_buffer_ring.cpp

@@ -188,7 +188,7 @@ void CmdBufferRing::DestroyCmdBufState(
     // Wait to finish in case still in flight
     if (pCmdBufState->pFence->GetStatus() == Pal::Result::NotReady)
     {
-        pDevice->PalDevice(deviceIdx)->WaitForFences(1, &pCmdBufState->pFence, true, ~0ULL);
+        pDevice->PalDevice(deviceIdx)->WaitForFences(1, &pCmdBufState->pFence, true, std::chrono::nanoseconds::max());
     }
 
     // Destroy Fence

icd/api/compiler_solution.cpp

@@ -206,7 +206,7 @@ void CompilerSolution::StoreShaderBinaryToCache(
 
     if (updateBinaryCache || updateAppCache || (pCacheBinary->pCode == nullptr))
     {
-        if ((pHeader->binaryLength > 0) && (pCacheBinary->codeSize == 0))
+        if (((pHeader->binaryLength > 0) || (pHeader->requireFullPipeline)) && (pCacheBinary->codeSize == 0))
         {
             size_t cacheSize = sizeof(ShaderLibraryBlobHeader) + pHeader->binaryLength + pHeader->fragMetaLength;
 
@@ -218,7 +218,10 @@ void CompilerSolution::StoreShaderBinaryToCache(
             if (pBuffer != nullptr)
             {
                 memcpy(pBuffer, pHeader, sizeof(ShaderLibraryBlobHeader));
-                memcpy(Util::VoidPtrInc(pBuffer, sizeof(ShaderLibraryBlobHeader)), pBlob, pHeader->binaryLength);
+                if (pBlob != nullptr)
+                {
+                    memcpy(Util::VoidPtrInc(pBuffer, sizeof(ShaderLibraryBlobHeader)), pBlob, pHeader->binaryLength);
+                }
                 if (pFragmentMeta != nullptr)
                 {
                     memcpy(Util::VoidPtrInc(pBuffer, sizeof(ShaderLibraryBlobHeader) + pHeader->binaryLength),

icd/api/compiler_solution_llpc.cpp

@@ -507,7 +507,22 @@ VkResult CompilerSolutionLlpc::CreateGraphicsShaderBinary(
                 }
             }
 
-            if (hitCache == false)
+            bool checkShaderModuleIdUsage = false;
+            if (hitCache)
+            {
+                const auto* pShaderLibraryHeader =
+                    reinterpret_cast<const ShaderLibraryBlobHeader*>(shaderLibraryBinary.pCode);
+                if (pShaderLibraryHeader->requireFullPipeline)
+                {
+                    checkShaderModuleIdUsage = true;
+                }
+            }
+            else
+            {
+                checkShaderModuleIdUsage = true;
+            }
+
+            if (checkShaderModuleIdUsage)
             {
                 for (uint32_t stage = 0; stage < ShaderStage::ShaderStageGfxCount; stage++)
                 {
@@ -552,10 +567,14 @@ VkResult CompilerSolutionLlpc::CreateGraphicsShaderBinary(
 
             if (llpcResult == Vkgc::Result::Success)
             {
-                blobHeader.binaryLength   = finalBinary.codeSize;
+                blobHeader.binaryLength = finalBinary.codeSize;
                 blobHeader.fragMetaLength = pipelineOut.fsOutputMetaDataSize;
             }
-            else if (llpcResult != Vkgc::Result::RequireFullPipeline)
+            else if (llpcResult == Vkgc::Result::RequireFullPipeline)
+            {
+                blobHeader.requireFullPipeline = true;
+            }
+            else
             {
                 result = (llpcResult == Vkgc::Result::ErrorOutOfMemory) ? VK_ERROR_OUT_OF_HOST_MEMORY :
                                                                           VK_ERROR_INITIALIZATION_FAILED;
@@ -567,18 +586,15 @@ VkResult CompilerSolutionLlpc::CreateGraphicsShaderBinary(
             // Always call StoreShaderBinaryToCache to sync data between app cache and binary cache except
             // RequireFullPipeline. When cache is hit, blobHeader is zero, StoreShaderBinaryToCache will ignore
             // finalBinary, and reuse shaderLibraryBinary.
-            if ((finalBinary.pCode != nullptr) || (shaderLibraryBinary.pCode != nullptr))
-            {
-                StoreShaderBinaryToCache(
-                    pPipelineCache,
-                    &cacheId,
-                    &blobHeader,
-                    finalBinary.pCode,
-                    pipelineOut.fsOutputMetaData,
-                    hitCache,
-                    hitAppCache,
-                    &shaderLibraryBinary);
-            }
+            StoreShaderBinaryToCache(
+                pPipelineCache,
+                &cacheId,
+                &blobHeader,
+                finalBinary.pCode,
+                pipelineOut.fsOutputMetaData,
+                hitCache,
+                hitAppCache,
+                &shaderLibraryBinary);
 
             pModuleState->elfPackage                  = shaderLibraryBinary;
             pModuleState->pFsOutputMetaData           = nullptr;
@@ -830,7 +846,7 @@ void LlpcHelperThreadProvider::WaitForTasks()
 {
     while (m_pDeferredWorkload->completedInstances < m_pDeferredWorkload->totalInstances)
     {
-        m_pDeferredWorkload->event.Wait(1.0f);
+        m_pDeferredWorkload->event.Wait(Util::fseconds { 1.0f });
     }
 }
 
@@ -1229,8 +1245,11 @@ Vkgc::BinaryData CompilerSolutionLlpc::ExtractPalElfBinary(
 {
     Vkgc::BinaryData elfBinary = {};
     const ShaderLibraryBlobHeader* pHeader = reinterpret_cast<const ShaderLibraryBlobHeader*>(shaderBinary.pCode);
-    elfBinary.pCode    = pHeader + 1;
-    elfBinary.codeSize = pHeader->binaryLength;
+    if (pHeader->binaryLength > 0)
+    {
+        elfBinary.pCode = pHeader + 1;
+        elfBinary.codeSize = pHeader->binaryLength;
+    }
     return elfBinary;
 }
 

icd/api/debug_printf.cpp

@@ -214,7 +214,7 @@ Pal::Result DebugPrintf::PostQueueProcess(
             while (true)
             {
                 palResult = pDevice->PalDevice(DefaultDeviceIndex)->WaitForSemaphores(
-                    1, palSemaphores, waitValues, 0, 1000000llu);
+                    1, palSemaphores, waitValues, 0, std::chrono::nanoseconds {1000000llu});
 
                 decodeOffset = ProcessDebugPrintfBuffer(pDevice, deviceIdx, decodeOffset, &file);
                 if ((PalToVkResult(palResult) <= 0) || (loopIndex++ > 1000))