From 7ecaee73c4278fb350e7e3a2953fed8952d57412 Mon Sep 17 00:00:00 2001 From: John Zulauf Date: Fri, 3 May 2024 16:44:46 -0600 Subject: [PATCH] Support multiple simulataneous API capture managers Split common and api specific options from isA to refsA relationship. For single API sessions should be exactly equivalent. --- framework/encode/capture_manager.cpp | 184 ++++++++++---- framework/encode/capture_manager.h | 268 +++++++++++++++++--- framework/encode/d3d12_capture_manager.cpp | 181 ++++++------- framework/encode/d3d12_capture_manager.h | 18 +- framework/encode/vulkan_capture_manager.cpp | 129 +++++----- framework/encode/vulkan_capture_manager.h | 114 ++++----- framework/format/api_call_id.h | 11 +- 7 files changed, 597 insertions(+), 308 deletions(-) diff --git a/framework/encode/capture_manager.cpp b/framework/encode/capture_manager.cpp index 5bfcf9995f..70b5757bce 100644 --- a/framework/encode/capture_manager.cpp +++ b/framework/encode/capture_manager.cpp @@ -51,11 +51,10 @@ std::mutex CaptureManager::ThreadData::count format::ThreadId CaptureManager::ThreadData::thread_count_ = 0; std::unordered_map CaptureManager::ThreadData::id_map_; -uint32_t CaptureManager::instance_count_ = 0; +CaptureManager* CaptureManager::singleton_; std::mutex CaptureManager::instance_lock_; thread_local std::unique_ptr CaptureManager::thread_data_; CaptureManager::ApiCallMutexT CaptureManager::api_call_mutex_; -std::function CaptureManager::delete_instance_func_ = nullptr; std::atomic CaptureManager::unique_id_counter_{ format::kNullHandleId }; @@ -88,8 +87,8 @@ format::ThreadId CaptureManager::ThreadData::GetThreadId() return id; } -CaptureManager::CaptureManager(format::ApiFamilyId api_family) : - api_family_(api_family), force_file_flush_(false), timestamp_filename_(true), +CaptureManager::CaptureManager() : + force_file_flush_(false), timestamp_filename_(true), memory_tracking_mode_(CaptureSettings::MemoryTrackingMode::kPageGuard), page_guard_align_buffer_sizes_(false), page_guard_track_ahb_memory_(false), page_guard_unblock_sigsegv_(false), page_guard_signal_handler_watcher_(false), page_guard_memory_mode_(kMemoryModeShadowInternal), trim_enabled_(false), @@ -112,90 +111,128 @@ CaptureManager::~CaptureManager() util::Log::Release(); } -bool CaptureManager::CreateInstance(std::function GetInstanceFunc, - std::function NewInstanceFunc, - std::function DeleteInstanceFunc) +bool CaptureManager::CreateInstance(ApiCaptureManagerBase* api_capture_singleton, + const std::function& destroyer) { - bool success = true; std::lock_guard instance_lock(instance_lock_); - if (instance_count_ == 0) + if (!singleton_) { - assert(GetInstanceFunc() == nullptr); + singleton_ = new CaptureManager(); + } + + return singleton_->LockedCreateInstance(api_capture_singleton, destroyer); +} + +bool CaptureManager::LockedCreateInstance(ApiCaptureManagerBase* api_capture_singleton, + const std::function& destroyer) +{ + bool success = true; - // Create new instance of capture manager. - instance_count_ = 1; - NewInstanceFunc(); - delete_instance_func_ = DeleteInstanceFunc; + if (instance_count_ == 0) + { if (std::atexit(CaptureManager::AtExit)) { GFXRECON_LOG_WARNING("Failed registering atexit"); } - assert(GetInstanceFunc() != nullptr); - // Initialize logging to report only errors (to stderr). util::Log::Settings stderr_only_log_settings; stderr_only_log_settings.min_severity = util::Log::kErrorSeverity; stderr_only_log_settings.output_errors_to_stderr = true; util::Log::Init(stderr_only_log_settings); - // Get capture settings which can be different per capture manager. - CaptureSettings settings(GetInstanceFunc()->GetDefaultTraceSettings()); + // NOTE: FIRST Api Instance is used for settings -- actual multiple simulatenous API support will need to + // resolve. Get capture settings which can be different per capture manager. + default_settings_ = api_capture_singleton->GetDefaultTraceSettings(); + capture_settings_ = api_capture_singleton->GetDefaultTraceSettings(); // Load log settings. - CaptureSettings::LoadLogSettings(&settings); + CaptureSettings::LoadLogSettings(&capture_settings_); // Reinitialize logging with values retrieved from settings. util::Log::Release(); - util::Log::Init(settings.GetLogSettings()); + util::Log::Init(capture_settings_.GetLogSettings()); // Load all settings with final logging settings active. - CaptureSettings::LoadSettings(&settings); + CaptureSettings::LoadSettings(&capture_settings_); GFXRECON_LOG_INFO("Initializing GFXReconstruct capture layer"); GFXRECON_LOG_INFO(" GFXReconstruct Version %s", GFXRECON_PROJECT_VERSION_STRING); - CaptureSettings::TraceSettings trace_settings = settings.GetTraceSettings(); + CaptureSettings::TraceSettings trace_settings = capture_settings_.GetTraceSettings(); std::string base_filename = trace_settings.capture_file; // Initialize capture manager with default settings. - success = GetInstanceFunc()->Initialize(base_filename, trace_settings); + success = Initialize(base_filename, trace_settings); if (!success) { GFXRECON_LOG_FATAL("Failed to initialize CaptureManager"); } } + + // Add the api capture managers to the list + GFXRECON_ASSERT(api_capture_singleton != nullptr); + auto manager_it = api_capture_managers_.find(api_capture_singleton); + if (manager_it == api_capture_managers_.end()) + { + // Add the Api Capture Manager to this list, and point it back to this common manager. + auto inserted = + api_capture_managers_.insert(std::make_pair(api_capture_singleton, ApiInstanceRecord{ 1, destroyer })); + api_capture_singleton->SetCommonManager(this); + GFXRECON_ASSERT(inserted.second); + manager_it = inserted.first; + + // NOTE: moved here from CaptureTracker::Initialize... DRY'r than putting it into the API specific + // CreateInstances. For actual multiple simulatenous API support we need to ensure all API capture manager + // state trackers are in the correct state given the differing settings that may be present. + if ((capture_mode_ & kModeTrack) == kModeTrack) + { + api_capture_singleton->CreateStateTracker(); + } + } else { - assert(GetInstanceFunc() != nullptr); - ++instance_count_; + ++manager_it->second.count; } + ++instance_count_; + GFXRECON_LOG_DEBUG("CaptureManager::CreateInstance(): Current instance count is %u", instance_count_); return success; } -void CaptureManager::DestroyInstance(std::function GetInstanceFunc) +void CaptureManager::DestroyInstance(ApiCaptureManagerBase* api_capture_manager) { std::lock_guard instance_lock(instance_lock_); - if (GetInstanceFunc() != nullptr) + GFXRECON_ASSERT(instance_count_ > 0); + + auto manager_it = api_capture_managers_.find(api_capture_manager); + GFXRECON_ASSERT(manager_it != api_capture_managers_.end()); + + if (manager_it != api_capture_managers_.end()) { - assert(instance_count_ > 0); + GFXRECON_ASSERT(manager_it->second.count > 0); + --manager_it->second.count; + if (manager_it->second.count == 0) + { + GFXRECON_ASSERT(manager_it->first); + manager_it->second.destroyer(); + api_capture_managers_.erase(manager_it); + } --instance_count_; + GFXRECON_LOG_DEBUG("CaptureManager::DestroyInstance(): Current instance count is %u", instance_count_); if (instance_count_ == 0) { - assert(delete_instance_func_); - delete_instance_func_(); - delete_instance_func_ = nullptr; - assert(GetInstanceFunc() == nullptr); + // NOTE: This delete is deleting this, so don't touch the object after this is done. + GFXRECON_ASSERT(this == singleton_); + delete singleton_; + singleton_ = nullptr; } - - GFXRECON_LOG_DEBUG("CaptureManager::DestroyInstance(): Current instance count is %u", instance_count_); } } @@ -426,11 +463,6 @@ bool CaptureManager::Initialize(std::string base_filename, const CaptureSettings trace_settings.page_guard_signal_handler_watcher_max_restores, mem_prot_mode); } - - if ((capture_mode_ & kModeTrack) == kModeTrack) - { - CreateStateTracker(); - } } else { @@ -440,6 +472,24 @@ bool CaptureManager::Initialize(std::string base_filename, const CaptureSettings return success; } +CaptureManager::ThreadData* CaptureManager::GetThreadData() +{ + if (!thread_data_) + { + thread_data_ = std::make_unique(); + } + return thread_data_.get(); +} + +bool CaptureManager::IsCaptureModeTrack() const +{ + return (GetCaptureMode() & kModeTrack) == kModeTrack; +} +bool CaptureManager::IsCaptureModeWrite() const +{ + return (GetCaptureMode() & kModeWrite) == kModeWrite; +} + ParameterEncoder* CaptureManager::InitApiCallCapture(format::ApiCallId call_id) { auto thread_data = GetThreadData(); @@ -640,7 +690,11 @@ void CaptureManager::CheckContinueCaptureForWriteMode(uint32_t current_boundary_ trim_enabled_ = false; trim_boundary_ = CaptureSettings::TrimBoundary::kUnknown; capture_mode_ = kModeDisabled; - DestroyStateTracker(); + // Clean up all of the capture manager's state trackers + for (auto& manager_it : api_capture_managers_) + { + manager_it.first->DestroyStateTracker(); + } compressor_ = nullptr; } else if (trim_ranges_[trim_current_range_].first == current_boundary_count) @@ -911,7 +965,8 @@ void CaptureManager::ActivateTrimming() auto thread_data = GetThreadData(); assert(thread_data != nullptr); - WriteTrackedState(file_stream_.get(), thread_data->thread_id_); + for (auto& manager : api_capture_managers_) + manager.first->WriteTrackedState(file_stream_.get(), thread_data->thread_id_); } void CaptureManager::DeactivateTrimming() @@ -954,6 +1009,21 @@ void CaptureManager::BuildOptionList(const format::EnabledOptions& enable option_list->push_back({ format::FileOption::kCompressionType, enabled_options.compression_type }); } +format::ApiFamilyId CaptureManager::GetApiFamily() const +{ + const format::ApiFamilyId none_id = format::ApiFamilyId::ApiFamily_None; + format::ApiFamilyId id = none_id; + const size_t manager_count = api_capture_managers_.size(); + if (manager_count == 1) + { + id = api_capture_managers_.cbegin()->first->GetApiFamily(); + } + else if (manager_count > 1) + { + id = format::ApiFamilyId::ApiFamily_Multiple; + } + return id; +} void CaptureManager::WriteDisplayMessageCmd(const char* message) { if ((capture_mode_ & kModeWrite) == kModeWrite) @@ -964,8 +1034,11 @@ void CaptureManager::WriteDisplayMessageCmd(const char* message) message_cmd.meta_header.block_header.type = format::BlockType::kMetaDataBlock; message_cmd.meta_header.block_header.size = format::GetMetaDataBlockBaseSize(message_cmd) + message_length; + + // NOTE: The message output may vary based on the ordering of Instance Creation/Destruction relative to + // message generation. Need to addres for actual multiple simulatenous API support. message_cmd.meta_header.meta_data_id = - format::MakeMetaDataId(api_family_, format::MetaDataType::kDisplayMessageCommand); + format::MakeMetaDataId(GetApiFamily(), format::MetaDataType::kDisplayMessageCommand); message_cmd.thread_id = thread_data->thread_id_; CombineAndWriteToFile({ { &message_cmd, sizeof(message_cmd) }, { message, message_length } }); @@ -982,7 +1055,7 @@ void CaptureManager::WriteExeFileInfo(const gfxrecon::util::filepath::FileInfo& exe_info_header.meta_header.block_header.type = format::BlockType::kMetaDataBlock; exe_info_header.meta_header.block_header.size = format::GetMetaDataBlockBaseSize(exe_info_header); exe_info_header.meta_header.meta_data_id = - format::MakeMetaDataId(api_family_, format::MetaDataType::kExeFileInfoCommand); + format::MakeMetaDataId(GetApiFamily(), format::MetaDataType::kExeFileInfoCommand); exe_info_header.thread_id = thread_data->thread_id_; WriteToFile(&exe_info_header, sizeof(exe_info_header)); @@ -1022,7 +1095,7 @@ void CaptureManager::WriteResizeWindowCmd(format::HandleId surface_id, uint32_t resize_cmd.meta_header.block_header.type = format::BlockType::kMetaDataBlock; resize_cmd.meta_header.block_header.size = format::GetMetaDataBlockBaseSize(resize_cmd); resize_cmd.meta_header.meta_data_id = - format::MakeMetaDataId(api_family_, format::MetaDataType::kResizeWindowCommand); + format::MakeMetaDataId(GetApiFamily(), format::MetaDataType::kResizeWindowCommand); resize_cmd.thread_id = thread_data->thread_id_; resize_cmd.surface_id = surface_id; @@ -1049,7 +1122,7 @@ void CaptureManager::WriteFillMemoryCmd(format::HandleId memory_id, uint64_t off fill_cmd.meta_header.block_header.type = format::BlockType::kMetaDataBlock; fill_cmd.meta_header.meta_data_id = - format::MakeMetaDataId(api_family_, format::MetaDataType::kFillMemoryCommand); + format::MakeMetaDataId(GetApiFamily(), format::MetaDataType::kFillMemoryCommand); fill_cmd.thread_id = thread_data->thread_id_; fill_cmd.memory_id = memory_id; fill_cmd.memory_offset = offset; @@ -1092,7 +1165,7 @@ void CaptureManager::WriteFillMemoryCmd(format::HandleId memory_id, uint64_t off void CaptureManager::WriteCreateHeapAllocationCmd(uint64_t allocation_id, uint64_t allocation_size) { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { format::CreateHeapAllocationCommand allocation_cmd; @@ -1102,7 +1175,7 @@ void CaptureManager::WriteCreateHeapAllocationCmd(uint64_t allocation_id, uint64 allocation_cmd.meta_header.block_header.type = format::BlockType::kMetaDataBlock; allocation_cmd.meta_header.block_header.size = format::GetMetaDataBlockBaseSize(allocation_cmd); allocation_cmd.meta_header.meta_data_id = - format::MakeMetaDataId(api_family_, format::MetaDataType::kCreateHeapAllocationCommand); + format::MakeMetaDataId(GetApiFamily(), format::MetaDataType::kCreateHeapAllocationCommand); allocation_cmd.thread_id = thread_data->thread_id_; allocation_cmd.allocation_id = allocation_id; allocation_cmd.allocation_size = allocation_size; @@ -1151,9 +1224,22 @@ void CaptureManager::WriteToFile(const void* data, size_t size) thread_data->block_index_ = block_index_.load(); } +void CaptureManager::AtExit() +{ + if (CaptureManager::singleton_) + { + for (auto& api_capture_manager : singleton_->api_capture_managers_) + { + api_capture_manager.second.destroyer(); + } + delete CaptureManager::singleton_; + CaptureManager::singleton_ = nullptr; + } +} + void CaptureManager::WriteCaptureOptions(std::string& operation_annotation) { - CaptureSettings::TraceSettings default_settings = GetDefaultTraceSettings(); + CaptureSettings::TraceSettings default_settings = default_settings_.GetTraceSettings(); std::string buffer; if (force_file_flush_ != default_settings.force_flush) @@ -1251,7 +1337,7 @@ void CaptureManager::WriteCaptureOptions(std::string& operation_annotation) operation_annotation += "\n }"; } -CaptureSettings::TraceSettings CaptureManager::GetDefaultTraceSettings() +CaptureSettings::TraceSettings ApiCaptureManagerBase::GetDefaultTraceSettings() { // Return default trace settings. return CaptureSettings::TraceSettings(); diff --git a/framework/encode/capture_manager.h b/framework/encode/capture_manager.h index 70cdae0d43..2b6f106bb2 100644 --- a/framework/encode/capture_manager.h +++ b/framework/encode/capture_manager.h @@ -49,6 +49,11 @@ GFXRECON_BEGIN_NAMESPACE(gfxrecon) GFXRECON_BEGIN_NAMESPACE(encode) +class ApiCaptureManagerBase; +class VulkanCaptureManager; +class D3D12CaptureManager; + +// The CaptureManager provides common functionality referenced API specific capture managers class CaptureManager { public: @@ -137,6 +142,8 @@ class CaptureManager bool RuntimeTriggerDisabled(); + format::ApiFamilyId GetApiFamily() const; + void WriteDisplayMessageCmd(const char* message); void WriteExeFileInfo(const gfxrecon::util::filepath::FileInfo& info); @@ -149,8 +156,6 @@ class CaptureManager /// @param data The value or payload text of the annotation. void WriteAnnotation(const format::AnnotationType type, const char* label, const char* data); - virtual CaptureSettings::TraceSettings GetDefaultTraceSettings(); - bool GetIUnknownWrappingSetting() const { return iunknown_wrapping_; } auto GetForceCommandSerialization() const { return force_command_serialization_; } auto GetQueueZeroOnly() const { return queue_zero_only_; } @@ -167,7 +172,15 @@ class CaptureManager return thread_data->block_index_ == 0 ? 0 : thread_data->block_index_ - 1; } - protected: + static bool CreateInstance(ApiCaptureManagerBase* api_instance_, const std::function& destroyer); + template + static bool CreateInstance() + { + return CreateInstance(Derived::InitSingleton(), Derived::DestroySingleton); + } + + CaptureManager(); + enum CaptureModeFlags : uint32_t { kModeDisabled = 0x0, @@ -218,32 +231,20 @@ class CaptureManager std::vector scratch_buffer_; }; - protected: - static bool CreateInstance(std::function GetInstanceFunc, - std::function NewInstanceFunc, - std::function DeleteInstanceFunc); + ThreadData* GetThreadData(); + bool IsCaptureModeTrack() const; + bool IsCaptureModeWrite() const; - static void DestroyInstance(std::function GetInstanceFunc); + void DestroyInstance(ApiCaptureManagerBase* singleton); - CaptureManager(format::ApiFamilyId api_family); + protected: + bool LockedCreateInstance(ApiCaptureManagerBase* api_capture_singleton, const std::function& destroyer); virtual ~CaptureManager(); bool Initialize(std::string base_filename, const CaptureSettings::TraceSettings& trace_settings); - virtual void CreateStateTracker() = 0; - virtual void DestroyStateTracker() = 0; - virtual void WriteTrackedState(util::FileOutputStream* file_stream, format::ThreadId thread_id) = 0; - - ThreadData* GetThreadData() - { - if (!thread_data_) - { - thread_data_ = std::make_unique(); - } - return thread_data_.get(); - } - + public: bool GetForceFileFlush() const { return force_file_flush_; } CaptureSettings::MemoryTrackingMode GetMemoryTrackingMode() const { return memory_tracking_mode_; } bool GetPageGuardAlignBufferSizes() const { return page_guard_align_buffer_sizes_; } @@ -258,6 +259,12 @@ class CaptureManager bool GetDisableDxrSetting() const { return disable_dxr_; } auto GetAccelStructPaddingSetting() const { return accel_struct_padding_; } + util::Compressor* GetCompressor() { return compressor_.get(); } + std::mutex& GetMappedMemoryLock() { return mapped_memory_lock_; } + util::Keyboard& GetKeyboard() { return keyboard_; } + const std::string& GetScreenshotPrefix() const { return screenshot_prefix_; } + util::ScreenshotFormat GetScreenShotFormat() const { return screenshot_format_; } + std::string CreateTrimFilename(const std::string& base_filename, const util::UintRange& trim_range); bool CreateCaptureFile(const std::string& base_filename); void WriteCaptureOptions(std::string& operation_annotation); @@ -278,14 +285,6 @@ class CaptureManager void WriteCreateHeapAllocationCmd(uint64_t allocation_id, uint64_t allocation_size); - protected: - std::unique_ptr compressor_; - std::mutex mapped_memory_lock_; - util::Keyboard keyboard_; - std::string screenshot_prefix_; - util::ScreenshotFormat screenshot_format_; - std::atomic block_index_; - void WriteToFile(const void* data, size_t size); template @@ -306,24 +305,41 @@ class CaptureManager WriteToFile(scratch_buffer.data(), scratch_buffer.size()); } - private: - static void AtExit() + void IncrementBlockIndex(uint64_t blocks) { - if (delete_instance_func_) - { - delete_instance_func_(); - delete_instance_func_ = nullptr; - } + block_index_ += blocks; + GetThreadData()->block_index_ = block_index_; } + protected: + std::unique_ptr compressor_; + std::mutex mapped_memory_lock_; + util::Keyboard keyboard_; + std::string screenshot_prefix_; + util::ScreenshotFormat screenshot_format_; + std::atomic block_index_; + + private: + static void AtExit(); + private: - static uint32_t instance_count_; static std::mutex instance_lock_; + static CaptureManager* singleton_; static thread_local std::unique_ptr thread_data_; static std::atomic unique_id_counter_; static ApiCallMutexT api_call_mutex_; - const format::ApiFamilyId api_family_; + uint32_t instance_count_ = 0; + struct ApiInstanceRecord + { + size_t count; + std::function destroyer; + }; + using ApiCaptureManagerMap = std::unordered_map; + ApiCaptureManagerMap api_capture_managers_; + + CaptureSettings default_settings_; + CaptureSettings capture_settings_; std::unique_ptr file_stream_; format::EnabledOptions file_options_; @@ -363,7 +379,6 @@ class CaptureManager bool queue_zero_only_; bool allow_pipeline_compile_required_; bool quit_after_frame_ranges_; - static std::function delete_instance_func_; struct { @@ -374,6 +389,179 @@ class CaptureManager } rv_annotation_info_; }; +class ApiCaptureManagerBase +{ + public: + ApiCaptureManagerBase(format::ApiFamilyId api_family) : api_family_(api_family) {} + void SetCommonManager(CaptureManager* common_manager) { common_manager_ = common_manager; } + + // Forwarded Statics + static format::HandleId GetUniqueId() { return CaptureManager::GetUniqueId(); } + static auto AcquireSharedApiCallLock() { return std::move(CaptureManager::AcquireSharedApiCallLock()); } + + static auto AcquireExclusiveApiCallLock() { return std::move(CaptureManager::AcquireExclusiveApiCallLock()); } + + // Virtual interface + virtual void CreateStateTracker() = 0; + virtual void DestroyStateTracker() = 0; + virtual void WriteTrackedState(util::FileOutputStream* file_stream, format::ThreadId thread_id) = 0; + virtual CaptureSettings::TraceSettings GetDefaultTraceSettings(); + + format::ApiFamilyId GetApiFamily() const { return api_family_; } + bool IsCaptureModeTrack() const { return common_manager_->IsCaptureModeTrack(); } + bool IsCaptureModeWrite() const { return common_manager_->IsCaptureModeWrite(); } + + bool IsPageGuardMemoryModeDisabled() const + { + return GetPageGuardMemoryMode() == CaptureManager::kMemoryModeDisabled; + } + bool IsPageGuardMemoryModeShadowInternal() const + { + return GetPageGuardMemoryMode() == CaptureManager::kMemoryModeShadowInternal; + } + bool IsPageGuardMemoryModeShadowPersistent() const + { + return GetPageGuardMemoryMode() == CaptureManager::kMemoryModeShadowPersistent; + } + bool IsPageGuardMemoryModeExternal() const + { + return GetPageGuardMemoryMode() == CaptureManager::kMemoryModeExternal; + } + + typedef uint32_t CaptureMode; + + // Forwarded Common Methods + HandleUnwrapMemory* GetHandleUnwrapMemory() { return common_manager_->GetHandleUnwrapMemory(); } + ParameterEncoder* BeginTrackedApiCallCapture(format::ApiCallId call_id) + { + return common_manager_->BeginTrackedApiCallCapture(call_id); + } + ParameterEncoder* BeginApiCallCapture(format::ApiCallId call_id) + { + return common_manager_->BeginApiCallCapture(call_id); + } + ParameterEncoder* BeginTrackedMethodCallCapture(format::ApiCallId call_id, format::HandleId object_id) + { + return common_manager_->BeginTrackedMethodCallCapture(call_id, object_id); + } + ParameterEncoder* BeginMethodCallCapture(format::ApiCallId call_id, format::HandleId object_id) + { + return common_manager_->BeginMethodCallCapture(call_id, object_id); + } + void EndApiCallCapture() { common_manager_->EndApiCallCapture(); } + + void EndMethodCallCapture() { common_manager_->EndMethodCallCapture(); } + + void WriteFrameMarker(format::MarkerType marker_type) { common_manager_->WriteFrameMarker(marker_type); } + + void EndFrame() { common_manager_->EndFrame(); } + + // Pre/PostQueueSubmit to be called immediately before and after work is submitted to the GPU by vkQueueSubmit for + // Vulkan or by ID3D12CommandQueue::ExecuteCommandLists for DX12. + void PreQueueSubmit() { common_manager_->PreQueueSubmit(); } + void PostQueueSubmit() { common_manager_->PostQueueSubmit(); } + + bool ShouldTriggerScreenshot() { return common_manager_->ShouldTriggerScreenshot(); } + + void CheckContinueCaptureForWriteMode(uint32_t current_boundary_count) + { + common_manager_->CheckContinueCaptureForWriteMode(current_boundary_count); + } + + void CheckStartCaptureForTrackMode(uint32_t current_boundary_count) + { + common_manager_->CheckStartCaptureForTrackMode(current_boundary_count); + } + + bool IsTrimHotkeyPressed() { return common_manager_->IsTrimHotkeyPressed(); } + + CaptureSettings::RuntimeTriggerState GetRuntimeTriggerState() { return common_manager_->GetRuntimeTriggerState(); } + + bool RuntimeTriggerEnabled() { return common_manager_->RuntimeTriggerEnabled(); } + + bool RuntimeTriggerDisabled() { return common_manager_->RuntimeTriggerDisabled(); } + + void WriteDisplayMessageCmd(const char* message) { common_manager_->WriteDisplayMessageCmd(message); } + + void WriteExeFileInfo(const gfxrecon::util::filepath::FileInfo& info) { common_manager_->WriteExeFileInfo(info); } + + void ForcedWriteAnnotation(const format::AnnotationType type, const char* label, const char* data) + { + common_manager_->ForcedWriteAnnotation(type, label, data); + } + + /// @brief Inject an Annotation block into the capture file. + /// @param type Identifies the contents of data as plain, xml, or json text + /// @param label The key or name of the annotation. + /// @param data The value or payload text of the annotation. + void WriteAnnotation(const format::AnnotationType type, const char* label, const char* data) + { + common_manager_->WriteAnnotation(type, label, data); + } + + bool GetIUnknownWrappingSetting() const { return common_manager_->GetIUnknownWrappingSetting(); } + auto GetForceCommandSerialization() const { return common_manager_->GetForceCommandSerialization(); } + auto GetQueueZeroOnly() const { return common_manager_->GetQueueZeroOnly(); } + auto GetAllowPipelineCompileRequired() const { return common_manager_->GetAllowPipelineCompileRequired(); } + + bool IsAnnotated() const { return common_manager_->IsAnnotated(); } + uint16_t GetGPUVAMask() const { return common_manager_->GetGPUVAMask(); } + uint16_t GetDescriptorMask() const { return common_manager_->GetDescriptorMask(); } + uint64_t GetShaderIDMask() const { return common_manager_->GetShaderIDMask(); } + uint64_t GetBlockIndex() const { return common_manager_->GetBlockIndex(); } + + bool GetForceFileFlush() const { return common_manager_->GetForceFileFlush(); } + CaptureSettings::MemoryTrackingMode GetMemoryTrackingMode() const + { + return common_manager_->GetMemoryTrackingMode(); + } + bool GetPageGuardAlignBufferSizes() const { return common_manager_->GetPageGuardAlignBufferSizes(); } + bool GetPageGuardTrackAhbMemory() const { return common_manager_->GetPageGuardTrackAhbMemory(); } + CaptureManager::PageGuardMemoryMode GetPageGuardMemoryMode() const + { + return common_manager_->GetPageGuardMemoryMode(); + } + const std::string& GetTrimKey() const { return common_manager_->GetTrimKey(); } + bool IsTrimEnabled() const { return common_manager_->IsTrimEnabled(); } + uint32_t GetCurrentFrame() const { return common_manager_->GetCurrentFrame(); } + CaptureManager::CaptureMode GetCaptureMode() const { return common_manager_->GetCaptureMode(); } + bool GetDebugLayerSetting() const { return common_manager_->GetDebugLayerSetting(); } + bool GetDebugDeviceLostSetting() const { return common_manager_->GetDebugDeviceLostSetting(); } + bool GetDisableDxrSetting() const { return common_manager_->GetDisableDxrSetting(); } + auto GetAccelStructPaddingSetting() const { return common_manager_->GetAccelStructPaddingSetting(); } + + void WriteResizeWindowCmd(format::HandleId surface_id, uint32_t width, uint32_t height) + { + common_manager_->WriteResizeWindowCmd(surface_id, width, height); + } + void WriteFillMemoryCmd(format::HandleId memory_id, uint64_t offset, uint64_t size, const void* data) + { + common_manager_->WriteFillMemoryCmd(memory_id, offset, size, data); + } + void WriteCreateHeapAllocationCmd(uint64_t allocation_id, uint64_t allocation_size) + { + common_manager_->WriteCreateHeapAllocationCmd(allocation_id, allocation_size); + } + void WriteToFile(const void* data, size_t size) { common_manager_->WriteToFile(data, size); } + + template + void CombineAndWriteToFile(const std::pair (&buffers)[N]) + { + common_manager_->CombineAndWriteToFile(buffers); + } + + CaptureManager::ThreadData* GetThreadData() { return common_manager_->GetThreadData(); } + util::Compressor* GetCompressor() { return common_manager_->GetCompressor(); } + std::mutex& GetMappedMemoryLock() { return common_manager_->GetMappedMemoryLock(); } + util::Keyboard& GetKeyboard() { return common_manager_->GetKeyboard(); } + const std::string& GetScreenshotPrefix() const { return common_manager_->GetScreenshotPrefix(); } + util::ScreenshotFormat GetScreenshotFormat() { return common_manager_->GetScreenshotFormat(); } + + protected: + const format::ApiFamilyId api_family_; + CaptureManager* common_manager_ = nullptr; +}; + GFXRECON_END_NAMESPACE(encode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/encode/d3d12_capture_manager.cpp b/framework/encode/d3d12_capture_manager.cpp index a696c39073..966ab2833c 100644 --- a/framework/encode/d3d12_capture_manager.cpp +++ b/framework/encode/d3d12_capture_manager.cpp @@ -35,44 +35,55 @@ GFXRECON_BEGIN_NAMESPACE(encode) static constexpr char kDx12RuntimeName[] = "D3D12Core.dll"; -D3D12CaptureManager* D3D12CaptureManager::instance_ = nullptr; +D3D12CaptureManager* D3D12CaptureManager::singleton_ = nullptr; thread_local uint32_t D3D12CaptureManager::call_scope_ = 0; D3D12CaptureManager::D3D12CaptureManager() : - CaptureManager(format::ApiFamilyId::ApiFamily_D3D12), dxgi_dispatch_table_{}, d3d12_dispatch_table_{}, + ApiCaptureManagerBase(format::ApiFamilyId::ApiFamily_D3D12), dxgi_dispatch_table_{}, d3d12_dispatch_table_{}, debug_layer_enabled_(false), debug_device_lost_enabled_(false), track_enable_debug_layer_object_id_(format::kNullHandleId), frame_buffer_renderer_(nullptr) {} bool D3D12CaptureManager::CreateInstance() { - bool ret = CaptureManager::CreateInstance([]() -> CaptureManager* { return instance_; }, - []() { - assert(instance_ == nullptr); - instance_ = new D3D12CaptureManager(); - }, - []() { - if (instance_) - { - delete instance_; - instance_ = nullptr; - } - }); - if (instance_->IsAnnotated() == true && instance_->resource_value_annotator_ == nullptr) - { - instance_->resource_value_annotator_ = std::make_unique(); + bool ret = CaptureManager::CreateInstance(); + + GFXRECON_ASSERT(singleton_); + + if (singleton_->IsAnnotated() == true && singleton_->resource_value_annotator_ == nullptr) + { + singleton_->resource_value_annotator_ = std::make_unique(); } return ret; } +D3D12CaptureManager* D3D12CaptureManager::InitSingleton() +{ + if (singleton_) + { + singleton_ = new D3D12CaptureManager(); + } + return singleton_; +} + +void D3D12CaptureManager::DestroySingleton() +{ + if (singleton_) + { + delete singleton_; + singleton_ = nullptr; + } +} + void D3D12CaptureManager::DestroyInstance() { - CaptureManager::DestroyInstance([]() -> const CaptureManager* { return instance_; }); + GFXRECON_ASSERT(singleton_ && singleton_->common_manager_); + singleton_->common_manager_->DestroyInstance(singleton_); } void D3D12CaptureManager::EndCreateApiCallCapture(HRESULT result, REFIID riid, void** handle) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && SUCCEEDED(result)) + if (IsCaptureModeTrack() && SUCCEEDED(result)) { if ((handle != nullptr) && (*handle != nullptr)) { @@ -92,7 +103,7 @@ void D3D12CaptureManager::EndCreateApiCallCapture(HRESULT result, REFIID riid, v #ifdef GFXRECON_AGS_SUPPORT void D3D12CaptureManager::EndAgsApiCallCapture(HRESULT result, void* object_ptr) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { if (SUCCEEDED(result)) { @@ -110,7 +121,7 @@ void D3D12CaptureManager::EndAgsApiCallCapture(HRESULT result, void* object_ptr) void D3D12CaptureManager::EndAgsApiCallCapture(ID3D12GraphicsCommandList_Wrapper* list_wrapper) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); @@ -129,7 +140,7 @@ void D3D12CaptureManager::EndAgsApiCallCapture(ID3D12GraphicsCommandList_Wrapper void D3D12CaptureManager::EndCreateDescriptorMethodCallCapture(D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor, ID3D12Device_Wrapper* create_object_wrapper) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (dest_descriptor.ptr != 0)) + if (IsCaptureModeTrack() && (dest_descriptor.ptr != 0)) { auto thread_data = GetThreadData(); assert(thread_data != nullptr); @@ -145,7 +156,7 @@ void D3D12CaptureManager::EndCreateDescriptorMethodCallCapture(D3D12_CPU_DESCRIP void D3D12CaptureManager::EndCommandListMethodCallCapture(ID3D12CommandList_Wrapper* list_wrapper) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); @@ -160,7 +171,7 @@ void D3D12CaptureManager::EndCommandListMethodCallCapture(ID3D12CommandList_Wrap void D3D12CaptureManager::WriteTrackedState(util::FileOutputStream* file_stream, format::ThreadId thread_id) { - Dx12StateWriter state_writer(file_stream, compressor_.get(), thread_id); + Dx12StateWriter state_writer(file_stream, GetCompressor(), thread_id); state_tracker_->WriteState(&state_writer, GetCurrentFrame()); } @@ -195,7 +206,7 @@ void D3D12CaptureManager::PreAcquireSwapChainImages(IDXGISwapChain_Wrapper* wrap info->child_images.resize(image_count); info->swap_effect = swap_effect; - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { // TODO: In VK version, this thing is done in InitializeGroupObjectState, // This might need to be removed to InitializeGroupObjectState when it's ready. @@ -277,7 +288,7 @@ void D3D12CaptureManager::ResizeSwapChainImages(IDXGISwapChain_Wrapper* wrapper, PreAcquireSwapChainImages(wrapper, nullptr, final_buffer_count, info->swap_effect); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackResizeBuffers( wrapper, format::ApiCall_IDXGISwapChain_ResizeBuffers, GetThreadData()->parameter_buffer_.get()); @@ -363,7 +374,7 @@ void D3D12CaptureManager::InitializeID3D12ResourceInfo(ID3D12Device_Wrapper* layouts[i].Footprint.Depth; } } - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackResourceCreation(resource_wrapper, initial_state, false); } @@ -383,7 +394,7 @@ void D3D12CaptureManager::InitializeSwapChainBufferResourceInfo(ID3D12Resource_W info->subresource_sizes = std::make_unique(info->num_subresources); info->subresource_sizes[0] = 0; - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackResourceCreation(resource_wrapper, initial_state, true); } @@ -419,7 +430,7 @@ bool D3D12CaptureManager::IsAccelerationStructureResource(format::HandleId id) void D3D12CaptureManager::CheckWriteWatchIgnored(D3D12_HEAP_FLAGS flags, format::HandleId id) { // Report that write watch was ignored because the application enabled it. - if ((GetPageGuardMemoryMode() == kMemoryModeExternal) && + if (IsPageGuardMemoryModeExternal() && ((flags & D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH) == D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH)) { GFXRECON_LOG_WARNING( @@ -433,7 +444,7 @@ bool D3D12CaptureManager::UseWriteWatch(D3D12_HEAP_TYPE type, D3D12_HEAP_FLAGS flags, D3D12_CPU_PAGE_PROPERTY page_property) { - if ((GetPageGuardMemoryMode() == kMemoryModeExternal) && + if (IsPageGuardMemoryModeExternal() && ((flags & D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH) != D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH) && IsUploadResource(type, page_property)) { @@ -585,8 +596,8 @@ void D3D12CaptureManager::PrePresent(IDXGISwapChain_Wrapper* swapchain_wrapper) swapchain_info->command_queue, swapchain, GetCurrentFrame(), - screenshot_prefix_, - screenshot_format_); + common_manager_->GetScreenshotPrefix(), + common_manager_->GetScreenshotFormat()); } else { @@ -983,14 +994,14 @@ void D3D12CaptureManager::PreProcess_ID3D12Device3_OpenExistingHeapFromAddress(I GFXRECON_UNREFERENCED_PARAMETER(riid); GFXRECON_UNREFERENCED_PARAMETER(heap); - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { MEMORY_BASIC_INFORMATION info{}; auto result = VirtualQuery(address, &info, sizeof(info)); if (result > 0) { - WriteCreateHeapAllocationCmd(reinterpret_cast(address), info.RegionSize); + common_manager_->WriteCreateHeapAllocationCmd(reinterpret_cast(address), info.RegionSize); } else { @@ -1007,7 +1018,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device3_OpenExistingHeapFromAddress( GFXRECON_UNREFERENCED_PARAMETER(wrapper); GFXRECON_UNREFERENCED_PARAMETER(riid); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { if (SUCCEEDED(result) && (heap != nullptr) && ((*heap) != nullptr)) { @@ -1260,7 +1271,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Resource_Map( { auto& mapped_subresource = info->mapped_subresources[subresource]; - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); if (++mapped_subresource.map_count == 1) { mapped_subresource.data = (*data); @@ -1281,7 +1292,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Resource_Map( use_shadow_memory = false; use_write_watch = true; } - else if ((GetPageGuardMemoryMode() == kMemoryModeShadowPersistent) && + else if (IsPageGuardMemoryModeShadowPersistent() && (mapped_subresource.shadow_allocation == util::PageGuardManager::kNullShadowHandle)) { mapped_subresource.shadow_allocation = @@ -1349,7 +1360,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Resource_Map( { auto& mapped_subresource = info->mapped_subresources[subresource]; - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); if (++mapped_subresource.map_count == 1) { if (GetMemoryTrackingMode() == CaptureSettings::MemoryTrackingMode::kUnassisted) @@ -1381,7 +1392,7 @@ void D3D12CaptureManager::PreProcess_ID3D12Resource_Unmap(ID3D12Resource_Wrapper if (mapped_subresource.data != nullptr) { // Handle first case, when mapped_subresource.data != null (like we've always done): - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); if (mapped_subresource.map_count > 0) { if ((--mapped_subresource.map_count == 0) && (mapped_subresource.data != nullptr)) @@ -1467,7 +1478,7 @@ void D3D12CaptureManager::PreProcess_ID3D12Resource_Unmap(ID3D12Resource_Wrapper // WriteToSubresource." // // Source: https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12resource-map - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); if (mapped_subresource.map_count > 0) { if (--mapped_subresource.map_count == 0) @@ -1514,7 +1525,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Resource_GetHeapProperties(ID3D12Res GFXRECON_UNREFERENCED_PARAMETER(wrapper); GFXRECON_UNREFERENCED_PARAMETER(heap_properties); - if (SUCCEEDED(result) && (heap_flags != nullptr) && (GetPageGuardMemoryMode() == kMemoryModeExternal)) + if (SUCCEEDED(result) && (heap_flags != nullptr) && (IsPageGuardMemoryModeExternal())) { auto info = wrapper->GetObjectInfo(); assert(info != nullptr); @@ -1541,7 +1552,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Resource_GetHeapProperties(ID3D12Res void D3D12CaptureManager::PostProcess_ID3D12Resource_GetGPUVirtualAddress(ID3D12Resource_Wrapper* wrapper, D3D12_GPU_VIRTUAL_ADDRESS result) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result != 0)) + if (IsCaptureModeTrack() && (result != 0)) { state_tracker_->TrackResourceGpuVa(wrapper, result); } @@ -1556,7 +1567,7 @@ bool D3D12CaptureManager::AddFillMemoryResourceValueCommand( const std::map& resource_values) { bool success = true; - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { std::vector write_buffer; format::FillMemoryResourceValueCommandHeader rv_header; @@ -1596,10 +1607,10 @@ bool D3D12CaptureManager::AddFillMemoryResourceValueCommand( std::vector compressed_write_buffer; - if (compressor_ != nullptr) + if (GetCompressor() != nullptr) { size_t compressed_size = - compressor_->Compress(write_buffer.size(), write_buffer.data(), &compressed_write_buffer, 0); + GetCompressor()->Compress(write_buffer.size(), write_buffer.data(), &compressed_write_buffer, 0); if ((compressed_size > 0) && (compressed_size < uncompressed_size)) { @@ -1676,7 +1687,7 @@ void D3D12CaptureManager::Destroy_ID3D12Resource(ID3D12Resource_Wrapper* wrapper { // If any subresources were mapped, the resource wrapper needs to be removed from the mapped resource // table. - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); mapped_resources_.erase(wrapper); } } @@ -1687,7 +1698,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Heap_GetDesc(ID3D12Heap_Wrapper* wra { GFXRECON_UNREFERENCED_PARAMETER(wrapper); - if ((GetPageGuardMemoryMode() == kMemoryModeExternal)) + if (IsPageGuardMemoryModeExternal()) { auto info = wrapper->GetObjectInfo(); assert(info != nullptr); @@ -1729,7 +1740,7 @@ void D3D12CaptureManager::PreProcess_ID3D12CommandQueue_ExecuteCommandLists(ID3D } else if (GetMemoryTrackingMode() == CaptureSettings::MemoryTrackingMode::kUnassisted) { - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); for (auto resource_wrapper : mapped_resources_) { auto info = resource_wrapper->GetObjectInfo(); @@ -1767,7 +1778,7 @@ void D3D12CaptureManager::PostProcess_ID3D12CommandQueue_ExecuteCommandLists(ID3 { PostQueueSubmit(); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackExecuteCommandLists(wrapper, num_lists, lists); } @@ -1784,7 +1795,7 @@ D3D12_CPU_DESCRIPTOR_HANDLE D3D12CaptureManager::OverrideID3D12DescriptorHeap_Ge result.ptr = reinterpret_cast(info->descriptor_memory.get()); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { info->cpu_start = result.ptr; } @@ -1801,7 +1812,7 @@ D3D12_GPU_DESCRIPTOR_HANDLE D3D12CaptureManager::OverrideID3D12DescriptorHeap_Ge auto result = heap->GetGPUDescriptorHandleForHeapStart(); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { info->gpu_start = result.ptr; } @@ -2264,7 +2275,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Fence_SetEventOnCompletion(ID3D12Fen { assert(wrapper != nullptr); - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && SUCCEEDED(result)) + if (IsCaptureModeTrack() && SUCCEEDED(result)) { state_tracker_->TrackFenceSetEventOnCompletion(wrapper, value, event); } @@ -2274,7 +2285,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Fence_Signal(ID3D12Fence_Wrapper* wr { assert(wrapper != nullptr); - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && SUCCEEDED(result)) + if (IsCaptureModeTrack() && SUCCEEDED(result)) { state_tracker_->TrackFenceSignal(wrapper, value); } @@ -2289,7 +2300,7 @@ void D3D12CaptureManager::PostProcess_ID3D12CommandQueue_Signal(ID3D12CommandQue assert(fence != nullptr); - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && SUCCEEDED(result)) + if (IsCaptureModeTrack() && SUCCEEDED(result)) { auto fence_wrapper = reinterpret_cast(fence); state_tracker_->TrackFenceSignal(fence_wrapper, value); @@ -2300,7 +2311,7 @@ void D3D12CaptureManager::PostProcess_ID3D12GraphicsCommandList_ResourceBarrier( UINT num_barriers, const D3D12_RESOURCE_BARRIER* barriers) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackResourceBarriers(list_wrapper, num_barriers, barriers); } @@ -2315,7 +2326,7 @@ void D3D12CaptureManager::PostProcess_ID3D12GraphicsCommandList4_BuildRaytracing GFXRECON_UNREFERENCED_PARAMETER(num_postbuild_info_descs); GFXRECON_UNREFERENCED_PARAMETER(postbuild_info_descs); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackBuildRaytracingAccelerationStructure(list_wrapper, desc); } @@ -2327,7 +2338,7 @@ void D3D12CaptureManager::PostProcess_ID3D12GraphicsCommandList4_CopyRaytracingA D3D12_GPU_VIRTUAL_ADDRESS source_acceleration_structure_data, D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE mode) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackCopyRaytracingAccelerationStructure( list_wrapper, dest_acceleration_structure_data, source_acceleration_structure_data, mode); @@ -2343,7 +2354,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device_CreateCommandList(ID3D12Devic REFIID riid, void** ppCommandList) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { auto list_wrapper = reinterpret_cast(*ppCommandList); state_tracker_->TrackCommandListCreation(list_wrapper, false, type); @@ -2358,7 +2369,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device4_CreateCommandList1(ID3D12Dev REFIID riid, void** ppCommandList) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { auto list_wrapper = reinterpret_cast(*ppCommandList); state_tracker_->TrackCommandListCreation(list_wrapper, true, type); @@ -2402,7 +2413,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device_CopyDescriptors(ID3D12Device_ const UINT* src_range_sizes, D3D12_DESCRIPTOR_HEAP_TYPE heap_type) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { UINT dest_range_i = 0; UINT src_range_i = 0; @@ -2447,7 +2458,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device_CopyDescriptorsSimple(ID3D12D D3D12_CPU_DESCRIPTOR_HANDLE src_start, D3D12_DESCRIPTOR_HEAP_TYPE heap_type) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (num_descriptors > 0)) + if (IsCaptureModeTrack() && (num_descriptors > 0)) { auto dest_descriptor_info = GetDescriptorInfo(dest_start.ptr); auto src_descriptor_info = GetDescriptorInfo(src_start.ptr); @@ -2468,7 +2479,7 @@ void D3D12CaptureManager::PostProcess_ID3D12CommandQueue_UpdateTileMappings( const UINT* range_tile_counts, D3D12_TILE_MAPPING_FLAGS flags) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { auto resource_wrapper = reinterpret_cast(resource); auto heap_wrapper = reinterpret_cast(heap); @@ -2490,7 +2501,7 @@ void D3D12CaptureManager::PostProcess_ID3D12CommandQueue_CopyTileMappings( D3D12_TILE_MAPPING_FLAGS flags) { // TODO: Implement tracking for CopyTileMappings. - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { GFXRECON_LOG_ERROR("ID3D12CommandQueue::CopyTileMappings support is not implemented for trimmed capture."); } @@ -2502,7 +2513,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device_CreateShaderResourceView( const D3D12_SHADER_RESOURCE_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackDescriptorResources(DestDescriptor.ptr, pResource); @@ -2520,7 +2531,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device_CreateUnorderedAccessView( const D3D12_UNORDERED_ACCESS_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackDescriptorResources(DestDescriptor.ptr, pResource, pCounterResource); } @@ -2531,7 +2542,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device_CreateRenderTargetView(ID3D12 const D3D12_RENDER_TARGET_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackDescriptorResources(DestDescriptor.ptr, pResource); } @@ -2542,7 +2553,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device_CreateDepthStencilView(ID3D12 const D3D12_DEPTH_STENCIL_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackDescriptorResources(DestDescriptor.ptr, pResource); } @@ -2553,7 +2564,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device_CreateConstantBufferView( const D3D12_CONSTANT_BUFFER_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { D3D12_GPU_VIRTUAL_ADDRESS address = 0; @@ -2572,7 +2583,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device8_CreateSamplerFeedbackUnorder ID3D12Resource* pFeedbackResource, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackDescriptorResources(DestDescriptor.ptr, pTargetedResource, pFeedbackResource); } @@ -2580,7 +2591,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device8_CreateSamplerFeedbackUnorder void D3D12CaptureManager::PostProcess_ID3D12Debug_EnableDebugLayer(ID3D12Debug_Wrapper* debug_wrapper) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { // Track object id since ID3D12Debug could be released very soon. track_enable_debug_layer_object_id_ = debug_wrapper->GetCaptureId(); @@ -2589,7 +2600,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Debug_EnableDebugLayer(ID3D12Debug_W void D3D12CaptureManager::PostProcess_ID3D12Debug1_EnableDebugLayer(ID3D12Debug1_Wrapper* debug1_wrapper) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { // Track object id since ID3D12Debug1 could be released very soon. track_enable_debug_layer_object_id_ = debug1_wrapper->GetCaptureId(); @@ -2599,7 +2610,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Debug1_EnableDebugLayer(ID3D12Debug1 void D3D12CaptureManager::PostProcess_ID3D12DeviceRemovedExtendedDataSettings_SetAutoBreadcrumbsEnablement( ID3D12DeviceRemovedExtendedDataSettings_Wrapper* dred_wrapper, D3D12_DRED_ENABLEMENT enablement) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { track_enable_dred_info_.dred_settings1_object_id = dred_wrapper->GetCaptureId(); track_enable_dred_info_.set_auto_breadcrumbs_enablement_ = enablement; @@ -2609,7 +2620,7 @@ void D3D12CaptureManager::PostProcess_ID3D12DeviceRemovedExtendedDataSettings_Se void D3D12CaptureManager::PostProcess_ID3D12DeviceRemovedExtendedDataSettings1_SetBreadcrumbContextEnablement( ID3D12DeviceRemovedExtendedDataSettings1_Wrapper* dred1_wrapper, D3D12_DRED_ENABLEMENT enablement) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { track_enable_dred_info_.dred_settings1_object_id = dred1_wrapper->GetCaptureId(); track_enable_dred_info_.set_breadcrumb_context_enablement_ = enablement; @@ -2619,7 +2630,7 @@ void D3D12CaptureManager::PostProcess_ID3D12DeviceRemovedExtendedDataSettings1_S void D3D12CaptureManager::PostProcess_ID3D12DeviceRemovedExtendedDataSettings_SetPageFaultEnablement( ID3D12DeviceRemovedExtendedDataSettings_Wrapper* dred_wrapper, D3D12_DRED_ENABLEMENT enablement) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { track_enable_dred_info_.dred_settings1_object_id = dred_wrapper->GetCaptureId(); track_enable_dred_info_.set_page_fault_enablement_ = enablement; @@ -2629,7 +2640,7 @@ void D3D12CaptureManager::PostProcess_ID3D12DeviceRemovedExtendedDataSettings_Se void D3D12CaptureManager::PostProcess_SetPrivateData( IUnknown_Wrapper* wrapper, HRESULT result, REFGUID Name, UINT DataSize, const void* pData) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackPrivateData(wrapper, Name, DataSize, pData); } @@ -2641,7 +2652,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device1_SetResidencyPriority(ID3D12D ID3D12Pageable* const* ppObjects, const D3D12_RESIDENCY_PRIORITY* pPriorities) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackResidencyPriority(device_wrapper, NumObjects, ppObjects, pPriorities); } @@ -2673,8 +2684,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device5_CreateStateObject(ID3D12Devi REFIID riid, void** state_object) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack && SUCCEEDED(result) && (state_object != nullptr) && - (*state_object != nullptr)) + if (IsCaptureModeTrack() && SUCCEEDED(result) && (state_object != nullptr) && (*state_object != nullptr)) { state_tracker_->TrackCreateStateObject(device5_wrapper, desc, state_object); } @@ -2687,8 +2697,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device7_AddToStateObject(ID3D12Devic REFIID riid, void** new_state_object) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack && SUCCEEDED(result) && (new_state_object != nullptr) && - (*new_state_object != nullptr)) + if (IsCaptureModeTrack() && SUCCEEDED(result) && (new_state_object != nullptr) && (*new_state_object != nullptr)) { state_tracker_->TrackAddToStateObject(device7_wrapper, addition, state_object_to_grow_from, new_state_object); } @@ -2697,7 +2706,7 @@ void D3D12CaptureManager::PostProcess_ID3D12Device7_AddToStateObject(ID3D12Devic void D3D12CaptureManager::PostProcess_ID3D12StateObjectProperties_GetShaderIdentifier( ID3D12StateObjectProperties_Wrapper* properties_wrapper, void* result, LPCWSTR export_name) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackGetShaderIdentifier( properties_wrapper, result, export_name, GetThreadData()->parameter_buffer_.get()); @@ -2711,7 +2720,7 @@ void D3D12CaptureManager::PostProcess_ID3D12StateObjectProperties_GetShaderIdent void D3D12CaptureManager::WriteDxgiAdapterInfoCommand(const format::DxgiAdapterDesc& adapter_desc) { - if (((GetCaptureMode() & kModeWrite) == kModeWrite)) + if ((IsCaptureModeWrite())) { format::DxgiAdapterInfoCommandHeader adapter_info_header; memset(&adapter_info_header, 0, sizeof(adapter_info_header)); @@ -2765,7 +2774,7 @@ void D3D12CaptureManager::PostProcess_CreateDXGIFactory2(HRESULT result, UINT Fl void D3D12CaptureManager::WriteDx12DriverInfo() { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { std::string driverinfo = ""; std::vector adapter_luids; @@ -2781,7 +2790,7 @@ void D3D12CaptureManager::WriteDx12DriverInfo() void D3D12CaptureManager::WriteDriverInfoCommand(const std::string& info) { - if (((GetCaptureMode() & kModeWrite) == kModeWrite)) + if ((IsCaptureModeWrite())) { format::DriverInfoBlock driver_info_header = {}; @@ -2802,7 +2811,7 @@ void D3D12CaptureManager::WriteDriverInfoCommand(const std::string& info) void D3D12CaptureManager::WriteDx12RuntimeInfo() { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { static bool wrote_dx12_runtime_info = false; @@ -2850,7 +2859,7 @@ void D3D12CaptureManager::WriteDx12RuntimeInfo() void D3D12CaptureManager::WriteDx2RuntimeInfoCommand(const format::Dx12RuntimeInfo& runtime_info) { - if (((GetCaptureMode() & kModeWrite) == kModeWrite)) + if ((IsCaptureModeWrite())) { format::Dx12RuntimeInfoCommandHeader dx12_runtime_info_header; memset(&dx12_runtime_info_header, 0, sizeof(dx12_runtime_info_header)); diff --git a/framework/encode/d3d12_capture_manager.h b/framework/encode/d3d12_capture_manager.h index 4be48a9582..3dbfff1764 100644 --- a/framework/encode/d3d12_capture_manager.h +++ b/framework/encode/d3d12_capture_manager.h @@ -41,15 +41,17 @@ GFXRECON_BEGIN_NAMESPACE(gfxrecon) GFXRECON_BEGIN_NAMESPACE(encode) -class D3D12CaptureManager : public CaptureManager +class D3D12CaptureManager : public ApiCaptureManagerBase { public: - static D3D12CaptureManager* Get() { return instance_; } - + static D3D12CaptureManager* Get() { return singleton_; } // Creates the capture manager instance if none exists, or increments a reference count if an instance already // exists. static bool CreateInstance(); + static D3D12CaptureManager* InitSingleton(); + static void DestroySingleton(); + // Decrement the instance reference count, releasing resources when the count reaches zero. Ignored if the count is // already zero. static void DestroyInstance(); @@ -157,7 +159,7 @@ class D3D12CaptureManager : public CaptureManager template void EndCreateMethodCallCapture(HRESULT result, REFIID riid, void** handle, ParentWrapper* create_object_wrapper) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && SUCCEEDED(result)) + if (IsCaptureModeTrack() && SUCCEEDED(result)) { if ((handle != nullptr) && (*handle != nullptr)) { @@ -184,7 +186,7 @@ class D3D12CaptureManager : public CaptureManager GetHandlesFunc func, GetHandlesArgs... args) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); @@ -205,7 +207,7 @@ class D3D12CaptureManager : public CaptureManager { resource_value_annotator_->RemoveObjectGPUVA(wrapper); } - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->RemoveEntry(wrapper); state_tracker_->TrackRelease(wrapper); @@ -740,7 +742,7 @@ class D3D12CaptureManager : public CaptureManager protected: D3D12CaptureManager(); - virtual ~D3D12CaptureManager() override {} + virtual ~D3D12CaptureManager() {} virtual void CreateStateTracker() override { state_tracker_ = std::make_unique(); } @@ -790,7 +792,7 @@ class D3D12CaptureManager : public CaptureManager void PrePresent(IDXGISwapChain_Wrapper* wrapper); void PostPresent(IDXGISwapChain_Wrapper* wrapper, UINT flags); - static D3D12CaptureManager* instance_; + static D3D12CaptureManager* singleton_; std::set mapped_resources_; ///< Track mapped resources for unassisted tracking mode. DxgiDispatchTable dxgi_dispatch_table_; ///< DXGI dispatch table for functions retrieved from the DXGI DLL. D3D12DispatchTable d3d12_dispatch_table_; ///< D3D12 dispatch table for functions retrieved from the D3D12 DLL. diff --git a/framework/encode/vulkan_capture_manager.cpp b/framework/encode/vulkan_capture_manager.cpp index 0d74bb3af7..d3fd715b9e 100644 --- a/framework/encode/vulkan_capture_manager.cpp +++ b/framework/encode/vulkan_capture_manager.cpp @@ -54,23 +54,14 @@ GFXRECON_BEGIN_NAMESPACE(gfxrecon) GFXRECON_BEGIN_NAMESPACE(encode) -VulkanCaptureManager* VulkanCaptureManager::instance_ = nullptr; +VulkanCaptureManager* VulkanCaptureManager::singleton_ = nullptr; VulkanLayerTable VulkanCaptureManager::vulkan_layer_table_; bool VulkanCaptureManager::CreateInstance() { - bool result = CaptureManager::CreateInstance([]() -> CaptureManager* { return instance_; }, - []() { - assert(instance_ == nullptr); - instance_ = new VulkanCaptureManager(); - }, - []() { - if (instance_) - { - delete instance_; - instance_ = nullptr; - } - }); + + bool result = CaptureManager::CreateInstance(); + GFXRECON_ASSERT(singleton_); GFXRECON_LOG_INFO(" Vulkan Header Version %u.%u.%u", VK_VERSION_MAJOR(VK_HEADER_VERSION_COMPLETE), @@ -80,19 +71,35 @@ bool VulkanCaptureManager::CreateInstance() return result; } +VulkanCaptureManager* VulkanCaptureManager::InitSingleton() +{ + if (singleton_) + { + singleton_ = new VulkanCaptureManager(); + } + return singleton_; +} + +void VulkanCaptureManager::DestroySingleton() +{ + if (singleton_) + { + delete singleton_; + singleton_ = nullptr; + } +} + void VulkanCaptureManager::DestroyInstance() { - CaptureManager::DestroyInstance([]() -> const CaptureManager* { return instance_; }); + GFXRECON_ASSERT(singleton_ && singleton_->common_manager_); + singleton_->common_manager_->DestroyInstance(singleton_); } void VulkanCaptureManager::WriteTrackedState(util::FileOutputStream* file_stream, format::ThreadId thread_id) { - VulkanStateWriter state_writer(file_stream, compressor_.get(), thread_id); + VulkanStateWriter state_writer(file_stream, GetCompressor(), thread_id); uint64_t n_blocks = state_tracker_->WriteState(&state_writer, GetCurrentFrame()); - block_index_ += n_blocks; - - auto thread_data = GetThreadData(); - thread_data->block_index_ = block_index_; + common_manager_->IncrementBlockIndex(n_blocks); } void VulkanCaptureManager::SetLayerFuncs(PFN_vkCreateInstance create_instance, PFN_vkCreateDevice create_device) @@ -139,7 +146,7 @@ void VulkanCaptureManager::WriteResizeWindowCmd2(format::HandleId s uint32_t height, VkSurfaceTransformFlagBitsKHR pre_transform) { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { auto thread_data = GetThreadData(); @@ -184,7 +191,7 @@ void VulkanCaptureManager::WriteCreateHardwareBufferCmd(format::HandleId AHardwareBuffer* buffer, const std::vector& plane_info) { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { #if defined(VK_USE_PLATFORM_ANDROID_KHR) assert(buffer != nullptr); @@ -250,7 +257,7 @@ void VulkanCaptureManager::WriteCreateHardwareBufferCmd(format::HandleId void VulkanCaptureManager::WriteDestroyHardwareBufferCmd(AHardwareBuffer* buffer) { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { #if defined(VK_USE_PLATFORM_ANDROID_KHR) assert(buffer != nullptr); @@ -277,7 +284,7 @@ void VulkanCaptureManager::WriteDestroyHardwareBufferCmd(AHardwareBuffer* buffer void VulkanCaptureManager::WriteSetDevicePropertiesCommand(format::HandleId physical_device_id, const VkPhysicalDeviceProperties& properties) { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { format::SetDevicePropertiesCommand properties_cmd; @@ -310,7 +317,7 @@ void VulkanCaptureManager::WriteSetDevicePropertiesCommand(format::HandleId void VulkanCaptureManager::WriteSetDeviceMemoryPropertiesCommand( format::HandleId physical_device_id, const VkPhysicalDeviceMemoryProperties& memory_properties) { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { format::SetDeviceMemoryPropertiesCommand memory_properties_cmd; @@ -367,7 +374,7 @@ void VulkanCaptureManager::WriteSetOpaqueAddressCommand(format::HandleId device_ format::HandleId object_id, uint64_t address) { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { format::SetOpaqueAddressCommand opaque_address_cmd; @@ -392,7 +399,7 @@ void VulkanCaptureManager::WriteSetRayTracingShaderGroupHandlesCommand(format::H size_t data_size, const void* data) { - if ((GetCaptureMode() & kModeWrite) == kModeWrite) + if (IsCaptureModeWrite()) { format::SetRayTracingShaderGroupHandlesCommandHeader set_handles_cmd; @@ -552,7 +559,7 @@ VkResult VulkanCaptureManager::OverrideCreateInstance(const VkInstanceCreateInfo if (CreateInstance()) { - if (instance_->GetPageGuardMemoryMode() == kMemoryModeExternal) + if (singleton_->IsPageGuardMemoryModeExternal()) { assert(pCreateInfo != nullptr); @@ -658,7 +665,7 @@ VkResult VulkanCaptureManager::OverrideCreateDevice(VkPhysicalDevice modified_extensions.push_back(entry); - if (GetPageGuardMemoryMode() == kMemoryModeExternal) + if (IsPageGuardMemoryModeExternal()) { if (util::platform::StringCompare(entry, VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME) == 0) { @@ -671,7 +678,7 @@ VkResult VulkanCaptureManager::OverrideCreateDevice(VkPhysicalDevice } } - if (GetPageGuardMemoryMode() == kMemoryModeExternal) + if (IsPageGuardMemoryModeExternal()) { if (!has_ext_mem) { @@ -733,7 +740,7 @@ VkResult VulkanCaptureManager::OverrideCreateDevice(VkPhysicalDevice // Track state of physical device properties and features at device creation wrapper->property_feature_info = property_feature_info; - if ((GetCaptureMode() & kModeTrack) != kModeTrack) + if (!IsCaptureModeTrack()) { // The state tracker will set this value when it is enabled. When state tracking is disabled it is set here // to ensure it is available. @@ -839,7 +846,7 @@ VkResult VulkanCaptureManager::OverrideCreateBuffer(VkDevice WriteSetOpaqueAddressCommand(device_wrapper->handle_id, buffer_wrapper->handle_id, address); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackBufferDeviceAddress(device, *pBuffer, address); } @@ -924,7 +931,7 @@ VulkanCaptureManager::OverrideCreateAccelerationStructureKHR(VkDevice WriteSetOpaqueAddressCommand(device_wrapper->handle_id, accel_struct_wrapper->handle_id, address); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackAccelerationStructureKHRDeviceAddress(device, *pAccelerationStructureKHR, address); } @@ -940,7 +947,7 @@ void VulkanCaptureManager::OverrideCmdBuildAccelerationStructuresKHR( const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackTLASBuildCommand(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); } @@ -994,7 +1001,7 @@ VkResult VulkanCaptureManager::OverrideAllocateMemory(VkDevice } } - if (GetPageGuardMemoryMode() == kMemoryModeExternal) + if (IsPageGuardMemoryModeExternal()) { VkMemoryPropertyFlags properties = GetMemoryProperties(device_wrapper, pAllocateInfo->memoryTypeIndex); @@ -1072,7 +1079,7 @@ VkResult VulkanCaptureManager::OverrideAllocateMemory(VkDevice WriteSetOpaqueAddressCommand(device_wrapper->handle_id, memory_wrapper->handle_id, address); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackDeviceMemoryDeviceAddress(device, *pMemory, address); } @@ -1080,7 +1087,7 @@ VkResult VulkanCaptureManager::OverrideAllocateMemory(VkDevice memory_wrapper->external_allocation = external_memory; - if ((GetCaptureMode() & kModeTrack) != kModeTrack) + if (!IsCaptureModeTrack()) { // The state tracker will set this value when it is enabled. When state tracking is disabled it is set // here to ensure it is available for mapped memory tracking. @@ -1340,7 +1347,7 @@ VulkanCaptureManager::OverrideCreateRayTracingPipelinesKHR(VkDevice WriteSetRayTracingShaderGroupHandlesCommand( device_wrapper->handle_id, pipeline_wrapper->handle_id, data_size, data.data()); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { state_tracker_->TrackRayTracingShaderGroupHandles( device, pPipelines[i], data_size, data.data()); @@ -1471,7 +1478,7 @@ VkResult VulkanCaptureManager::OverrideDeferredOperationJoinKHR(VkDevice device, if ((deferred_command_result == VK_SUCCESS) || (deferred_command_result == VK_OPERATION_NOT_DEFERRED_KHR)) { - DeferredOperationPostProcess(device, operation, (GetCaptureMode() & kModeTrack) == kModeTrack); + DeferredOperationPostProcess(device, operation, IsCaptureModeTrack()); } } @@ -1491,7 +1498,7 @@ VkResult VulkanCaptureManager::OverrideGetDeferredOperationResultKHR(VkDevice de // hardware/driver return VK_OPERATION_NOT_DEFERRED_KHR: // 1. The deferred operation finished and returned VK_SUCCESS. // 2. No command has been deferred on the deferred operation object. - DeferredOperationPostProcess(device, operation, (GetCaptureMode() & kModeTrack) == kModeTrack); + DeferredOperationPostProcess(device, operation, IsCaptureModeTrack()); } return result; @@ -1598,7 +1605,7 @@ void VulkanCaptureManager::ProcessEnumeratePhysicalDevices(VkResult res instance_table->GetPhysicalDeviceProperties(physical_device_handle, &properties); instance_table->GetPhysicalDeviceMemoryProperties(physical_device_handle, &memory_properties); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { // Let the state tracker process the memory properties. assert(state_tracker_ != nullptr); @@ -1913,7 +1920,7 @@ void VulkanCaptureManager::PreProcess_vkCreateXlibSurfaceKHR(VkInstance assert(pCreateInfo != nullptr); if (pCreateInfo && !GetTrimKey().empty()) { - if (!keyboard_.Initialize(pCreateInfo->dpy)) + if (!GetKeyboard().Initialize(pCreateInfo->dpy)) { GFXRECON_LOG_ERROR("Failed to initialize Xlib keyboard capture trigger"); } @@ -1940,7 +1947,7 @@ void VulkanCaptureManager::PreProcess_vkCreateXcbSurfaceKHR(VkInstance assert(pCreateInfo != nullptr); if (pCreateInfo && !GetTrimKey().empty()) { - if (!keyboard_.Initialize(pCreateInfo->connection)) + if (!GetKeyboard().Initialize(pCreateInfo->connection)) { GFXRECON_LOG_ERROR("Failed to initialize XCB keyboard capture trigger"); } @@ -2004,7 +2011,7 @@ void VulkanCaptureManager::PostProcess_vkMapMemory(VkResult result, if (wrapper->mapped_data == nullptr) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackMappedMemory(device, memory, (*ppData), offset, size, flags); @@ -2044,12 +2051,12 @@ void VulkanCaptureManager::PostProcess_vkMapMemory(VkResult result, bool use_shadow_memory = true; bool use_write_watch = false; - if (GetPageGuardMemoryMode() == kMemoryModeExternal) + if (IsPageGuardMemoryModeExternal()) { use_shadow_memory = false; use_write_watch = true; } - else if ((GetPageGuardMemoryMode() == kMemoryModeShadowPersistent) && + else if (IsPageGuardMemoryModeShadowPersistent() && (wrapper->shadow_allocation == util::PageGuardManager::kNullShadowHandle)) { wrapper->shadow_allocation = manager->AllocatePersistentShadowMemory(static_cast(size)); @@ -2069,7 +2076,7 @@ void VulkanCaptureManager::PostProcess_vkMapMemory(VkResult result, else if (GetMemoryTrackingMode() == CaptureSettings::MemoryTrackingMode::kUnassisted) { // Need to keep track of mapped memory objects so memory content can be written at queue submit. - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); mapped_memory_.insert(wrapper); } } @@ -2207,12 +2214,12 @@ void VulkanCaptureManager::PreProcess_vkUnmapMemory(VkDevice device, VkDeviceMem WriteFillMemoryCmd(wrapper->handle_id, 0, size, wrapper->mapped_data); { - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); mapped_memory_.erase(wrapper); } } - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackMappedMemory(device, memory, nullptr, 0, 0, 0); @@ -2257,7 +2264,7 @@ void VulkanCaptureManager::PreProcess_vkFreeMemory(VkDevice } else if (GetMemoryTrackingMode() == CaptureSettings::MemoryTrackingMode::kUnassisted) { - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); mapped_memory_.erase(wrapper); } } @@ -2282,12 +2289,12 @@ void VulkanCaptureManager::PostProcess_vkFreeMemory(VkDevice util::PageGuardManager* manager = util::PageGuardManager::Get(); assert(manager != nullptr); - if ((GetPageGuardMemoryMode() == kMemoryModeExternal) && (wrapper->external_allocation != nullptr)) + if ((IsPageGuardMemoryModeExternal()) && (wrapper->external_allocation != nullptr)) { size_t external_memory_size = manager->GetAlignedSize(static_cast(wrapper->allocation_size)); manager->FreeMemory(wrapper->external_allocation, external_memory_size); } - else if ((GetPageGuardMemoryMode() == kMemoryModeShadowPersistent) && + else if (IsPageGuardMemoryModeShadowPersistent() && (wrapper->shadow_allocation != util::PageGuardManager::kNullShadowHandle)) { manager->FreePersistentShadowMemory(wrapper->shadow_allocation); @@ -2310,7 +2317,7 @@ void VulkanCaptureManager::PostProcess_vkAcquireFullScreenExclusiveModeEXT(VkRes GFXRECON_UNREFERENCED_PARAMETER(device); GFXRECON_UNREFERENCED_PARAMETER(swapchain); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackAcquireFullScreenExclusiveMode(device, swapchain); @@ -2326,7 +2333,7 @@ void VulkanCaptureManager::PostProcess_vkGetPhysicalDeviceSurfacePresentModes2EX { if ((pPresentModeCount != nullptr) && (pPresentModes != nullptr) && (pSurfaceInfo != nullptr)) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert(state_tracker_ != nullptr); state_tracker_->TrackPhysicalDeviceSurfacePresentModes( @@ -2346,7 +2353,7 @@ void VulkanCaptureManager::PostProcess_vkReleaseFullScreenExclusiveModeEXT(VkRes GFXRECON_UNREFERENCED_PARAMETER(device); GFXRECON_UNREFERENCED_PARAMETER(swapchain); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackReleaseFullScreenExclusiveMode(device, swapchain); @@ -2362,7 +2369,7 @@ void VulkanCaptureManager::PostProcess_vkGetDeviceGroupSurfacePresentModesKHR(Vk if (pModes != nullptr) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert(state_tracker_ != nullptr); state_tracker_->TrackDeviceGroupSurfacePresentModes(device, surface, pModes); @@ -2380,7 +2387,7 @@ void VulkanCaptureManager::PostProcess_vkGetDeviceGroupSurfacePresentModes2EXT( if ((pSurfaceInfo != nullptr) && (pModes != nullptr)) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert(state_tracker_ != nullptr); state_tracker_->TrackDeviceGroupSurfacePresentModes( @@ -2403,7 +2410,7 @@ void VulkanCaptureManager::PreProcess_vkQueueSubmit(VkQueue queue, PreQueueSubmit(); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { if (pSubmits) { @@ -2430,7 +2437,7 @@ void VulkanCaptureManager::PreProcess_vkQueueSubmit2(VkQueue queue, PreQueueSubmit(); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { std::vector command_buffs; if (pSubmits) @@ -2465,7 +2472,7 @@ void VulkanCaptureManager::QueueSubmitWriteFillMemoryCmd() } else if (GetMemoryTrackingMode() == CaptureSettings::MemoryTrackingMode::kUnassisted) { - std::lock_guard lock(mapped_memory_lock_); + std::lock_guard lock(GetMappedMemoryLock()); for (auto wrapper : mapped_memory_) { @@ -2610,7 +2617,7 @@ void VulkanCaptureManager::PostProcess_vkSetPrivateData(VkResult result if (privateDataSlot != VK_NULL_HANDLE) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert(state_tracker_ != nullptr); state_tracker_->TrackSetPrivateData(device, objectType, objectHandle, privateDataSlot, data); @@ -2626,7 +2633,7 @@ void VulkanCaptureManager::PostProcess_vkSetLocalDimmingAMD(VkDevice devic if (swapChain != VK_NULL_HANDLE) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackSetLocalDimmingAMD(device, swapChain, localDimmingEnable); diff --git a/framework/encode/vulkan_capture_manager.h b/framework/encode/vulkan_capture_manager.h index 4d6134b700..f6315dd192 100644 --- a/framework/encode/vulkan_capture_manager.h +++ b/framework/encode/vulkan_capture_manager.h @@ -54,15 +54,18 @@ GFXRECON_BEGIN_NAMESPACE(gfxrecon) GFXRECON_BEGIN_NAMESPACE(encode) -class VulkanCaptureManager : public CaptureManager +class VulkanCaptureManager : public ApiCaptureManagerBase { public: - static VulkanCaptureManager* Get() { return instance_; } + static VulkanCaptureManager* Get() { return singleton_; } // Creates the capture manager instance if none exists, or increments a reference count if an instance already // exists. static bool CreateInstance(); + static VulkanCaptureManager* InitSingleton(); + static void DestroySingleton(); + // Decrement the instance reference count, releasing resources when the count reaches zero. Ignored if the count is // already zero. static void DestroyInstance(); @@ -90,7 +93,7 @@ class VulkanCaptureManager : public CaptureManager typename Wrapper::HandleType* handle, const CreateInfo* create_info) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && result == VK_SUCCESS) + if (IsCaptureModeTrack() && result == VK_SUCCESS) { assert(state_tracker_ != nullptr); @@ -112,7 +115,7 @@ class VulkanCaptureManager : public CaptureManager typename Wrapper::HandleType* handles, const AllocateInfo* alloc_info) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS) && (handles != nullptr)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS) && (handles != nullptr)) { assert(state_tracker_ != nullptr); @@ -135,7 +138,7 @@ class VulkanCaptureManager : public CaptureManager typename Wrapper::HandleType* handles, const CreateInfo* create_infos) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && + if (IsCaptureModeTrack() && ((result == VK_SUCCESS) || (result == VK_OPERATION_DEFERRED_KHR) || (result == VK_OPERATION_NOT_DEFERRED_KHR) || (result == VK_INCOMPLETE)) && (handles != nullptr)) @@ -166,7 +169,7 @@ class VulkanCaptureManager : public CaptureManager HandleStruct* handle_structs, std::function unwrap_struct_handle) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && ((result == VK_SUCCESS) || (result == VK_INCOMPLETE)) && + if (IsCaptureModeTrack() && ((result == VK_SUCCESS) || (result == VK_INCOMPLETE)) && (handle_structs != nullptr)) { assert(state_tracker_ != nullptr); @@ -189,7 +192,7 @@ class VulkanCaptureManager : public CaptureManager template void EndDestroyApiCallCapture(typename Wrapper::HandleType handle) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->RemoveEntry(handle); @@ -202,7 +205,7 @@ class VulkanCaptureManager : public CaptureManager template void EndDestroyApiCallCapture(uint32_t count, const typename Wrapper::HandleType* handles) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (handles != nullptr)) + if (IsCaptureModeTrack() && (handles != nullptr)) { assert(state_tracker_ != nullptr); @@ -231,7 +234,7 @@ class VulkanCaptureManager : public CaptureManager auto thread_data = GetThreadData(); GFXRECON_ASSERT(thread_data != nullptr); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackCommand(command_buffer, thread_data->call_id_, thread_data->parameter_buffer_.get()); @@ -248,7 +251,7 @@ class VulkanCaptureManager : public CaptureManager auto thread_data = GetThreadData(); GFXRECON_ASSERT(thread_data != nullptr); - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackCommand( @@ -344,8 +347,7 @@ class VulkanCaptureManager : public CaptureManager uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (pQueueFamilyPropertyCount != nullptr) && - (pQueueFamilyProperties != nullptr)) + if (IsCaptureModeTrack() && (pQueueFamilyPropertyCount != nullptr) && (pQueueFamilyProperties != nullptr)) { assert(state_tracker_ != nullptr); state_tracker_->TrackPhysicalDeviceQueueFamilyProperties( @@ -358,8 +360,7 @@ class VulkanCaptureManager : public CaptureManager uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (pQueueFamilyPropertyCount != nullptr) && - (pQueueFamilyProperties != nullptr)) + if (IsCaptureModeTrack() && (pQueueFamilyPropertyCount != nullptr) && (pQueueFamilyProperties != nullptr)) { assert(state_tracker_ != nullptr); state_tracker_->TrackPhysicalDeviceQueueFamilyProperties2( @@ -373,7 +374,7 @@ class VulkanCaptureManager : public CaptureManager VkSurfaceKHR surface, VkBool32* pSupported) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS) && (pSupported != nullptr)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS) && (pSupported != nullptr)) { assert(state_tracker_ != nullptr); state_tracker_->TrackPhysicalDeviceSurfaceSupport(physicalDevice, queueFamilyIndex, surface, *pSupported); @@ -385,8 +386,7 @@ class VulkanCaptureManager : public CaptureManager VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS) && - (pSurfaceCapabilities != nullptr)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS) && (pSurfaceCapabilities != nullptr)) { assert(state_tracker_ != nullptr); state_tracker_->TrackPhysicalDeviceSurfaceCapabilities(physicalDevice, surface, pSurfaceCapabilities); @@ -400,8 +400,7 @@ class VulkanCaptureManager : public CaptureManager { GFXRECON_UNREFERENCED_PARAMETER(physicalDevice); - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS) && - (pSurfaceCapabilities != nullptr)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS) && (pSurfaceCapabilities != nullptr)) { assert(state_tracker_ != nullptr); state_tracker_->TrackPhysicalDeviceSurfaceCapabilities2( @@ -415,8 +414,8 @@ class VulkanCaptureManager : public CaptureManager uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS) && - (pSurfaceFormatCount != nullptr) && (pSurfaceFormats != nullptr)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS) && (pSurfaceFormatCount != nullptr) && + (pSurfaceFormats != nullptr)) { assert(state_tracker_ != nullptr); state_tracker_->TrackPhysicalDeviceSurfaceFormats( @@ -430,8 +429,8 @@ class VulkanCaptureManager : public CaptureManager uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS) && - (pSurfaceFormatCount != nullptr) && (pSurfaceFormats != nullptr)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS) && (pSurfaceFormatCount != nullptr) && + (pSurfaceFormats != nullptr)) { assert(state_tracker_ != nullptr); state_tracker_->TrackPhysicalDeviceSurfaceFormats2( @@ -447,7 +446,7 @@ class VulkanCaptureManager : public CaptureManager { if ((pPresentModeCount != nullptr) && (pPresentModes != nullptr)) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert(state_tracker_ != nullptr); state_tracker_->TrackPhysicalDeviceSurfacePresentModes( @@ -488,8 +487,7 @@ class VulkanCaptureManager : public CaptureManager VkFence fence, uint32_t* index) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && - ((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR))) + if (IsCaptureModeTrack() && ((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR))) { assert((state_tracker_ != nullptr) && (index != nullptr)); state_tracker_->TrackSemaphoreSignalState(semaphore); @@ -502,8 +500,7 @@ class VulkanCaptureManager : public CaptureManager const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* index) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && - ((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR))) + if (IsCaptureModeTrack() && ((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR))) { assert((state_tracker_ != nullptr) && (pAcquireInfo != nullptr) && (index != nullptr)); state_tracker_->TrackSemaphoreSignalState(pAcquireInfo->semaphore); @@ -517,8 +514,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkQueuePresentKHR(VkResult result, VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && - ((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR))) + if (IsCaptureModeTrack() && ((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR))) { assert((state_tracker_ != nullptr) && (pPresentInfo != nullptr)); state_tracker_->TrackSemaphoreSignalState( @@ -533,7 +529,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkQueueBindSparse( VkResult result, VkQueue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert((state_tracker_ != nullptr) && ((bindInfoCount == 0) || (pBindInfo != nullptr))); for (uint32_t i = 0; i < bindInfoCount; ++i) @@ -759,7 +755,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkBindBufferMemory( VkResult result, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert(state_tracker_ != nullptr); state_tracker_->TrackBufferMemoryBinding(device, buffer, memory, memoryOffset); @@ -771,7 +767,7 @@ class VulkanCaptureManager : public CaptureManager uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS) && (pBindInfos != nullptr)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS) && (pBindInfos != nullptr)) { assert(state_tracker_ != nullptr); @@ -789,7 +785,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkBindImageMemory( VkResult result, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert(state_tracker_ != nullptr); state_tracker_->TrackImageMemoryBinding(device, image, memory, memoryOffset); @@ -801,7 +797,7 @@ class VulkanCaptureManager : public CaptureManager uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS) && (pBindInfos != nullptr)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS) && (pBindInfos != nullptr)) { assert(state_tracker_ != nullptr); @@ -817,7 +813,7 @@ class VulkanCaptureManager : public CaptureManager const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackBeginRenderPass(commandBuffer, pRenderPassBegin); @@ -828,7 +824,7 @@ class VulkanCaptureManager : public CaptureManager const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR*) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackBeginRenderPass(commandBuffer, pRenderPassBegin); @@ -837,7 +833,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackEndRenderPass(commandBuffer); @@ -846,7 +842,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR*) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackEndRenderPass(commandBuffer); @@ -864,7 +860,7 @@ class VulkanCaptureManager : public CaptureManager uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackImageBarriers(commandBuffer, imageMemoryBarrierCount, pImageMemoryBarriers); @@ -873,7 +869,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackImageBarriers2KHR( @@ -885,7 +881,7 @@ class VulkanCaptureManager : public CaptureManager uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); @@ -894,7 +890,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackTrimCommandPool(device, commandPool); @@ -903,7 +899,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkResetCommandPool(VkResult result, VkDevice, VkCommandPool commandPool, VkCommandPoolResetFlags) { - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert(state_tracker_ != nullptr); state_tracker_->TrackResetCommandPool(commandPool); @@ -915,7 +911,7 @@ class VulkanCaptureManager : public CaptureManager { PostQueueSubmit(); - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert((state_tracker_ != nullptr) && ((submitCount == 0) || (pSubmits != nullptr))); @@ -955,7 +951,7 @@ class VulkanCaptureManager : public CaptureManager { PostQueueSubmit(); - if (((GetCaptureMode() & kModeTrack) == kModeTrack) && (result == VK_SUCCESS)) + if (IsCaptureModeTrack() && (result == VK_SUCCESS)) { assert((state_tracker_ != nullptr) && ((submitCount == 0) || (pSubmits != nullptr))); @@ -996,7 +992,7 @@ class VulkanCaptureManager : public CaptureManager uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackUpdateDescriptorSets( @@ -1009,7 +1005,7 @@ class VulkanCaptureManager : public CaptureManager VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { TrackUpdateDescriptorSetWithTemplate(descriptorSet, descriptorUpdateTemplate, pData); } @@ -1020,7 +1016,7 @@ class VulkanCaptureManager : public CaptureManager VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { TrackUpdateDescriptorSetWithTemplate(descriptorSet, descriptorUpdateTemplate, pData); } @@ -1060,7 +1056,7 @@ class VulkanCaptureManager : public CaptureManager { if (result == VK_SUCCESS) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackResetDescriptorPool(descriptorPool); @@ -1075,7 +1071,7 @@ class VulkanCaptureManager : public CaptureManager uint32_t query, VkQueryControlFlags flags) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackQueryActivation( @@ -1086,7 +1082,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackQueryActivation(commandBuffer, queryPool, query, flags, index); @@ -1098,7 +1094,7 @@ class VulkanCaptureManager : public CaptureManager VkQueryPool queryPool, uint32_t query) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackQueryActivation( @@ -1111,7 +1107,7 @@ class VulkanCaptureManager : public CaptureManager VkQueryPool queryPool, uint32_t query) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackQueryActivation( @@ -1141,7 +1137,7 @@ class VulkanCaptureManager : public CaptureManager uint32_t firstQuery, uint32_t queryCount) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackQueryReset(commandBuffer, queryPool, firstQuery, queryCount); @@ -1150,7 +1146,7 @@ class VulkanCaptureManager : public CaptureManager void PostProcess_vkResetQueryPool(VkDevice, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { - if ((GetCaptureMode() & kModeTrack) == kModeTrack) + if (IsCaptureModeTrack()) { assert(state_tracker_ != nullptr); state_tracker_->TrackQueryReset(queryPool, firstQuery, queryCount); @@ -1262,9 +1258,9 @@ class VulkanCaptureManager : public CaptureManager #endif protected: - VulkanCaptureManager() : CaptureManager(format::ApiFamilyId::ApiFamily_Vulkan) {} + VulkanCaptureManager() : ApiCaptureManagerBase(format::ApiFamilyId::ApiFamily_Vulkan) {} - virtual ~VulkanCaptureManager() override {} + virtual ~VulkanCaptureManager() {} virtual void CreateStateTracker() override { @@ -1335,7 +1331,7 @@ class VulkanCaptureManager : public CaptureManager private: void QueueSubmitWriteFillMemoryCmd(); - static VulkanCaptureManager* instance_; + static VulkanCaptureManager* singleton_; static VulkanLayerTable vulkan_layer_table_; std::set mapped_memory_; // Track mapped memory for unassisted tracking mode. std::unique_ptr state_tracker_; diff --git a/framework/format/api_call_id.h b/framework/format/api_call_id.h index 8ca77f15a5..44bb852209 100644 --- a/framework/format/api_call_id.h +++ b/framework/format/api_call_id.h @@ -50,11 +50,12 @@ constexpr uint16_t GetApiCallFamily(uint32_t call_id) enum ApiFamilyId : uint16_t { - ApiFamily_None = 0, - ApiFamily_Vulkan = 1, - ApiFamily_Dxgi = 2, - ApiFamily_D3D12 = 3, - ApiFamily_AGS = 4, + ApiFamily_None = 0, + ApiFamily_Vulkan = 1, + ApiFamily_Dxgi = 2, + ApiFamily_D3D12 = 3, + ApiFamily_AGS = 4, + ApiFamily_Multiple = 0xFFFF }; enum ApiCallId : uint32_t