Merge pull request #143 from GPUOpen-LibrariesAndSDKs/update_wk13_2

DominikWitczakAMD · web-flow · commit 5dab34f9d732 · 2019-03-27T10:21:14.000+01:00
Bug-fixes
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -22,6 +22,10 @@ endif()
 
 # Do not modify anything after this line, unless you know what you're doing.
 
+if (NOT MSVC)
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_DEBUG")
+endif()
+
 configure_file("include/config.h.in" "include/config.h")
 
 include_directories("${Anvil_BINARY_DIR}/include"
diff --git a/include/misc/debug.h b/include/misc/debug.h
@@ -27,7 +27,7 @@
 #include <functional>
 
 
-#ifdef _DEBUG
+#if defined(_DEBUG)
     #define anvil_assert(assertion)                  \
         if (!(assertion))                            \
         {                                            \
@@ -87,4 +87,4 @@ namespace Anvil
     void set_assertion_failure_handler(AssertionFailedCallbackFunction in_new_callback_func);
 };
 
-#endif /* MISC_DEBUG_H */
+#endif /* MISC_DEBUG_H */
diff --git a/include/misc/external_handle.h b/include/misc/external_handle.h
@@ -40,19 +40,20 @@ namespace Anvil
             return m_handle;
         }
 
-        #if defined(_WIN32)
-            /* If a payload of an object exported to a NT handle is imported to another object, the ownership is passed
-             * to the new object.
-             *
-             * For NT handles, it is assumed the handle should be destroyed when the wrapper goes out of scope. If the above
-             * import is performed, you MUST tell ExternalHandleWrapper to release the ownership of the handle, or else anything
-             * can happen.
-             */
-            void release_ownership()
-            {
-                m_close_at_destruction_time = false;
-            }
-        #endif
+        /* If a payload of an object exported to a NT handle is imported to another object, the ownership is passed
+         * to the new object.
+         *
+         * For NT handles, it is assumed the handle should be destroyed when the wrapper goes out of scope. If the above
+         * import is performed, you MUST tell ExternalHandle to release the ownership of the handle, or else it will leak.
+         *
+         * Under Linux, ownership of the underlying FD is transferred to the app at export time, and back to the driver at import time.
+         * If the wrapper has been created with in_close_at_destruction_time set to true and an exported external handle IS imported,
+         * you need to call this function in order to avoid double release of the FD.
+         */
+        void release_ownership()
+        {
+            m_close_at_destruction_time = false;
+        }
 
     private:
         ExternalHandle(const ExternalHandleType& in_handle,
diff --git a/include/misc/types_classes.h b/include/misc/types_classes.h
@@ -374,6 +374,10 @@ namespace Anvil
             {
                 memory_block_owned_by_image = false;
                 memory_block_ptr            = nullptr;
+                memory_block_start_offset   = UINT32_MAX;
+                offset.x                    = 0;
+                offset.y                    = 0;
+                offset.z                    = 0;
             }
         } ImageBindInfo;
 
diff --git a/include/misc/types_struct.h b/include/misc/types_struct.h
@@ -185,7 +185,7 @@ namespace Anvil
     static_assert(offsetof(SurfaceCapabilities, supported_usage_flags)     == offsetof(VkSurfaceCapabilitiesKHR, supportedUsageFlags),     "Member offsets must match");
 
     /* NOTE: Maps 1:1 to VkImageSubresource */
-    typedef struct
+    typedef struct ImageSubresource
     {
         Anvil::ImageAspectFlags aspect_mask;
         uint32_t                mip_level;
@@ -201,6 +201,13 @@ namespace Anvil
 
             return result;
         }
+
+        ImageSubresource()
+            :array_layer(UINT32_MAX),
+             mip_level  (UINT32_MAX)
+         {
+             /* Stub */
+         }
     } ImageSubresource;
 
     static_assert(sizeof(ImageSubresource)                == sizeof(VkImageSubresource),               "Struct sizes much match");
diff --git a/include/misc/types_utils.h b/include/misc/types_utils.h
@@ -31,6 +31,11 @@ namespace Anvil
         bool convert_mt_safety_enum_to_boolean(MTSafety                 in_mt_safety,
                                                const Anvil::BaseDevice* in_device_ptr);
 
+        /* NOTE: in_api_version must NOT be Anvil::APIVersion::UNKNOWN */
+        void get_version_chunks_for_api_version(const Anvil::APIVersion& in_api_version,
+                                                uint32_t*                out_major_version_ptr,
+                                                uint32_t*                out_minor_version_ptr);
+
         Anvil::QueueFamilyFlags get_queue_family_flags_from_queue_family_type(Anvil::QueueFamilyType in_queue_family_type);
 
         /** Converts a queue family bitfield value to an array of queue family indices.
diff --git a/src/misc/base_pipeline_manager.cpp b/src/misc/base_pipeline_manager.cpp
@@ -41,8 +41,8 @@ Anvil::BasePipelineManager::BasePipelineManager(const Anvil::BaseDevice* in_devi
      m_pipeline_cache_ptr    (nullptr),
      m_pipeline_counter      (0)
 {
-    anvil_assert(!in_use_pipeline_cache && in_pipeline_cache_to_reuse_ptr == nullptr ||
-                  in_use_pipeline_cache);
+    anvil_assert((!in_use_pipeline_cache && in_pipeline_cache_to_reuse_ptr == nullptr) ||
+                   in_use_pipeline_cache);
 
     m_pipeline_layout_manager_ptr = in_device_ptr->get_pipeline_layout_manager();
     anvil_assert(m_pipeline_layout_manager_ptr != nullptr);
diff --git a/src/misc/debug.cpp b/src/misc/debug.cpp
@@ -75,4 +75,4 @@ void Anvil::on_assertion_failed(const char*  in_filename,
 void Anvil::set_assertion_failure_handler(Anvil::AssertionFailedCallbackFunction in_new_callback_func)
 {
     g_anvil_assertion_check_failed_func = in_new_callback_func;
-}
+}
diff --git a/src/misc/memalloc_backends/backend_oneshot.cpp b/src/misc/memalloc_backends/backend_oneshot.cpp
@@ -330,7 +330,10 @@ bool Anvil::MemoryAllocatorBackends::OneShot::bake(Anvil::MemoryAllocator::Items
                                                                 (is_current_item_image && current_item_ptr->image_ptr->get_create_info_ptr()->get_tiling() == Anvil::ImageTiling::LINEAR);
 
                             anvil_assert(current_item_ptr->alloc_exportable_external_handle_types == 0);
-                            anvil_assert(current_item_ptr->alloc_external_nt_handle_info_ptr      == nullptr);
+
+                            #if defined(_WIN32)
+                                anvil_assert(current_item_ptr->alloc_external_nt_handle_info_ptr == nullptr);
+                            #endif
 
                             n_bytes_required = Anvil::Utils::round_up(n_bytes_required,
                                                                       current_item_ptr->alloc_memory_required_alignment);
diff --git a/src/misc/memory_allocator.cpp b/src/misc/memory_allocator.cpp
@@ -1205,9 +1205,9 @@ bool Anvil::MemoryAllocator::add_sparse_image_miptail(Anvil::Image*
     anvil_assert(result);
 
     /* Even more sanity checks */
-    anvil_assert((aspect_props_ptr->flags & Anvil::SparseImageFormatFlagBits::SINGLE_MIPTAIL_BIT) != 0 &&
-                  in_n_layer                                                                      == 0 ||
-                 (aspect_props_ptr->flags & Anvil::SparseImageFormatFlagBits::SINGLE_MIPTAIL_BIT) == 0);
+    anvil_assert(((aspect_props_ptr->flags & Anvil::SparseImageFormatFlagBits::SINGLE_MIPTAIL_BIT) != 0  &&
+                   in_n_layer                                                                      == 0) ||
+                 ((aspect_props_ptr->flags & Anvil::SparseImageFormatFlagBits::SINGLE_MIPTAIL_BIT) == 0));
 
     /* Determine allocation properties */
     miptail_memory_types = in_image_ptr->get_image_memory_types(n_plane);
diff --git a/src/misc/types_struct.cpp b/src/misc/types_struct.cpp
@@ -4121,16 +4121,16 @@ Anvil::SubmitInfo::SubmitInfo(uint32_t                         in_n_command_buff
 #endif
      dst_stage_wait_masks                          (in_n_semaphores_to_wait_on),
      fence_ptr                                     (in_opt_fence_ptr),
-     is_protected                                  (false),
 #if defined(_WIN32)
-    keyed_mutex_n_acquire_keys                     (0),
-    keyed_mutex_acquire_d3d11_memory_block_ptrs_ptr(nullptr),
-    keyed_mutex_acquire_mutex_key_value_ptrs       (nullptr),
-    keyed_mutex_acquire_timeout_ptrs               (nullptr),
-    keyed_mutex_n_release_keys                     (0),
-    keyed_mutex_release_d3d11_memory_block_ptrs_ptr(nullptr),
-    keyed_mutex_release_mutex_key_value_ptrs       (nullptr),
+     keyed_mutex_n_acquire_keys                     (0),
+     keyed_mutex_acquire_d3d11_memory_block_ptrs_ptr(nullptr),
+     keyed_mutex_acquire_mutex_key_value_ptrs       (nullptr),
+     keyed_mutex_acquire_timeout_ptrs               (nullptr),
+     keyed_mutex_n_release_keys                     (0),
+     keyed_mutex_release_d3d11_memory_block_ptrs_ptr(nullptr),
+     keyed_mutex_release_mutex_key_value_ptrs       (nullptr),
 #endif
+     is_protected                                  (false),
      n_command_buffers                             (in_n_command_buffers),
      n_signal_semaphores                           (in_n_semaphores_to_signal),
      n_wait_semaphores                             (in_n_semaphores_to_wait_on),
@@ -4188,13 +4188,13 @@ Anvil::SubmitInfo::SubmitInfo(uint32_t                           in_n_command_bu
      fence_ptr                                     (in_opt_fence_ptr),
      is_protected                                  (false),
 #if defined(_WIN32)
-    keyed_mutex_n_acquire_keys                     (0),
-    keyed_mutex_acquire_d3d11_memory_block_ptrs_ptr(nullptr),
-    keyed_mutex_acquire_mutex_key_value_ptrs       (nullptr),
-    keyed_mutex_acquire_timeout_ptrs               (nullptr),
-    keyed_mutex_n_release_keys                     (0),
-    keyed_mutex_release_d3d11_memory_block_ptrs_ptr(nullptr),
-    keyed_mutex_release_mutex_key_value_ptrs       (nullptr),
+     keyed_mutex_n_acquire_keys                     (0),
+     keyed_mutex_acquire_d3d11_memory_block_ptrs_ptr(nullptr),
+     keyed_mutex_acquire_mutex_key_value_ptrs       (nullptr),
+     keyed_mutex_acquire_timeout_ptrs               (nullptr),
+     keyed_mutex_n_release_keys                     (0),
+     keyed_mutex_release_d3d11_memory_block_ptrs_ptr(nullptr),
+     keyed_mutex_release_mutex_key_value_ptrs       (nullptr),
 #endif
      n_command_buffers                             (in_n_command_buffer_submissions),
      n_signal_semaphores                           (in_n_signal_semaphore_submissions),
diff --git a/src/misc/types_utils.cpp b/src/misc/types_utils.cpp
@@ -23,6 +23,37 @@
 #include "wrappers/buffer.h"
 #include "wrappers/device.h"
 
+/** Please see header for specification */
+void Anvil::Utils::get_version_chunks_for_api_version(const Anvil::APIVersion& in_api_version,
+                                                      uint32_t*                out_major_version_ptr,
+                                                      uint32_t*                out_minor_version_ptr)
+{
+    switch (in_api_version)
+    {
+        case Anvil::APIVersion::_1_0:
+        {
+            *out_major_version_ptr = 1;
+            *out_minor_version_ptr = 0;
+
+            break;
+        }
+
+        case Anvil::APIVersion::_1_1:
+        {
+            *out_major_version_ptr = 1;
+            *out_minor_version_ptr = 1;
+
+            break;
+        }
+
+        default:
+        {
+            /* in_api_version must NOT be Anvil::APIVersion::UNKNOWN! */
+            anvil_assert_fail();
+        }
+    }
+}
+
 /** Please see header for specification */
 Anvil::MemoryFeatureFlags Anvil::Utils::get_memory_feature_flags_from_vk_property_flags(Anvil::MemoryPropertyFlags in_mem_type_flags,
                                                                                         Anvil::MemoryHeapFlags     in_mem_heap_flags)
diff --git a/src/wrappers/command_buffer.cpp b/src/wrappers/command_buffer.cpp
@@ -3203,7 +3203,7 @@ bool Anvil::CommandBufferBase::record_pipeline_barrier(Anvil::PipelineStageFlags
     }
 
     anvil_assert((!m_is_renderpass_active)                                                                           ||
-                 ( m_is_renderpass_active) && (in_dependency_flags & Anvil::DependencyFlagBits::VIEW_LOCAL_BIT) == 0);
+                 ((m_is_renderpass_active) && (in_dependency_flags & Anvil::DependencyFlagBits::VIEW_LOCAL_BIT) == 0));
 
     #ifdef STORE_COMMAND_BUFFER_COMMANDS
     {
@@ -4583,7 +4583,7 @@ bool Anvil::PrimaryCommandBuffer::record_begin_render_pass_internal(const bool&
     {
         auto chain_ptr = render_pass_begin_info_chain.create_chain();
 
-        if (in_use_khr_create_rp2_extension)
+        if (!in_use_khr_create_rp2_extension)
         {
             Anvil::Vulkan::vkCmdBeginRenderPass(m_command_buffer,
                                                 chain_ptr->get_root_struct(),
diff --git a/src/wrappers/device.cpp b/src/wrappers/device.cpp
@@ -1474,8 +1474,8 @@ bool Anvil::BaseDevice::init_extension_func_ptrs()
             m_khr_external_memory_fd_extension_entrypoints.vkGetMemoryFdKHR           = reinterpret_cast<PFN_vkGetMemoryFdKHR>          (get_proc_address("vkGetMemoryFdKHR"));
             m_khr_external_memory_fd_extension_entrypoints.vkGetMemoryFdPropertiesKHR = reinterpret_cast<PFN_vkGetMemoryFdPropertiesKHR>(get_proc_address("vkGetMemoryFdPropertiesKHR"));
 
-            anvil_assert(m_khr_external_memory_win32_extension_entrypoints.vkGetMemoryFdKHR           != nullptr);
-            anvil_assert(m_khr_external_memory_win32_extension_entrypoints.vkGetMemoryFdPropertiesKHR != nullptr);
+            anvil_assert(m_khr_external_memory_fd_extension_entrypoints.vkGetMemoryFdKHR           != nullptr);
+            anvil_assert(m_khr_external_memory_fd_extension_entrypoints.vkGetMemoryFdPropertiesKHR != nullptr);
         }
 
         if (m_extension_enabled_info_ptr->get_device_extension_info()->khr_external_semaphore_fd() )
@@ -2115,7 +2115,7 @@ void Anvil::MGPUDevice::init_device()
         auto& physical_device_props = m_parent_physical_devices.at(n_physical_device);
 
         anvil_assert( present_caps.presentMask[n_physical_device] == 0                                                                                    ||
-                      present_caps.presentMask[n_physical_device] != 0 && (present_caps.presentMask[n_physical_device] & (1 << n_physical_device) ) != 0);
+                     (present_caps.presentMask[n_physical_device] != 0 && (present_caps.presentMask[n_physical_device] & (1 << n_physical_device) ) != 0));
 
         for (uint32_t n_sub_physical_device = 0;
                       n_sub_physical_device < static_cast<uint32_t>(m_parent_physical_devices.size() );
diff --git a/src/wrappers/fence.cpp b/src/wrappers/fence.cpp
@@ -424,8 +424,8 @@ bool Anvil::Fence::reset_fences(const uint32_t in_n_fences,
         {
             Anvil::Fence& current_fence = in_fences[n_fence_batch * fence_cache_capacity + n_fence];
 
-            anvil_assert(device_ptr == nullptr                                          ||
-                         device_ptr != nullptr && current_fence.m_device_ptr != nullptr);
+            anvil_assert((device_ptr == nullptr)                                          ||
+                         (device_ptr != nullptr && current_fence.m_device_ptr != nullptr) );
 
             device_ptr           = current_fence.m_device_ptr;
             fence_cache[n_fence] = current_fence.m_fence;
diff --git a/src/wrappers/image.cpp b/src/wrappers/image.cpp
@@ -1518,8 +1518,8 @@ bool Anvil::Image::has_aspects(const Anvil::ImageAspectFlags& in_aspects) const
             }
         }
 
-        anvil_assert(!result                                   ||
-                      result && checked_aspects == in_aspects);
+        anvil_assert( !result                                   ||
+                     ( result && checked_aspects == in_aspects));
     }
 
     return result;
@@ -2638,4 +2638,4 @@ void Anvil::Image::upload_mipmaps(const std::vector<MipmapRawData>* in_mipmaps_p
             );
         }
     }
-}
+}
diff --git a/src/wrappers/memory_block.cpp b/src/wrappers/memory_block.cpp
@@ -305,7 +305,7 @@ Anvil::ExternalHandleUniquePtr Anvil::MemoryBlock::export_to_external_memory_han
     else
     {
         result_returned_ptr = Anvil::ExternalHandle::create(result_handle,
-                                                            false); /* in_close_at_destruction_time */
+                                                            is_autorelease_handle); /* in_close_at_destruction_time */
     }
 
     anvil_assert(result_returned_ptr != nullptr);
@@ -464,7 +464,7 @@ bool Anvil::MemoryBlock::init(VkResult* out_opt_result)
                 VkImportMemoryHostPointerInfoEXT handle_info_khr;
 
                 anvil_assert(handle_import_info_ptr->host_ptr != nullptr);
-                anvil_assert(handle_import_info_ptr->handle   == static_cast<Anvil::ExternalHandleType>(nullptr) );
+                anvil_assert(handle_import_info_ptr->handle   == 0);
 
                 handle_info_khr.handleType   = static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>(imported_external_memory_handle_type);
                 handle_info_khr.pHostPointer = handle_import_info_ptr->host_ptr;
@@ -490,7 +490,7 @@ bool Anvil::MemoryBlock::init(VkResult* out_opt_result)
                 }
                 #else
                 {
-                    anvil_assert(handle_import_info_ptr->handle != static_cast<Anvil::ExternalHandleType>(nullptr) );
+                    anvil_assert(handle_import_info_ptr->handle != 0);
                 }
                 #endif
 
@@ -883,4 +883,4 @@ bool Anvil::MemoryBlock::write(VkDeviceSize in_start_offset,
 
 end:
     return result;
-}
+}
diff --git a/src/wrappers/physical_device.cpp b/src/wrappers/physical_device.cpp
@@ -1638,8 +1638,24 @@ bool Anvil::PhysicalDevice::supports_core_vk1_1() const
 /* Please see header for specification */
 bool Anvil::PhysicalDevice::supports_core_vk1_1(const uint32_t& in_api_version) const
 {
-    const auto vk_major_version = VK_VERSION_MAJOR(in_api_version);
-    const auto vk_minor_version = VK_VERSION_MINOR(in_api_version);
+    auto vk_major_version = VK_VERSION_MAJOR(in_api_version);
+    auto vk_minor_version = VK_VERSION_MINOR(in_api_version);
+
+    /* Make sure to clamp the version in case API version used to create the parent instance is lower! */
+    const auto instance_api_version   = m_instance_ptr->get_api_version();
+    uint32_t   instance_major_version = 0;
+    uint32_t   instance_minor_version = 0;
+
+    Anvil::Utils::get_version_chunks_for_api_version(instance_api_version,
+                                                    &instance_major_version,
+                                                    &instance_minor_version);
+
+    if ( instance_major_version <  vk_major_version                                               ||
+        (instance_major_version == vk_major_version && instance_minor_version < vk_minor_version))
+    {
+        vk_major_version = instance_major_version;
+        vk_minor_version = instance_minor_version;
+    }
 
     return (vk_major_version >= 2)                          ||
            (vk_major_version == 1 && vk_minor_version >= 1);
diff --git a/src/wrappers/render_pass.cpp b/src/wrappers/render_pass.cpp
@@ -278,7 +278,7 @@ bool Anvil::RenderPass::init_using_core_vk10()
         }
 
         /* NOTE: DS resolve operations are only accessible via KHR_depth_stencil_resolve + KHR_create_renderpass2. */
-        anvil_assert( (*subpass_iterator)->depth_stencil_attachment.resolve_attachment_index != UINT32_MAX);
+        anvil_assert( (*subpass_iterator)->depth_stencil_attachment.resolve_attachment_index == UINT32_MAX);
 
         /* Determine the highest color attachment location & input attachment index. */
         for (auto subpass_color_attachment_iterator  = (*subpass_iterator)->color_attachments_map.cbegin();

Original file line number	Diff line number	Diff line change
`@@ -374,6 +374,10 @@ namespace Anvil`
`374`	`374`	`{`
`375`	`375`	`memory_block_owned_by_image = false;`
`376`	`376`	`memory_block_ptr = nullptr;`
	`377`	`+ memory_block_start_offset = UINT32_MAX;`
	`378`	`+ offset.x = 0;`
	`379`	`+ offset.y = 0;`
	`380`	`+ offset.z = 0;`
`377`	`381`	`}`
`378`	`382`	`} ImageBindInfo;`
`379`	`383`
Original file line number	Diff line number	Diff line change
`@@ -75,4 +75,4 @@ void Anvil::on_assertion_failed(const char* in_filename,`
`75`	`75`	`void Anvil::set_assertion_failure_handler(Anvil::AssertionFailedCallbackFunction in_new_callback_func)`
`76`	`76`	`{`
`77`	`77`	`g_anvil_assertion_check_failed_func = in_new_callback_func;`
`78`		`-}`
	`78`	`+}`